Files
skillshare/internal/server/handler_uninstall.go
T
Willie 2e9f14da49 feat(ui): let the dashboard force a refused tracked-repo uninstall
DELETE /api/repos/{name} now refuses a repo with uncommitted changes or
unreadable git status, and the Dashboard page never sent force, so those
repos could not be removed from it at all.

The two refusals force overrides now carry their own error code. The
page still sends the first request without force; on either code the
confirmation says why and retries with force only when the user
confirms. Other refusals, such as a linked folder that is itself a
skill, keep the plain error because force does not change them.

Refs #442
2026-10-07 00:35:03 +08:00

323 lines
10 KiB
Go

package server
import (
"errors"
"fmt"
"log"
"net/http"
"path/filepath"
"strings"
"time"
"skillshare/internal/install"
"skillshare/internal/sourcewalk"
"skillshare/internal/sync"
"skillshare/internal/uninstall"
)
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, len(body.Names))
var agents []uninstall.Agent
var slots []int // results index of each resolved agent
for i, name := range body.Names {
results[i] = batchUninstallItemResult{Name: name, Kind: "agent"}
agent, err := resolveAgentResource(agentsSource, name)
if err != nil {
results[i].Error = "agent not found: " + name
continue
}
agents = append(agents, uninstall.Agent{Name: agentMetaKey(agent.RelPath), File: agent.SourcePath})
slots = append(slots, i)
}
for j, err := range s.uninstallAgents(agentsSource, agents) {
res := &results[slots[j]]
if err != nil {
res.Error = fmt.Sprintf("failed to trash agent: %v", err)
continue
}
res.Success, res.MovedToTrash = true, true
}
summary, status, firstErr := summarizeBatchUninstall(results)
s.writeOpsLog("uninstall", status, start, map[string]any{
"names": body.Names,
"kind": "agent",
"scope": "ui",
"count": summary.Succeeded,
}, firstErr)
writeJSON(w, map[string]any{"results": results, "summary": summary})
}
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).
source := s.skillsSource()
walk := s.skillsWalk()
discovered, err := sync.DiscoverSourceSkillsAll(source, walk)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
results := make([]batchUninstallItemResult, len(body.Names))
var items []uninstall.Item
var slots []int // results index of each resolved item
for i, name := range body.Names {
results[i] = batchUninstallItemResult{Name: name, Kind: "skill"}
item, err := s.resolveBatchUninstallItem(discovered, source, walk, name)
if err != nil {
results[i].Error = err.Error()
continue
}
items = append(items, item)
slots = append(slots, i)
}
for j, r := range s.uninstallSkills(items, body.Force) {
res := &results[slots[j]]
if r.Err != nil {
res.Error = uninstallErrorMessage(r)
continue
}
res.Success, res.MovedToTrash = true, true
}
summary, status, firstErr := summarizeBatchUninstall(results)
if summary.Succeeded > 0 {
s.reconcileSkillsConfig(s.cfg.EffectiveSkillsSource())
}
s.writeOpsLog("uninstall", status, start, map[string]any{
"names": body.Names,
"force": body.Force,
"scope": "ui",
"count": summary.Succeeded,
}, firstErr)
writeJSON(w, map[string]any{"results": results, "summary": summary})
}
// summarizeBatchUninstall counts the results and derives the oplog status and
// message from them.
func summarizeBatchUninstall(results []batchUninstallItemResult) (summary batchUninstallSummary, status, firstErr string) {
for _, res := range results {
if res.Success {
summary.Succeeded++
continue
}
summary.Failed++
if firstErr == "" {
firstErr = res.Error
}
}
status = "ok"
if summary.Failed > 0 && summary.Succeeded > 0 {
status = "partial"
} else if summary.Failed > 0 {
status = "error"
}
return summary, status, firstErr
}
// resolveBatchUninstallItem resolves a flat name from the dashboard to a
// tracked repo or a skill.
func (s *Server) resolveBatchUninstallItem(discovered []sync.DiscoveredSkill, source string, walk sourcewalk.Options, name string) (uninstall.Item, error) {
if !validSourceName(name) {
return uninstall.Item{}, errors.New("invalid skill name: " + name)
}
repoPath := filepath.Join(source, name)
_, repoFollowed := walk.Follow.Resolve(repoPath)
managedRepo := strings.HasPrefix(name, "_") && filepath.Base(name) == name && !repoFollowed && install.IsGitRepo(repoPath)
var skill *sync.DiscoveredSkill
if !managedRepo {
var err error
if skill, err = resolveUninstallSkill(discovered, name); err != nil {
return uninstall.Item{}, err
}
}
followed := false
if skill != nil {
_, followed = walk.Follow.Resolve(skill.SourcePath)
}
// An explicit managed repo takes precedence over a skill's basename.
if managedRepo || (strings.HasPrefix(name, "_") && !followed) {
if !install.IsGitRepo(repoPath) {
return uninstall.Item{}, errors.New("not a tracked repository: " + name)
}
return s.repoUninstallItem(name, repoPath), nil
}
if skill == nil {
return uninstall.Item{}, errors.New("skill not found: " + name)
}
if skill.IsInRepo && !followed {
return uninstall.Item{}, errors.New("skill is inside a tracked repo; uninstall the repo instead")
}
return skillUninstallItem(skill, followed), nil
}
// repoUninstallItem describes a tracked repo by its source-relative name.
func (s *Server) repoUninstallItem(name, repoPath string) uninstall.Item {
entry := name
if s.IsProjectMode() {
entry = s.projectGitignorePrefix() + "/" + name
}
return uninstall.Item{Name: name, Path: repoPath, TrashName: name, Repo: true, Gitignore: entry}
}
// skillUninstallItem describes a discovered skill. A skill below a followed
// source link keeps its logical path in the trash so restore goes back through
// the same link.
func skillUninstallItem(skill *sync.DiscoveredSkill, followed bool) uninstall.Item {
trashName := filepath.Base(skill.SourcePath)
if followed {
trashName = skill.RelPath
}
return uninstall.Item{Name: skill.RelPath, Path: skill.SourcePath, TrashName: trashName}
}
// uninstallSkills runs the shared uninstall for resolved skills and repos.
func (s *Server) uninstallSkills(items []uninstall.Item, force bool) []uninstall.Result {
out := uninstall.Run(items, uninstall.Options{
SourceDir: s.skillsSource(),
Follow: s.skillsWalk().Follow,
TrashDir: s.trashBase(),
Store: s.skillsStore,
GitignoreDir: s.gitignoreDir(),
Force: force,
})
if out.GitignoreErr != nil {
log.Printf("warning: failed to clean .gitignore: %v", out.GitignoreErr)
}
if out.SaveErr != nil {
log.Printf("warning: failed to save metadata: %v", out.SaveErr)
}
return out.Results
}
// uninstallAgents runs the shared agent uninstall; errs follows agents.
func (s *Server) uninstallAgents(agentsSource string, agents []uninstall.Agent) []error {
errs, saveErr := uninstall.Agents(agents, agentsSource, s.agentTrashBase(), s.agentsStore)
if saveErr != nil {
log.Printf("warning: failed to save agent metadata after uninstall: %v", saveErr)
}
return errs
}
// uninstallErrorStatus is the HTTP status of a failed single uninstall: a
// refusal is a conflict, a failed move is the server's fault.
func uninstallErrorStatus(err error) int {
var trashErr *uninstall.TrashError
if errors.As(err, &trashErr) {
return http.StatusInternalServerError
}
return http.StatusConflict
}
// uninstallForceCode names the refusals force overrides, so the dashboard
// offers the override for these and nothing else; "" for any other error.
func uninstallForceCode(err error) string {
var statusErr *uninstall.StatusError
switch {
case errors.Is(err, uninstall.ErrDirty):
return "repo_dirty"
case errors.As(err, &statusErr):
return "repo_status_failed"
}
return ""
}
// uninstallErrorMessage words a failed result for the dashboard.
func uninstallErrorMessage(r uninstall.Result) string {
var trashErr *uninstall.TrashError
switch {
case errors.Is(r.Err, uninstall.ErrDirty):
return "uncommitted changes (use force to override)"
case errors.As(r.Err, &trashErr):
if r.Item.Repo {
return fmt.Sprintf("failed to trash repo: %v", trashErr.Err)
}
return fmt.Sprintf("failed to trash skill: %v", trashErr.Err)
}
return r.Err.Error()
}
// ponytail: scan per requested name; index discovery if large batches become slow.
func resolveUninstallSkill(discovered []sync.DiscoveredSkill, name string) (*sync.DiscoveredSkill, error) {
for i := range discovered {
if discovered[i].FlatName == name {
return &discovered[i], nil
}
}
var match *sync.DiscoveredSkill
var candidates []string
for i := range discovered {
if filepath.Base(discovered[i].SourcePath) == name {
match = &discovered[i]
candidates = append(candidates, match.FlatName)
}
}
if len(candidates) > 1 {
return nil, fmt.Errorf("ambiguous skill name %q: use one of %s", name, strings.Join(candidates, ", "))
}
return match, nil
}