Files
skillshare/internal/server/handler_skills_batch.go
T
Willie 0cc1c25d67 fix(server): keep local edits when the dashboard updates an agent (#967)
Updating an agent from the dashboard replaced the file with the remote
version even when the user had edited it since install. Skills were already
protected: update skips them and offers a forced retry. Agents had the
recorded file hash to compare against, but the update never looked at it.

An agent whose file no longer matches its recorded hash is now skipped with
the same message as a skill, so the Updates tab offers Force Retry and the
agent's own page asks before overwriting. The check runs only once a newer
version is about to be written, so an edited agent that is already at the
remote version still reports up to date.

Assigning targets to an agent from the dashboard rewrites its frontmatter.
That rewrite now carries the recorded hash, as it does for skills, so it is
not mistaken for a local edit.

The confirmation on the agent's page no longer tries to list the local
changes: that list is served for skills only and showed a load error.
2026-11-20 17:23:26 +08:00

315 lines
8.1 KiB
Go

package server
import (
"errors"
"io"
"net/http"
"os"
"path/filepath"
"strings"
"time"
"skillshare/internal/resource"
"skillshare/internal/sourcefs"
"skillshare/internal/sourcewalk"
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()
walk := s.skillsWalk()
discovered, err := ssync.DiscoverSourceSkillsAll(source, walk)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
var updated, skipped int
var errors []string
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")
before, _ := utils.FileHashFormatted(skillMDPath)
if err := setSourceFrontmatterList(source, skillMDPath, "metadata.targets", values, walk.Follow); err != nil {
errors = append(errors, d.FlatName+": "+err.Error())
continue
}
if after, err := utils.FileHashFormatted(skillMDPath); err == nil && s.skillsStore.CarryFileHash(relPath, "SKILL.md", before, after) {
overridden = true
}
updated++
}
// Save the overrides and hashes before unlocking: every API request reloads
// skillsStore from disk, so a change 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()
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()
walk := s.skillsWalk()
discovered, err := ssync.DiscoverSourceSkillsAll(source, walk)
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()
before, _ := utils.FileHashFormatted(skillMDPath)
err := setSourceFrontmatterList(source, skillMDPath, "metadata.targets", values, walk.Follow)
if err == nil {
if after, hashErr := utils.FileHashFormatted(skillMDPath); hashErr == nil && s.skillsStore.CarryFileHash(d.RelPath, "SKILL.md", before, after) {
err = s.skillsStore.Save(s.cfg.EffectiveSkillsSource())
}
}
s.mu.Unlock()
if err != nil {
status := http.StatusInternalServerError
if errors.Is(err, sourcefs.ErrLink) {
status = http.StatusBadRequest
}
writeError(w, status, "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()
before, _ := utils.FileHashFormatted(d.SourcePath)
err := setSourceFrontmatterList(agentsSource, d.SourcePath, "targets", values, nil)
if err == nil {
if after, hashErr := utils.FileHashFormatted(d.SourcePath); hashErr == nil && s.agentsStore.CarryFileHash(agentMetaKey(d.RelPath), filepath.Base(d.RelPath), before, after) {
err = s.agentsStore.Save(agentsSource)
}
}
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)
}
// setSourceFrontmatterList keeps target assignment inside the source write boundary.
func setSourceFrontmatterList(source, path, field string, values []string, follow *sourcewalk.Follow) error {
root, err := sourcefs.Open(source, follow)
if err != nil {
return err
}
defer root.Close()
rel, err := root.Rel(path)
if err != nil {
return err
}
if err := root.CheckNoLink(rel); err != nil {
return err
}
file, err := root.OpenFile(rel, os.O_RDONLY, 0)
if err != nil {
return err
}
data, err := io.ReadAll(file)
file.Close()
if err != nil {
return err
}
data, err = utils.RewriteFrontmatterList(data, field, values)
if err != nil {
return err
}
return root.WriteFileAtomic(rel, data, 0644)
}