mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Implements rollout steps 1 and 2 of proposals/274-skillfollow.md. Nothing follows a link or parses .skillfollow yet. Step 1: doctor reports first-level symlinks and junctions in the skills source as info, in text and JSON, without following them. Step 2a: internal/sourcewalk owns traversal of the skills source. Thirteen raw walks move onto it with identical behavior, and a go/parser ratchet fails the tests on any new unclassified walk. Step 2b: internal/sourcefs wraps an os.Root opened at the skills source and refuses any write whose path has a link component. The six write sites the proposal found in review move onto it, including the cross-device copy fallback, and a second ratchet covers raw os write calls. The only behavior change is that an explicit path crossing a link inside the source is refused instead of written through. Refs #274 Release-As: 0.24.3
405 lines
12 KiB
Go
405 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/git"
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/resource"
|
|
"skillshare/internal/sourcefs"
|
|
"skillshare/internal/sync"
|
|
)
|
|
|
|
// skillContentRequest is the JSON body for PUT /api/resources/{name}/content
|
|
type skillContentRequest struct {
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
// skillContentResponse is the JSON response on successful save.
|
|
type skillContentResponse struct {
|
|
BytesWritten int `json:"bytesWritten"`
|
|
Path string `json:"path"`
|
|
ContentType string `json:"contentType"`
|
|
SavedAt string `json:"savedAt"`
|
|
}
|
|
|
|
// handlePutSkillContent saves the SKILL.md (or agent markdown) content to disk.
|
|
// Request body: {"content": "..."}
|
|
// Writes atomically via <file>.tmp + rename.
|
|
func (s *Server) handlePutSkillContent(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
agentsSource := s.agentsSource()
|
|
s.mu.RUnlock()
|
|
|
|
name := r.PathValue("name")
|
|
kind := r.URL.Query().Get("kind")
|
|
if kind != "" && kind != "skill" && kind != "agent" {
|
|
writeError(w, http.StatusBadRequest, "invalid kind: "+kind)
|
|
return
|
|
}
|
|
|
|
var req skillContentRequest
|
|
if err := decodeJSON(w, r, &req, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body: "+err.Error())
|
|
}
|
|
return
|
|
}
|
|
|
|
// Reject writes above a conservative ceiling to guard against accidents.
|
|
const maxBytes = 2 * 1024 * 1024 // 2 MiB
|
|
if len(req.Content) > maxBytes {
|
|
writeError(w, http.StatusRequestEntityTooLarge, fmt.Sprintf("content exceeds %d bytes", maxBytes))
|
|
return
|
|
}
|
|
|
|
targetPath, resolvedKind, err := s.resolveEditableSkillPath(source, agentsSource, name, kind)
|
|
if err != nil {
|
|
writeError(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
if resolvedKind == "skill" {
|
|
err = writeSourceFileAtomic(source, targetPath, []byte(req.Content))
|
|
} else {
|
|
err = writeFileAtomic(targetPath, []byte(req.Content), 0o644)
|
|
}
|
|
if errors.Is(err, sourcefs.ErrLink) {
|
|
writeError(w, http.StatusConflict, err.Error())
|
|
return
|
|
}
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to save: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("skill.edit", "ok", start, map[string]any{
|
|
"name": name,
|
|
"kind": resolvedKind,
|
|
"path": targetPath,
|
|
"length": len(req.Content),
|
|
}, "")
|
|
|
|
writeJSON(w, skillContentResponse{
|
|
BytesWritten: len(req.Content),
|
|
Path: targetPath,
|
|
ContentType: "text/markdown",
|
|
SavedAt: time.Now().UTC().Format(time.RFC3339),
|
|
})
|
|
}
|
|
|
|
// patchSourceRequest is the JSON body for PATCH /api/resources/{name}/source.
|
|
type patchSourceRequest struct {
|
|
Source string `json:"source"`
|
|
}
|
|
|
|
// handlePatchSkillSource updates the source URL for a tracked skill or agent.
|
|
// It updates the metadata store entry and, for tracked repos with a .git directory,
|
|
// also updates the git remote origin URL.
|
|
func (s *Server) handlePatchSkillSource(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
name := r.PathValue("name")
|
|
kind := r.URL.Query().Get("kind") // optional: "skill" or "agent"
|
|
|
|
var req patchSourceRequest
|
|
if err := decodeJSON(w, r, &req, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body: "+err.Error())
|
|
}
|
|
return
|
|
}
|
|
req.Source = strings.TrimSpace(req.Source)
|
|
if req.Source == "" {
|
|
writeError(w, http.StatusBadRequest, "source cannot be empty")
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
parsed, parseErr := install.ParseSourceWithOptions(req.Source, s.parseOpts())
|
|
if parseErr != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid source: "+parseErr.Error())
|
|
return
|
|
}
|
|
|
|
newRepoURL := req.Source
|
|
if parsed.IsGit() {
|
|
newRepoURL = parsed.CloneURL
|
|
}
|
|
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
agentsSource := s.agentsSource()
|
|
|
|
m := s.findMetadataEntry(name, kind, source, agentsSource)
|
|
if m == nil {
|
|
writeError(w, http.StatusNotFound, "resource not found: "+name)
|
|
return
|
|
}
|
|
entry := m.Entry
|
|
if entry == nil {
|
|
entry = &install.MetadataEntry{}
|
|
}
|
|
|
|
// Detect tracked repo by walking up for .git, bounded by storeDir.
|
|
// This handles both direct tracked repos (IsInRepo=true) and --into repos.
|
|
repoRoot := findRepoRoot(m.SourcePath, m.StoreDir)
|
|
isTracked := repoRoot != ""
|
|
|
|
// For tracked repos with missing metadata, infer RepoURL from git remote.
|
|
oldRepoURL := entry.RepoURL
|
|
if oldRepoURL == "" && isTracked {
|
|
if remoteURL, err := git.GetRemoteURL(repoRoot); err == nil && remoteURL != "" {
|
|
oldRepoURL = remoteURL
|
|
}
|
|
}
|
|
|
|
oldSource := entry.Source
|
|
updated := 0
|
|
|
|
// Update git remote origin before persisting metadata so the API does not
|
|
// report success while the on-disk repository still points at the old URL.
|
|
if repoRoot != "" {
|
|
if err := git.SetRemoteURL(repoRoot, newRepoURL); err != nil {
|
|
s.writeOpsLog("skill.source", "error", start, map[string]any{
|
|
"name": name,
|
|
"kind": m.Kind,
|
|
"oldSource": oldSource,
|
|
"newSource": req.Source,
|
|
}, err.Error())
|
|
writeError(w, http.StatusInternalServerError, "failed to update git remote URL: "+err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
if m.Entry == nil {
|
|
m.Store.Set(m.RelPath, entry)
|
|
}
|
|
|
|
// For tracked repos, update ALL skills sharing the same git repo.
|
|
if oldRepoURL != "" && isTracked {
|
|
oldBase := strings.TrimSuffix(oldRepoURL, ".git")
|
|
newBase := strings.TrimSuffix(newRepoURL, ".git")
|
|
for _, key := range m.Store.List() {
|
|
e := m.Store.Get(key)
|
|
if e == nil || e.RepoURL != oldRepoURL {
|
|
continue
|
|
}
|
|
e.RepoURL = newRepoURL
|
|
if oldBase != newBase {
|
|
e.Source = strings.Replace(e.Source, oldBase, newBase, 1)
|
|
}
|
|
updated++
|
|
}
|
|
// Also update the entry itself if it was freshly created (no RepoURL yet).
|
|
if entry.RepoURL != newRepoURL {
|
|
entry.Source = req.Source
|
|
entry.RepoURL = newRepoURL
|
|
updated++
|
|
}
|
|
} else {
|
|
entry.Source = req.Source
|
|
entry.RepoURL = newRepoURL
|
|
updated = 1
|
|
}
|
|
|
|
if err := m.Store.Save(m.StoreDir); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to save metadata: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("skill.source", "ok", start, map[string]any{
|
|
"name": name,
|
|
"kind": m.Kind,
|
|
"oldSource": oldSource,
|
|
"newSource": req.Source,
|
|
"updated": updated,
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{
|
|
"success": true,
|
|
"source": entry.Source,
|
|
"repoUrl": entry.RepoURL,
|
|
"updated": updated,
|
|
})
|
|
}
|
|
|
|
// metadataLookup holds the result of findMetadataEntry.
|
|
type metadataLookup struct {
|
|
Store *install.MetadataStore
|
|
StoreDir string
|
|
Entry *install.MetadataEntry // nil if resource exists on disk but has no metadata
|
|
RelPath string
|
|
SourcePath string
|
|
IsInRepo bool
|
|
Kind string // "skill" or "agent"
|
|
}
|
|
|
|
// findMetadataEntry looks up a metadata entry by name across skills and agents stores.
|
|
func (s *Server) findMetadataEntry(name, kind, source, agentsSource string) *metadataLookup {
|
|
if kind != "agent" && source != "" {
|
|
discovered, err := sync.DiscoverSourceSkillsAll(source)
|
|
if err == nil {
|
|
for _, d := range discovered {
|
|
if d.FlatName != name && filepath.Base(d.SourcePath) != name {
|
|
continue
|
|
}
|
|
return &metadataLookup{
|
|
Store: s.skillsStore, StoreDir: source,
|
|
Entry: s.skillsStore.GetByPath(d.RelPath),
|
|
RelPath: d.RelPath, SourcePath: d.SourcePath,
|
|
IsInRepo: d.IsInRepo, Kind: "skill",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if kind != "skill" && agentsSource != "" {
|
|
agents, _ := resource.AgentKind{}.Discover(agentsSource)
|
|
for _, d := range agents {
|
|
if d.FlatName != name && d.Name != name {
|
|
continue
|
|
}
|
|
agentKey := strings.TrimSuffix(d.RelPath, ".md")
|
|
return &metadataLookup{
|
|
Store: s.agentsStore, StoreDir: agentsSource,
|
|
Entry: s.agentsStore.GetByPath(agentKey),
|
|
RelPath: agentKey, SourcePath: filepath.Dir(d.SourcePath),
|
|
IsInRepo: d.IsInRepo, Kind: "agent",
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// findRepoRoot walks up from path looking for a tracked-skill .git directory,
|
|
// strictly BELOW root. The source root itself is never a tracked repo (it holds
|
|
// many skills from different sources), and it may legitimately be a GitSync repo
|
|
// — treating it as a tracked repo would rewrite that repo's origin. Returns the
|
|
// directory containing .git, or "" if none found.
|
|
func findRepoRoot(path, root string) string {
|
|
cleanRoot := filepath.Clean(root)
|
|
prefix := cleanRoot + string(filepath.Separator)
|
|
for dir := filepath.Clean(path); dir != filepath.Dir(dir); dir = filepath.Dir(dir) {
|
|
// Stop once we reach the source root (or step outside it): a tracked
|
|
// skill's .git always lives in a subdirectory, never at root itself.
|
|
if dir == cleanRoot || !strings.HasPrefix(dir, prefix) {
|
|
break
|
|
}
|
|
if fi, err := os.Stat(filepath.Join(dir, ".git")); err == nil && fi.IsDir() {
|
|
return dir
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// resolveEditableSkillPath locates the on-disk markdown file for a skill or agent.
|
|
// For skills this is <skillDir>/SKILL.md; for agents this is the agent's single .md file.
|
|
// Returns (absPath, resolvedKind, error).
|
|
func (s *Server) resolveEditableSkillPath(source, agentsSource, name, kind string) (string, string, error) {
|
|
if kind != "agent" && source != "" {
|
|
discovered, err := sync.DiscoverSourceSkillsAll(source)
|
|
if err == nil {
|
|
for _, d := range discovered {
|
|
baseName := filepath.Base(d.SourcePath)
|
|
if d.FlatName != name && baseName != name {
|
|
continue
|
|
}
|
|
skillMd := filepath.Join(d.SourcePath, "SKILL.md")
|
|
if !withinDir(skillMd, d.SourcePath) {
|
|
return "", "", fmt.Errorf("invalid skill path")
|
|
}
|
|
return skillMd, "skill", nil
|
|
}
|
|
}
|
|
}
|
|
|
|
if kind != "skill" && agentsSource != "" {
|
|
agents, _ := resource.AgentKind{}.Discover(agentsSource)
|
|
for _, d := range agents {
|
|
if !matchesAgentName(d, name) {
|
|
continue
|
|
}
|
|
if !withinDir(d.SourcePath, agentsSource) {
|
|
return "", "", fmt.Errorf("invalid agent path")
|
|
}
|
|
return d.SourcePath, "agent", nil
|
|
}
|
|
}
|
|
|
|
return "", "", fmt.Errorf("skill not found: %s", name)
|
|
}
|
|
|
|
// withinDir reports whether path is inside (or equal to) dir.
|
|
// Uses filepath.Rel for correctness on case-insensitive filesystems.
|
|
func withinDir(path, dir string) bool {
|
|
rel, err := filepath.Rel(filepath.Clean(dir), filepath.Clean(path))
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return rel == "." || (!strings.HasPrefix(rel, "..") && !filepath.IsAbs(rel))
|
|
}
|
|
|
|
// writeSourceFileAtomic replaces a file in the skills source through the
|
|
// source-write handle, so neither the temp file nor the rename can reach
|
|
// outside the source through a link, and a file that is a link is refused.
|
|
func writeSourceFileAtomic(source, path string, data []byte) error {
|
|
src, err := sourcefs.Open(source)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer src.Close()
|
|
rel, err := src.Rel(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return src.WriteFileAtomic(rel, data, 0o644)
|
|
}
|
|
|
|
// writeFileAtomic writes data to a temp file in the same directory, then renames it
|
|
// into place. This prevents partial writes if the process is killed mid-write.
|
|
func writeFileAtomic(path string, data []byte, perm os.FileMode) error {
|
|
dir := filepath.Dir(path)
|
|
tmp, err := os.CreateTemp(dir, ".skillshare-"+filepath.Base(path)+".*")
|
|
if err != nil {
|
|
return fmt.Errorf("create temp: %w", err)
|
|
}
|
|
tmpPath := tmp.Name()
|
|
cleanup := func() { _ = os.Remove(tmpPath) }
|
|
|
|
if _, err := tmp.Write(data); err != nil {
|
|
_ = tmp.Close()
|
|
cleanup()
|
|
return fmt.Errorf("write temp: %w", err)
|
|
}
|
|
if err := tmp.Chmod(perm); err != nil {
|
|
_ = tmp.Close()
|
|
cleanup()
|
|
return fmt.Errorf("chmod temp: %w", err)
|
|
}
|
|
if err := tmp.Sync(); err != nil {
|
|
_ = tmp.Close()
|
|
cleanup()
|
|
return fmt.Errorf("sync temp: %w", err)
|
|
}
|
|
if err := tmp.Close(); err != nil {
|
|
cleanup()
|
|
return fmt.Errorf("close temp: %w", err)
|
|
}
|
|
if err := os.Rename(tmpPath, path); err != nil {
|
|
cleanup()
|
|
return fmt.Errorf("rename temp: %w", err)
|
|
}
|
|
return nil
|
|
}
|