Files
skillshare/internal/server/handler_skill_content.go
T
Willie a502e9316b feat(sourcefs): write through followed first-level source links
With follow_source_links on, discovery reports <source>/_dev-skills/foo,
but every write to it was refused: sourcefs rejects a link in the path, and
its source-root os.Root refuses descendants outside the source. Dashboard
edits, nested uninstall, regular skill replacement, and tracked installs
under such a link all failed, although writing through a link the user
placed is the agreed behavior (#410).

sourcefs.Open, Create, MkdirAllIn, and CheckMoveOut take the operation's
optional sourcewalk.Follow. A clean name <link>/<rest> whose first
component the policy follows is handled by a second os.Root opened at the
link's canonical target, with the same per-component link check on <rest>,
so a nested link or ".." still cannot escape the target. Names with ".."
keep the source root, which refuses them through the link. Without a
policy nothing changes.

The link entry itself stays a link: RemoveAll, Rename, and writes on it are
refused, install --track --force still refuses to replace it, and
CheckMoveOut still lets trash rename the link without following it.
MkdirAll on a followed link is a no-op, since it already is that directory;
install --into needs that. A rename across the link boundary is refused.

The install, update, uninstall, and server callers pass the same policy
their discovery uses, through InstallOptions.SourceFollow and the update
context. No raw-write allowance was needed.

Refs #274
2026-10-05 14:42:09 +08:00

406 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/sourcewalk"
"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), s.skillsWalk().Follow)
} 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, s.skillsWalk())
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, s.skillsWalk())
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, follow *sourcewalk.Follow) error {
src, err := sourcefs.Open(source, follow)
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
}