Files
skillshare/internal/server/handler_uninstall.go
T
Willie c61f48865e fix(server): reject skill names that escape the skills source (#408)
GET /api/audit/{name} joined the client-supplied name to the source
without checking it, so a name such as ../../x scanned a directory
outside the skills source and returned a clean result for it. The
single-skill update, the update stream, and the batch uninstall built
paths the same way; the tracked-repo uninstall route already refused
such names inline.

One helper, validSourceName, now holds that rule: non-empty, relative,
not starting with "..", and no Windows separators or volume prefixes on
any host, as sourcewalk does for declared names. The audit and update
routes answer 400, the update stream reports the name as an error
result, the batch uninstall fails that item, and the repo uninstall
route uses the same helper. Nested names such as group/skill still
resolve.

Closes #402
2026-10-05 11:03:39 +08:00

381 lines
9.8 KiB
Go

package server
import (
"errors"
"fmt"
"log"
"net/http"
"path/filepath"
"strings"
"time"
"skillshare/internal/git"
"skillshare/internal/install"
"skillshare/internal/sourcefs"
"skillshare/internal/sync"
"skillshare/internal/trash"
)
type batchUninstallRequest struct {
Names []string `json:"names"`
Kind string `json:"kind,omitempty"`
Force bool `json:"force"`
}
type batchUninstallItemResult struct {
Name string `json:"name"`
Kind string `json:"kind,omitempty"`
Success bool `json:"success"`
MovedToTrash bool `json:"movedToTrash,omitempty"`
Error string `json:"error,omitempty"`
}
type batchUninstallSummary struct {
Succeeded int `json:"succeeded"`
Failed int `json:"failed"`
}
func (s *Server) handleBatchUninstall(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body batchUninstallRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if len(body.Names) == 0 {
writeError(w, http.StatusBadRequest, "names array is required and must not be empty")
return
}
if body.Kind != "" && body.Kind != "skill" && body.Kind != "agent" {
writeError(w, http.StatusBadRequest, "invalid kind: "+body.Kind)
return
}
// Agent-mode batch uninstall
if body.Kind == "agent" {
s.handleBatchUninstallAgents(w, body, start)
return
}
// Skill-mode (default) batch uninstall
s.handleBatchUninstallSkills(w, body, start)
}
func (s *Server) handleBatchUninstallAgents(w http.ResponseWriter, body batchUninstallRequest, start time.Time) {
agentsSource := s.agentsSource()
if agentsSource == "" {
writeError(w, http.StatusInternalServerError, "agents source not configured")
return
}
results := make([]batchUninstallItemResult, 0, len(body.Names))
var removedNames []string
succeeded, failed := 0, 0
var firstErr string
for _, name := range body.Names {
res := batchUninstallItemResult{Name: name, Kind: "agent"}
agent, err := resolveAgentResource(agentsSource, name)
if err != nil {
res.Success = false
res.Error = "agent not found: " + name
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
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 {
res.Success = false
res.Error = fmt.Sprintf("failed to trash agent: %v", err)
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
removedNames = append(removedNames, displayName)
res.Success = true
res.MovedToTrash = true
results = append(results, res)
succeeded++
}
if succeeded > 0 && s.agentsStore != nil {
for _, name := range removedNames {
s.agentsStore.Remove(name)
}
if err := s.agentsStore.Save(agentsSource); err != nil {
log.Printf("warning: failed to save agent metadata after batch uninstall: %v", err)
}
}
status := "ok"
if failed > 0 && succeeded > 0 {
status = "partial"
} else if failed > 0 {
status = "error"
}
s.writeOpsLog("uninstall", status, start, map[string]any{
"names": body.Names,
"kind": "agent",
"scope": "ui",
"count": succeeded,
}, firstErr)
writeJSON(w, map[string]any{
"results": results,
"summary": batchUninstallSummary{
Succeeded: succeeded,
Failed: failed,
},
})
}
func (s *Server) handleBatchUninstallSkills(w http.ResponseWriter, body batchUninstallRequest, start time.Time) {
// Use DiscoverSourceSkillsAll (not DiscoverSourceSkills) so disabled skills
// — those listed in .skillignore — are also resolvable. The list handler
// shows disabled skills, so uninstall must be able to find them too (#190).
discovered, err := sync.DiscoverSourceSkillsAll(s.cfg.EffectiveSkillsSource())
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
flatNameMap := make(map[string]*sync.DiscoveredSkill, len(discovered))
baseNameMap := make(map[string]*sync.DiscoveredSkill, len(discovered))
for i := range discovered {
flatNameMap[discovered[i].FlatName] = &discovered[i]
baseNameMap[filepath.Base(discovered[i].SourcePath)] = &discovered[i]
}
results := make([]batchUninstallItemResult, 0, len(body.Names))
removedPaths := make(map[string]bool) // exact RelPaths of successfully removed items
var repoEntriesToRemove []string
succeeded, failed := 0, 0
var firstErr string
for _, name := range body.Names {
res := batchUninstallItemResult{Name: name, Kind: "skill"}
if !validSourceName(name) {
res.Success = false
res.Error = "invalid skill name: " + name
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if strings.HasPrefix(name, "_") {
repoPath := filepath.Join(s.cfg.EffectiveSkillsSource(), name)
if !install.IsGitRepo(repoPath) {
res.Success = false
res.Error = "not a tracked repository: " + name
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if !body.Force {
dirty, err := git.IsDirty(repoPath)
if err != nil {
res.Error = fmt.Sprintf("failed to check git status: %v", err)
} else if dirty {
res.Error = "uncommitted changes (use force to override)"
}
}
if res.Error != "" {
res.Success = false
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if err := sourcefs.CheckMoveOut(s.cfg.EffectiveSkillsSource(), repoPath); err != nil {
res.Success = false
res.Error = err.Error()
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if _, err := trash.MoveToTrash(repoPath, name, s.trashBase()); err != nil {
res.Success = false
res.Error = fmt.Sprintf("failed to trash repo: %v", err)
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
repoEntriesToRemove = append(repoEntriesToRemove, name)
removedPaths[name] = true // repo dir name is already the registry path
res.Success = true
res.MovedToTrash = true
results = append(results, res)
succeeded++
continue
}
skill := flatNameMap[name]
if skill == nil {
skill = baseNameMap[name]
}
if skill == nil {
res.Success = false
res.Error = "skill not found: " + name
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if skill.IsInRepo {
res.Success = false
res.Error = "skill is inside a tracked repo; uninstall the repo instead"
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
baseName := filepath.Base(skill.SourcePath)
if err := sourcefs.CheckMoveOut(s.cfg.EffectiveSkillsSource(), skill.SourcePath); err != nil {
res.Success = false
res.Error = err.Error()
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if _, err := trash.MoveToTrash(skill.SourcePath, baseName, s.trashBase()); err != nil {
res.Success = false
res.Error = fmt.Sprintf("failed to trash skill: %v", err)
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
removedPaths[skill.RelPath] = true // exact path for registry matching
res.Success = true
res.MovedToTrash = true
results = append(results, res)
succeeded++
}
if len(repoEntriesToRemove) > 0 {
gitDir := s.gitignoreDir()
if gitDir != "" {
entries := repoEntriesToRemove
if s.IsProjectMode() {
prefix := s.projectGitignorePrefix()
entries = make([]string, len(repoEntriesToRemove))
for i, e := range repoEntriesToRemove {
entries[i] = prefix + "/" + e
}
}
if _, err := install.RemoveFromGitIgnoreBatch(gitDir, entries); err != nil {
log.Printf("warning: failed to clean .gitignore: %v", err)
}
}
}
if succeeded > 0 {
// removedPaths contains exact RelPaths (e.g. "frontend/vue/vue-best-practices")
// and repo dir names (e.g. "_team-skills"), collected during the uninstall loop.
for _, name := range s.skillsStore.List() {
entry := s.skillsStore.Get(name)
if entry == nil {
continue
}
if removedPaths[name] {
s.skillsStore.Remove(name)
continue
}
// Tracked repos: store uses group without "_" prefix (e.g., group="team-skills"
// for repo dir "_team-skills"). Reconstruct the prefixed name to match removedPaths.
if entry.Group != "" && removedPaths["_"+entry.Group] {
s.skillsStore.Remove(name)
continue
}
// When a group directory is uninstalled, also remove its member skills
memberOfRemoved := false
for rp := range removedPaths {
if strings.HasPrefix(name, rp+"/") {
memberOfRemoved = true
break
}
}
if memberOfRemoved {
s.skillsStore.Remove(name)
}
}
for rp := range removedPaths {
s.skillsStore.RemoveTargetOverrides(rp)
}
if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil {
log.Printf("warning: failed to save metadata: %v", err)
}
s.reconcileSkillsConfig(s.cfg.EffectiveSkillsSource())
}
status := "ok"
if failed > 0 && succeeded > 0 {
status = "partial"
} else if failed > 0 {
status = "error"
}
s.writeOpsLog("uninstall", status, start, map[string]any{
"names": body.Names,
"force": body.Force,
"scope": "ui",
"count": succeeded,
}, firstErr)
writeJSON(w, map[string]any{
"results": results,
"summary": batchUninstallSummary{
Succeeded: succeeded,
Failed: failed,
},
})
}