mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
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.
589 lines
17 KiB
Go
589 lines
17 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/git"
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/resource"
|
|
"skillshare/internal/sync"
|
|
"skillshare/internal/trash"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
type skillItem struct {
|
|
Name string `json:"name"`
|
|
Kind string `json:"kind"` // "skill" or "agent"
|
|
FlatName string `json:"flatName"`
|
|
RelPath string `json:"relPath"`
|
|
SourcePath string `json:"sourcePath"`
|
|
IsInRepo bool `json:"isInRepo"`
|
|
Targets []string `json:"targets,omitempty"`
|
|
InstalledAt string `json:"installedAt,omitempty"`
|
|
Source string `json:"source,omitempty"`
|
|
Type string `json:"type,omitempty"`
|
|
RepoURL string `json:"repoUrl,omitempty"`
|
|
Version string `json:"version,omitempty"`
|
|
Branch string `json:"branch,omitempty"`
|
|
Disabled bool `json:"disabled"`
|
|
// ManualOnly mirrors disable-model-invocation: installed and invocable by name, but the
|
|
// model does not load it on its own. The list TUI toggles it with M.
|
|
ManualOnly bool `json:"manualOnly,omitempty"`
|
|
}
|
|
|
|
// ponytail: one small read per skill on the list; carry it on DiscoveredSkill if lists get slow.
|
|
func manualOnly(skillDir string) bool {
|
|
return strings.EqualFold(utils.ParseFrontmatterField(filepath.Join(skillDir, "SKILL.md"), "disable-model-invocation"), "true")
|
|
}
|
|
|
|
// enrichSkillBranch fills item.Branch from metadata, falling back to
|
|
// git.GetCurrentBranch for tracked repos without branch in metadata.
|
|
func enrichSkillBranch(item *skillItem) {
|
|
if item.Branch == "" && item.IsInRepo {
|
|
if branch, err := git.GetCurrentBranch(item.SourcePath); err == nil {
|
|
item.Branch = branch
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) handleListSkills(w http.ResponseWriter, r *http.Request) {
|
|
kindFilter := r.URL.Query().Get("kind") // "", "skill", "agent"
|
|
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
agentsSource := s.agentsSource()
|
|
s.mu.RUnlock()
|
|
|
|
var items []skillItem
|
|
|
|
// Skills
|
|
if kindFilter == "" || kindFilter == "skill" {
|
|
discovered, err := sync.DiscoverSourceSkillsAll(source)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
for _, d := range discovered {
|
|
item := skillItem{
|
|
Name: filepath.Base(d.SourcePath),
|
|
Kind: "skill",
|
|
FlatName: d.FlatName,
|
|
RelPath: d.RelPath,
|
|
SourcePath: d.SourcePath,
|
|
IsInRepo: d.IsInRepo,
|
|
Targets: d.Targets,
|
|
Disabled: d.Disabled,
|
|
ManualOnly: manualOnly(d.SourcePath),
|
|
}
|
|
|
|
if entry := s.skillEntry(d.RelPath); entry != nil {
|
|
if !entry.InstalledAt.IsZero() {
|
|
item.InstalledAt = entry.InstalledAt.Format(time.RFC3339)
|
|
}
|
|
item.Source = entry.Source
|
|
item.Type = entry.Type
|
|
item.RepoURL = entry.RepoURL
|
|
item.Version = entry.Version
|
|
item.Branch = entry.Branch
|
|
}
|
|
enrichSkillBranch(&item)
|
|
|
|
items = append(items, item)
|
|
}
|
|
}
|
|
|
|
// Agents — recursive discovery (supports --into subdirectories)
|
|
if (kindFilter == "" || kindFilter == "agent") && agentsSource != "" {
|
|
discovered, _ := resource.AgentKind{}.Discover(agentsSource)
|
|
for _, d := range discovered {
|
|
item := skillItem{
|
|
Name: d.Name,
|
|
Kind: "agent",
|
|
FlatName: d.FlatName,
|
|
RelPath: d.RelPath,
|
|
SourcePath: d.SourcePath,
|
|
IsInRepo: d.IsInRepo,
|
|
Disabled: d.Disabled,
|
|
Targets: d.Targets,
|
|
}
|
|
|
|
// Read from centralized agents metadata store
|
|
agentKey := strings.TrimSuffix(d.RelPath, ".md")
|
|
if entry := s.agentEntry(agentKey); entry != nil {
|
|
if !entry.InstalledAt.IsZero() {
|
|
item.InstalledAt = entry.InstalledAt.Format(time.RFC3339)
|
|
}
|
|
item.Source = entry.Source
|
|
item.Type = entry.Type
|
|
item.RepoURL = entry.RepoURL
|
|
item.Version = entry.Version
|
|
} else if d.RepoRelPath != "" {
|
|
repoPath := filepath.Join(agentsSource, filepath.FromSlash(d.RepoRelPath))
|
|
if repoURL, err := git.GetRemoteURL(repoPath); err == nil {
|
|
item.Source = repoURL
|
|
item.RepoURL = repoURL
|
|
}
|
|
if version, err := git.GetCurrentFullHash(repoPath); err == nil {
|
|
item.Version = version
|
|
}
|
|
}
|
|
|
|
items = append(items, item)
|
|
}
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"resources": items})
|
|
}
|
|
|
|
func (s *Server) handleGetSkill(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
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
|
|
}
|
|
|
|
// Find the skill by flat name (exact) first, then fall back to base name.
|
|
if kind != "agent" {
|
|
discovered, err := sync.DiscoverSourceSkillsAll(source)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
// Two-pass: prefer FlatName exact match over baseName fallback.
|
|
var match *sync.DiscoveredSkill
|
|
for i := range discovered {
|
|
if discovered[i].FlatName == name {
|
|
match = &discovered[i]
|
|
break
|
|
}
|
|
}
|
|
if match == nil {
|
|
for i := range discovered {
|
|
if filepath.Base(discovered[i].SourcePath) == name {
|
|
match = &discovered[i]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if match != nil {
|
|
d := match
|
|
baseName := filepath.Base(d.SourcePath)
|
|
item := skillItem{
|
|
Name: baseName,
|
|
Kind: "skill",
|
|
FlatName: d.FlatName,
|
|
RelPath: d.RelPath,
|
|
SourcePath: d.SourcePath,
|
|
IsInRepo: d.IsInRepo,
|
|
Targets: d.Targets,
|
|
Disabled: d.Disabled,
|
|
ManualOnly: manualOnly(d.SourcePath),
|
|
}
|
|
|
|
if entry := s.skillEntry(d.RelPath); entry != nil {
|
|
if !entry.InstalledAt.IsZero() {
|
|
item.InstalledAt = entry.InstalledAt.Format(time.RFC3339)
|
|
}
|
|
item.Source = entry.Source
|
|
item.Type = entry.Type
|
|
item.RepoURL = entry.RepoURL
|
|
item.Version = entry.Version
|
|
item.Branch = entry.Branch
|
|
}
|
|
enrichSkillBranch(&item)
|
|
|
|
// Read SKILL.md content
|
|
skillMdContent := ""
|
|
skillMdPath := filepath.Join(d.SourcePath, "SKILL.md")
|
|
if data, err := os.ReadFile(skillMdPath); err == nil {
|
|
skillMdContent = string(data)
|
|
}
|
|
|
|
// List all files in the skill directory
|
|
files := make([]string, 0)
|
|
filepath.Walk(d.SourcePath, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if info.IsDir() && utils.IsHidden(info.Name()) {
|
|
return filepath.SkipDir
|
|
}
|
|
if !info.IsDir() {
|
|
rel, _ := filepath.Rel(d.SourcePath, path)
|
|
// Normalize separators
|
|
rel = strings.ReplaceAll(rel, "\\", "/")
|
|
files = append(files, rel)
|
|
}
|
|
return nil
|
|
})
|
|
|
|
writeJSON(w, map[string]any{
|
|
"resource": item,
|
|
"skillMdContent": skillMdContent,
|
|
"files": files,
|
|
})
|
|
return
|
|
}
|
|
}
|
|
|
|
// Fallback: check agents source (recursive — supports --into subdirectories)
|
|
if kind != "skill" && agentsSource != "" {
|
|
agentDiscovered, _ := resource.AgentKind{}.Discover(agentsSource)
|
|
for _, d := range agentDiscovered {
|
|
if !matchesAgentName(d, name) {
|
|
continue
|
|
}
|
|
|
|
data, readErr := os.ReadFile(d.SourcePath)
|
|
if readErr != nil {
|
|
continue
|
|
}
|
|
|
|
item := skillItem{
|
|
Name: d.Name,
|
|
Kind: "agent",
|
|
FlatName: d.FlatName,
|
|
RelPath: d.RelPath,
|
|
SourcePath: d.SourcePath,
|
|
IsInRepo: d.IsInRepo,
|
|
Disabled: d.Disabled,
|
|
Targets: d.Targets,
|
|
}
|
|
|
|
agentKey := strings.TrimSuffix(d.RelPath, ".md")
|
|
if entry := s.agentEntry(agentKey); entry != nil {
|
|
if !entry.InstalledAt.IsZero() {
|
|
item.InstalledAt = entry.InstalledAt.Format(time.RFC3339)
|
|
}
|
|
item.Source = entry.Source
|
|
item.Type = entry.Type
|
|
item.RepoURL = entry.RepoURL
|
|
item.Version = entry.Version
|
|
} else if d.RepoRelPath != "" {
|
|
repoPath := filepath.Join(agentsSource, filepath.FromSlash(d.RepoRelPath))
|
|
if repoURL, err := git.GetRemoteURL(repoPath); err == nil {
|
|
item.Source = repoURL
|
|
item.RepoURL = repoURL
|
|
}
|
|
if version, err := git.GetCurrentFullHash(repoPath); err == nil {
|
|
item.Version = version
|
|
}
|
|
}
|
|
|
|
writeJSON(w, map[string]any{
|
|
"resource": item,
|
|
"skillMdContent": string(data),
|
|
"files": []string{filepath.Base(d.RelPath)},
|
|
})
|
|
return
|
|
}
|
|
}
|
|
|
|
writeError(w, http.StatusNotFound, "skill not found: "+name)
|
|
}
|
|
|
|
func (s *Server) handleGetSkillFile(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
s.mu.RUnlock()
|
|
|
|
name := r.PathValue("name")
|
|
fp := r.PathValue("filepath")
|
|
|
|
// Reject path traversal attempts
|
|
if strings.Contains(fp, "..") {
|
|
writeError(w, http.StatusBadRequest, "invalid file path")
|
|
return
|
|
}
|
|
|
|
// Find the skill
|
|
discovered, err := sync.DiscoverSourceSkills(source)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
for _, d := range discovered {
|
|
baseName := filepath.Base(d.SourcePath)
|
|
if d.FlatName != name && baseName != name {
|
|
continue
|
|
}
|
|
|
|
// Resolve and verify the file is within the skill directory
|
|
absPath := filepath.Join(d.SourcePath, filepath.FromSlash(fp))
|
|
absPath = filepath.Clean(absPath)
|
|
skillDir := filepath.Clean(d.SourcePath) + string(filepath.Separator)
|
|
if !strings.HasPrefix(absPath, skillDir) {
|
|
writeError(w, http.StatusBadRequest, "invalid file path")
|
|
return
|
|
}
|
|
|
|
data, err := os.ReadFile(absPath)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
writeError(w, http.StatusNotFound, "file not found: "+fp)
|
|
} else {
|
|
writeError(w, http.StatusInternalServerError, "failed to read file: "+err.Error())
|
|
}
|
|
return
|
|
}
|
|
|
|
// Determine content type from extension
|
|
ct := "text/plain"
|
|
switch strings.ToLower(filepath.Ext(absPath)) {
|
|
case ".md":
|
|
ct = "text/markdown"
|
|
case ".json":
|
|
ct = "application/json"
|
|
case ".yaml", ".yml":
|
|
ct = "text/yaml"
|
|
}
|
|
|
|
writeJSON(w, map[string]any{
|
|
"content": string(data),
|
|
"contentType": ct,
|
|
"filename": filepath.Base(absPath),
|
|
})
|
|
return
|
|
}
|
|
|
|
writeError(w, http.StatusNotFound, "skill not found: "+name)
|
|
}
|
|
|
|
func (s *Server) handleUninstallRepo(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
name := strings.TrimSpace(r.PathValue("name"))
|
|
cleanName := filepath.Clean(filepath.FromSlash(name))
|
|
if name == "" || cleanName == "." || cleanName == ".." || filepath.IsAbs(cleanName) || strings.HasPrefix(cleanName, ".."+string(filepath.Separator)) {
|
|
writeError(w, http.StatusBadRequest, "invalid or missing tracked repository name")
|
|
return
|
|
}
|
|
|
|
repoName, repoPath, resolveErr := s.resolveTrackedRepo(cleanName)
|
|
if resolveErr != nil {
|
|
writeError(w, http.StatusBadRequest, resolveErr.Error())
|
|
return
|
|
}
|
|
if repoPath == "" {
|
|
writeError(w, http.StatusBadRequest, "not a tracked repository: "+cleanName)
|
|
return
|
|
}
|
|
|
|
// Move to trash first — only clean gitignore after durable removal.
|
|
if _, err := trash.MoveToTrash(repoPath, repoName, s.trashBase()); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to trash repo: "+err.Error())
|
|
return
|
|
}
|
|
|
|
gitDir := s.gitignoreDir()
|
|
if gitDir != "" {
|
|
if s.IsProjectMode() {
|
|
install.RemoveFromGitIgnore(gitDir, s.projectGitignorePrefix()+"/"+repoName)
|
|
} else {
|
|
install.RemoveFromGitIgnore(gitDir, repoName)
|
|
}
|
|
}
|
|
|
|
// Prune store entries: the repo itself + skills belonging to it.
|
|
// Legacy entries use Group without "_" prefix (e.g., "team-skills" for repo "_team-skills").
|
|
// Only apply legacy matching for top-level repos (no "/" in repoName) to avoid
|
|
// basename collisions between sibling nested repos like org/_team-skills vs dept/_team-skills.
|
|
legacyGroup := ""
|
|
if !strings.Contains(repoName, "/") {
|
|
legacyGroup = strings.TrimPrefix(repoName, "_")
|
|
}
|
|
for _, name := range s.skillsStore.List() {
|
|
entry := s.skillsStore.Get(name)
|
|
if entry == nil {
|
|
continue
|
|
}
|
|
// Match the repo's own entry (e.g., "_team-skills" or "org/_team-skills")
|
|
if name == repoName {
|
|
s.skillsStore.Remove(name)
|
|
continue
|
|
}
|
|
// Match tracked skills grouped under this repo (exact group match)
|
|
if entry.Tracked && entry.Group == repoName {
|
|
s.skillsStore.Remove(name)
|
|
continue
|
|
}
|
|
// Match legacy grouped entries (top-level repos only, e.g., group="team-skills")
|
|
if legacyGroup != "" && entry.Tracked && entry.Group == legacyGroup {
|
|
s.skillsStore.Remove(name)
|
|
continue
|
|
}
|
|
// Match nested members (e.g., "org/_team-skills/sub-skill")
|
|
if strings.HasPrefix(name, repoName+"/") {
|
|
s.skillsStore.Remove(name)
|
|
continue
|
|
}
|
|
}
|
|
|
|
s.skillsStore.RemoveTargetOverrides(repoName)
|
|
|
|
if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil {
|
|
log.Printf("warning: failed to save metadata after repo uninstall: %v", err)
|
|
}
|
|
|
|
s.writeOpsLog("uninstall", "ok", start, map[string]any{
|
|
"name": repoName,
|
|
"type": "repo",
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": repoName, "movedToTrash": true})
|
|
}
|
|
|
|
func (s *Server) handleUninstallSkill(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
name := r.PathValue("name")
|
|
kind := r.URL.Query().Get("kind")
|
|
if kind != "" && kind != "skill" && kind != "agent" {
|
|
writeError(w, http.StatusBadRequest, "invalid kind: "+kind)
|
|
return
|
|
}
|
|
|
|
if kind == "agent" {
|
|
agentsSource := s.agentsSource()
|
|
if agentsSource == "" {
|
|
writeError(w, http.StatusNotFound, "agent not found: "+name)
|
|
return
|
|
}
|
|
agent, err := resolveAgentResource(agentsSource, name)
|
|
if err != nil {
|
|
writeError(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
displayName := agentMetaKey(agent.RelPath)
|
|
legacySidecar := filepath.Join(filepath.Dir(agent.SourcePath), filepath.Base(displayName)+".skillshare-meta.json")
|
|
if _, err := trash.MoveAgentToTrash(agent.SourcePath, legacySidecar, displayName, s.agentTrashBase()); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to trash agent: "+err.Error())
|
|
return
|
|
}
|
|
|
|
if s.agentsStore != nil {
|
|
s.agentsStore.Remove(displayName)
|
|
if err := s.agentsStore.Save(agentsSource); err != nil {
|
|
log.Printf("warning: failed to save agent metadata after uninstall: %v", err)
|
|
}
|
|
}
|
|
|
|
s.writeOpsLog("uninstall", "ok", start, map[string]any{
|
|
"name": displayName,
|
|
"type": "agent",
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": displayName, "movedToTrash": true})
|
|
return
|
|
}
|
|
|
|
// Find skill path. Disabled skills are listed in .skillignore, but the UI
|
|
// still shows them, so single-resource uninstall must resolve them too (#190).
|
|
discovered, err := sync.DiscoverSourceSkillsAll(s.cfg.EffectiveSkillsSource())
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
for _, d := range discovered {
|
|
baseName := filepath.Base(d.SourcePath)
|
|
if d.FlatName != name && baseName != name {
|
|
continue
|
|
}
|
|
|
|
// Don't allow removing skills inside tracked repos
|
|
if d.IsInRepo {
|
|
writeError(w, http.StatusBadRequest, "cannot uninstall skill from tracked repo; use 'skillshare uninstall' for the whole repo")
|
|
return
|
|
}
|
|
|
|
if _, err := trash.MoveToTrash(d.SourcePath, baseName, s.trashBase()); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to trash skill: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("uninstall", "ok", start, map[string]any{
|
|
"name": baseName,
|
|
"type": "skill",
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": name, "movedToTrash": true})
|
|
return
|
|
}
|
|
|
|
writeError(w, http.StatusNotFound, "skill not found: "+name)
|
|
}
|
|
|
|
// resolveTrackedRepo resolves a repo name (flat or nested) to its directory name
|
|
// and absolute path under s.cfg.EffectiveSkillsSource(). Returns ("", "", nil) if not found.
|
|
// Returns a non-nil error for ambiguous matches or internal failures.
|
|
func (s *Server) resolveTrackedRepo(input string) (string, string, error) {
|
|
sourceRoot := filepath.Clean(s.cfg.EffectiveSkillsSource())
|
|
candidates := []string{input}
|
|
if !strings.HasPrefix(filepath.Base(input), "_") {
|
|
if dir := filepath.Dir(input); dir != "." && dir != "" {
|
|
candidates = append(candidates, filepath.Join(dir, "_"+filepath.Base(input)))
|
|
} else {
|
|
candidates = append(candidates, "_"+input)
|
|
}
|
|
}
|
|
for _, candidate := range candidates {
|
|
repoPath := filepath.Clean(filepath.Join(sourceRoot, candidate))
|
|
relPath, relErr := filepath.Rel(sourceRoot, repoPath)
|
|
if relErr != nil || relPath == ".." || strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
|
|
continue
|
|
}
|
|
if install.IsGitRepo(repoPath) {
|
|
return candidate, repoPath, nil
|
|
}
|
|
}
|
|
|
|
// Fallback: match nested tracked repos by basename.
|
|
repos, err := install.GetTrackedRepos(s.cfg.EffectiveSkillsSource())
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("failed to list tracked repositories: %w", err)
|
|
}
|
|
var match string
|
|
for _, repo := range repos {
|
|
base := filepath.Base(repo)
|
|
trimmed := strings.TrimPrefix(base, "_")
|
|
if base == input || trimmed == input {
|
|
if match != "" {
|
|
return "", "", fmt.Errorf("multiple tracked repositories match: %s — use the full path", input)
|
|
}
|
|
match = repo
|
|
}
|
|
}
|
|
if match != "" {
|
|
return match, filepath.Join(sourceRoot, match), nil
|
|
}
|
|
return "", "", nil
|
|
}
|