Files
skillshare/internal/server/handler_skills_batch.go
T
Willie c0e66720ce fix(source-links): preserve trashed links and resolve audit and hash roots
Trash moves and restores the link entry without copying or removing its target, including when rename fails. Relative link text is stored as an absolute target so relocation cannot change its meaning; list and TUI expose the link target without inventorying its contents.

Pass the operation-scoped Follow policy into audit and hash operations, resolving their physical root while keeping logical result and metadata keys. Calls without a policy keep their existing behavior and ScanSkill retains its original function signature.

Update six stale trash raw-write allowances for the injected rename test seam and classify moveLink creation/removal: it moves a checked source entry to trash or restores an entry into source, never writes through its target. Raw sourcewalk calls and allowances are unchanged.
2026-10-05 14:45:41 +08:00

307 lines
7.8 KiB
Go

package server
import (
"errors"
"net/http"
"path/filepath"
"strings"
"time"
"skillshare/internal/install"
"skillshare/internal/resource"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
// matchesFolder reports whether relPath belongs to the given folder filter.
// folder="" → root-level only (dir == ".")
// folder="*" → all skills
// otherwise → dir == folder || dir has folder/ prefix
func matchesFolder(relPath, folder string) bool {
if folder == "*" {
return true
}
dir := filepath.ToSlash(filepath.Dir(relPath))
if folder == "" {
return dir == "."
}
return dir == folder || strings.HasPrefix(dir, folder+"/")
}
type batchSetTargetsRequest struct {
Folder string `json:"folder"`
Target string `json:"target"`
}
type batchSetTargetsResponse struct {
Updated int `json:"updated"`
Skipped int `json:"skipped"`
Errors []string `json:"errors"`
}
// handleBatchSetTargets handles POST /api/skills/batch/targets.
// Sets or removes the target for all skills in a folder.
func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) {
start := time.Now()
var req batchSetTargetsRequest
if err := decodeJSON(w, r, &req, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
}
return
}
// Reject path traversal in folder
if strings.Contains(req.Folder, "..") {
writeError(w, http.StatusBadRequest, "invalid folder: path traversal not allowed")
return
}
folder := filepath.ToSlash(filepath.Clean(req.Folder))
if req.Folder == "" {
folder = ""
}
// Snapshot config under read lock, then discover without holding the lock.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
s.mu.RUnlock()
discovered, err := ssync.DiscoverSourceSkillsAll(source, s.skillsWalk())
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
var updated, skipped int
var errors []string
// Collect skills that need meta hash refresh (outside the lock).
type updatedSkill struct {
name string
path string
}
var updatedSkills []updatedSkill
overridden := false
var values []string
if req.Target != "" {
values = []string{req.Target}
}
// Acquire write lock only for the file-write loop.
s.mu.Lock()
for _, d := range discovered {
relPath := filepath.ToSlash(d.RelPath)
if !matchesFolder(relPath, folder) {
continue
}
// Skip disabled skills
if d.Disabled {
skipped++
continue
}
// Tracked-repo members keep their SKILL.md untouched so the clone
// stays clean for update; the targets live in .metadata.json.
if d.IsInRepo {
s.skillsStore.SetTargetOverride(relPath, values)
overridden = true
updated++
continue
}
skillMDPath := filepath.Join(d.SourcePath, "SKILL.md")
if err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values); err != nil {
errors = append(errors, d.FlatName+": "+err.Error())
continue
}
if name := filepath.Base(d.SourcePath); s.skillsStore.HasFileHashes(name) {
updatedSkills = append(updatedSkills, updatedSkill{name: name, path: d.SourcePath})
}
updated++
}
// Save the overrides before unlocking: every API request reloads skillsStore
// from disk, so an override left unsaved here can be dropped by the next one.
if overridden {
if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil {
s.mu.Unlock()
writeError(w, http.StatusInternalServerError, "failed to save target overrides: "+err.Error())
return
}
}
s.mu.Unlock()
// Recompute file hashes outside the lock so reads aren't blocked; the
// store itself is only touched under the lock.
hashes := make(map[string]map[string]string, len(updatedSkills))
for _, sk := range updatedSkills {
if h, err := install.ComputeFileHashes(sk.path, s.skillsWalk().Follow); err == nil {
hashes[sk.name] = h
}
}
if len(hashes) > 0 {
s.mu.Lock()
for name, h := range hashes {
s.skillsStore.SetFileHashes(name, h)
}
err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource())
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to save file hashes: "+err.Error())
return
}
}
s.writeOpsLog("batch-set-targets", "ok", start, map[string]any{
"folder": req.Folder,
"target": req.Target,
"updated": updated,
"skipped": skipped,
"scope": "ui",
}, "")
if errors == nil {
errors = []string{}
}
writeJSON(w, batchSetTargetsResponse{
Updated: updated,
Skipped: skipped,
Errors: errors,
})
}
type setSkillTargetsRequest struct {
Target string `json:"target"`
}
// handleSetSkillTargets handles PATCH /api/skills/{name}/targets.
// Sets or removes the target for a single skill.
func (s *Server) handleSetSkillTargets(w http.ResponseWriter, r *http.Request) {
start := time.Now()
name := r.PathValue("name")
var req setSkillTargetsRequest
if err := decodeJSON(w, r, &req, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
}
return
}
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
s.mu.RUnlock()
discovered, err := ssync.DiscoverSourceSkillsAll(source, s.skillsWalk())
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
for _, d := range discovered {
baseName := filepath.Base(d.SourcePath)
if d.FlatName != name && baseName != name {
continue
}
var values []string
if req.Target != "" {
values = []string{req.Target}
}
if d.IsInRepo {
// Tracked-repo members keep their SKILL.md untouched so the clone
// stays clean for update; the targets live in .metadata.json.
s.mu.Lock()
s.skillsStore.SetTargetOverride(d.RelPath, values)
err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource())
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error())
return
}
} else {
skillMDPath := filepath.Join(d.SourcePath, "SKILL.md")
s.mu.Lock()
err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values)
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error())
return
}
s.mu.RLock()
refresh := s.skillsStore.HasFileHashes(d.RelPath)
s.mu.RUnlock()
if refresh {
if hashes, err := install.ComputeFileHashes(d.SourcePath, s.skillsWalk().Follow); err == nil {
s.mu.Lock()
s.skillsStore.SetFileHashes(d.RelPath, hashes)
err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource())
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error())
return
}
}
}
}
s.writeOpsLog("set-skill-targets", "ok", start, map[string]any{
"name": name,
"target": req.Target,
"scope": "ui",
}, "")
writeJSON(w, map[string]any{"success": true})
return
}
// Try agents if skill not found
s.mu.RLock()
agentsSource := s.agentsSource()
s.mu.RUnlock()
if agentsSource != "" {
agents, _ := resource.AgentKind{}.Discover(agentsSource)
for _, d := range agents {
if d.FlatName != name {
continue
}
var values []string
if req.Target != "" {
values = []string{req.Target}
}
s.mu.Lock()
err := utils.SetFrontmatterList(d.SourcePath, "targets", values)
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update agent: "+err.Error())
return
}
s.writeOpsLog("set-agent-targets", "ok", start, map[string]any{
"name": name,
"target": req.Target,
"scope": "ui",
}, "")
writeJSON(w, map[string]any{"success": true})
return
}
}
writeError(w, http.StatusNotFound, "resource not found: "+name)
}