Files
skillshare/internal/server/handler_skills_batch.go
T
Willie 5dd83a8412 fix(server): guard metadata store access against concurrent requests
Every API request reloads the skills and agents metadata stores and
swaps the server's pointers under s.mu, but several handlers read or
wrote the stores outside that lock: listing, skill detail, check, the
update stream, and the hash refresh after setting targets. Concurrent
requests could race on the pointer or on the stores' maps, which the
race detector reported hundreds of times under load and which can
crash the server with a concurrent map access.

Store access now always happens under s.mu. Reads return a copy of
the entry so it can be used after unlocking, and target handlers hash
files outside the lock and only write the result under it.
2026-09-26 21:12:57 +08:00

290 lines
7.2 KiB
Go

package server
import (
"encoding/json"
"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 := json.NewDecoder(r.Body).Decode(&req); err != nil {
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)
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 {
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
}
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); err == nil {
hashes[sk.name] = h
}
}
if len(hashes) > 0 {
s.mu.Lock()
for name, h := range hashes {
s.skillsStore.SetFileHashes(name, h)
}
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
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 := json.NewDecoder(r.Body).Decode(&req); err != nil {
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)
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); err == nil {
s.mu.Lock()
s.skillsStore.SetFileHashes(d.RelPath, hashes)
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
s.mu.Unlock()
}
}
}
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)
}