mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Rewrite frontmatter as bytes and read and write target assignments through sourcefs with the discovery follow policy. Refuse nested SKILL.md links with per-skill batch errors or HTTP 400 while regular followed skills remain editable and outside files stay unchanged.
347 lines
8.7 KiB
Go
347 lines
8.7 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/install"
|
|
"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
|
|
|
|
// 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 := setSourceFrontmatterList(source, skillMDPath, "metadata.targets", values, walk.Follow); 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, walk.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()
|
|
|
|
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()
|
|
err := setSourceFrontmatterList(source, skillMDPath, "metadata.targets", values, walk.Follow)
|
|
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.mu.RLock()
|
|
refresh := s.skillsStore.HasFileHashes(d.RelPath)
|
|
s.mu.RUnlock()
|
|
if refresh {
|
|
if hashes, err := install.ComputeFileHashes(d.SourcePath, walk.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 := setSourceFrontmatterList(agentsSource, d.SourcePath, "targets", values, nil)
|
|
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)
|
|
}
|