mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Batch uninstall treated any name whose last segment starts with "_" and is a git checkout as a tracked repo. A submodule such as _team/vendor/_lib inside a tracked repo matched, so the dashboard could move it out of the repo's checkout, leaving the repo dirty for update. The fallback for "_"-prefixed names had the same hole before --into support. --into folders cannot start with "_" (validate.IntoPath), so a repo name may have "_" only in its last segment; both checks now use that rule. Also, the list TUI gave the root skill of an --into repo (RelPath equal to RepoName, e.g. org/_team) the group "org"; it now has no group, like a top-level repo's root skill.
330 lines
10 KiB
Go
330 lines
10 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"path"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/sourcewalk"
|
|
"skillshare/internal/sync"
|
|
"skillshare/internal/uninstall"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
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)
|
|
// A repo installed with --into is named by its path, e.g. org/_team. --into
|
|
// folders cannot start with "_" (validate.IntoPath), so a deeper _ git dir
|
|
// such as _team/vendor/_lib is part of a tracked repo, not a repo of its own.
|
|
parent, base := path.Split(name)
|
|
repoName := utils.IsTrackedRepoDir(base) && !strings.Contains("/"+parent, "/_")
|
|
managedRepo := repoName && !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 || (repoName && !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
|
|
}
|