package server import ( "errors" "fmt" "log" "net/http" "os" "path/filepath" "strings" "time" "skillshare/internal/audit" "skillshare/internal/config" "skillshare/internal/git" "skillshare/internal/install" "skillshare/internal/utils" ) type updateRequest struct { Name string `json:"name"` Kind string `json:"kind,omitempty"` Force bool `json:"force"` All bool `json:"all"` SkipAudit bool `json:"skipAudit"` } // missingTrackedRepoInfo describes a tracked repo declared in metadata whose // clone directory is absent on disk. Carried in update responses so the UI can // warn and offer rehydration (issue #212). type missingTrackedRepoInfo struct { Name string `json:"name"` Source string `json:"source"` Branch string `json:"branch,omitempty"` } // missingTrackedRepos returns tracked repos declared in metadata but absent on disk. func (s *Server) missingTrackedRepos() []missingTrackedRepoInfo { repos, err := install.GetMissingTrackedRepos(s.cfg.EffectiveSkillsSource()) if err != nil || len(repos) == 0 { return nil } out := make([]missingTrackedRepoInfo, 0, len(repos)) for _, r := range repos { out = append(out, missingTrackedRepoInfo{Name: r.Name, Source: r.Source, Branch: r.Branch}) } return out } type updateResultItem struct { Name string `json:"name"` Action string `json:"action"` // "updated", "up-to-date", "skipped", "error", "blocked" Message string `json:"message,omitempty"` IsRepo bool `json:"isRepo"` AuditRiskScore int `json:"auditRiskScore,omitempty"` AuditRiskLabel string `json:"auditRiskLabel,omitempty"` Kind string `json:"kind,omitempty"` } func (s *Server) updateAuditThreshold() string { if s.IsProjectMode() && s.projectCfg != nil { if threshold, err := audit.NormalizeThreshold(s.projectCfg.Audit.BlockThreshold); err == nil { return threshold } return audit.DefaultThreshold() } if s.cfg != nil { if threshold, err := audit.NormalizeThreshold(s.cfg.Audit.BlockThreshold); err == nil { return threshold } } return audit.DefaultThreshold() } func (s *Server) handleUpdate(w http.ResponseWriter, r *http.Request) { start := time.Now() s.mu.Lock() defer s.mu.Unlock() defer s.trackProjectLock()() var body updateRequest if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil { if !errors.Is(err, errBodyTooLarge) { writeError(w, http.StatusBadRequest, "invalid JSON body") } return } if body.All { results := s.updateAll(body.Force, body.SkipAudit) total := len(results) failed := 0 blocked := 0 for _, item := range results { if item.Action == "error" { failed++ } else if item.Action == "blocked" { blocked++ } } status := "ok" msg := "" if blocked > 0 { status = "partial" msg = fmt.Sprintf("%d update(s) blocked by security audit", blocked) } if failed > 0 { status = "partial" if msg != "" { msg += fmt.Sprintf(", %d update(s) failed", failed) } else { msg = fmt.Sprintf("%d update(s) failed", failed) } } s.writeOpsLog("update", status, start, map[string]any{ "name": "--all", "force": body.Force, "skip_audit": body.SkipAudit, "results_total": total, "results_failed": failed, "results_blocked": blocked, "scope": "ui", }, msg) writeJSON(w, map[string]any{"results": results, "missingTrackedRepos": s.missingTrackedRepos()}) return } if body.Name == "" { writeError(w, http.StatusBadRequest, "name is required (or use all: true)") return } if body.Kind != "" && body.Kind != "skill" && body.Kind != "agent" { writeError(w, http.StatusBadRequest, "invalid kind: "+body.Kind) return } result := s.updateSingleByKind(body.Name, body.Kind, body.Force, body.SkipAudit) status := "ok" msg := "" if result.Action == "error" { status = "error" msg = result.Message } else if result.Action == "blocked" { status = "error" msg = result.Message } else if result.Action == "skipped" { status = "partial" msg = result.Message } s.writeOpsLog("update", status, start, map[string]any{ "name": body.Name, "force": body.Force, "skip_audit": body.SkipAudit, "scope": "ui", }, msg) writeJSON(w, map[string]any{"results": []updateResultItem{result}}) } func (s *Server) updateSingle(name string, force, skipAudit bool) updateResultItem { return s.updateSingleByKind(name, "", force, skipAudit) } func (s *Server) updateSingleByKind(name, kind string, force, skipAudit bool) updateResultItem { if kind == "agent" { return s.updateAgent(name, force, skipAudit) } // Try exact skill path first (prevents basename collision with nested repos) skillPath := filepath.Join(s.cfg.EffectiveSkillsSource(), name) if entry := s.skillsStore.GetByPath(name); entry != nil && entry.Source != "" { return s.updateRegularSkill(name, skillPath, force, skipAudit) } // Try tracked repo (flat, nested, or basename fallback) repoName, repoPath, err := s.resolveTrackedRepo(name) if err != nil { return updateResultItem{Name: name, Action: "error", Message: err.Error()} } if repoPath != "" { return s.updateTrackedRepo(repoName, repoPath, force, skipAudit) } return updateResultItem{ Name: name, Action: "error", Message: fmt.Sprintf("'%s' not found as tracked repo or updatable skill", name), } } func (s *Server) updateAgent(name string, force, skipAudit bool) updateResultItem { agentsSource := s.agentsSource() if agentsSource == "" { return updateResultItem{Name: name, Kind: "agent", Action: "error", Message: "agents source is not configured"} } localAgent, err := resolveAgentResource(agentsSource, name) if err != nil { return updateResultItem{Name: name, Kind: "agent", Action: "error", Message: err.Error()} } if localAgent.RepoRelPath != "" { repoPath := filepath.Join(agentsSource, filepath.FromSlash(localAgent.RepoRelPath)) return s.updateTrackedRepo(agentMetaKey(localAgent.RelPath), repoPath, force, skipAudit) } metaKey := agentMetaKey(localAgent.RelPath) entry := s.agentsStore.GetByPath(metaKey) if entry == nil || entry.Source == "" { return updateResultItem{ Name: metaKey, Kind: "agent", Action: "skipped", Message: "agent is local and has no update source", } } source, err := install.ParseSourceWithOptions(entry.Source, s.parseOpts()) if err != nil { return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: "invalid source: " + err.Error()} } source.ApplyRecordedBranch(entry.Branch) repoSubdir := strings.TrimSuffix(source.Subdir, entry.Subdir) repoSubdir = strings.TrimRight(repoSubdir, "/") source.Subdir = repoSubdir var discovery *install.DiscoveryResult if source.HasSubdir() { discovery, err = install.DiscoverFromGitSubdir(source) } else { discovery, err = install.DiscoverFromGit(source) } if err != nil { return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: err.Error()} } defer install.CleanupDiscovery(discovery) if discovery.CommitHash != "" && discovery.CommitHash == entry.Version { return updateResultItem{Name: metaKey, Kind: "agent", Action: "up-to-date"} } var target *install.AgentInfo for i := range discovery.Agents { candidate := discovery.Agents[i] if candidate.Path == entry.Subdir || candidate.FileName == filepath.Base(localAgent.RelPath) || candidate.Name == filepath.Base(metaKey) { target = &discovery.Agents[i] break } } if target == nil { return updateResultItem{ Name: metaKey, Kind: "agent", Action: "error", Message: fmt.Sprintf("agent path %q not found in repository", entry.Subdir), } } destDir := agentsSource opts := install.InstallOptions{ Kind: "agent", Force: force, Update: true, SkipAudit: skipAudit, AuditThreshold: s.updateAuditThreshold(), SourceDir: agentsSource, } if s.IsProjectMode() { opts.AuditProjectRoot = s.projectRoot } res, err := install.UpdateAgentFromDiscovery(discovery, *target, destDir, opts) if err != nil { return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: err.Error()} } if st, loadErr := install.LoadMetadataWithMigration(agentsSource, install.MetadataKindAgent); loadErr == nil && st != nil { s.agentsStore = st } message := res.Action if message == "" { message = "updated" } return updateResultItem{ Name: metaKey, Kind: "agent", Action: "updated", Message: message, } } func (s *Server) updateTrackedRepo(name, repoPath string, force, skipAudit bool) updateResultItem { // Check for uncommitted changes if isDirty, _ := git.IsDirty(repoPath); isDirty { if !force { return updateResultItem{ Name: name, Action: "skipped", Message: "has uncommitted changes (use force to discard)", IsRepo: true, } } if err := git.Restore(repoPath); err != nil { return updateResultItem{ Name: name, Action: "error", Message: "failed to discard changes: " + err.Error(), IsRepo: true, } } } var info *git.UpdateInfo var err error if force { info, err = git.ForcePullWithAuth(repoPath) } else { info, err = git.PullWithAuth(repoPath) } if err != nil { msg := err.Error() if !force { msg += " (try force update)" } return updateResultItem{ Name: name, Action: "error", Message: msg, IsRepo: true, } } if info.UpToDate { return updateResultItem{Name: name, Action: "up-to-date", IsRepo: true} } // Post-pull audit gate item := updateResultItem{ Name: name, Action: "updated", Message: fmt.Sprintf("%d commits, %d files changed", len(info.Commits), info.Stats.FilesChanged), IsRepo: true, } if !skipAudit { blocked, auditResult := s.auditGateTrackedRepo(name, repoPath, info.BeforeHash, force, s.updateAuditThreshold()) if blocked != nil { return *blocked } if auditResult != nil { item.AuditRiskScore = auditResult.RiskScore item.AuditRiskLabel = auditResult.RiskLabel } } return item } // auditGateTrackedRepo scans a tracked repo after pull and rolls back if findings are detected // at or above the active threshold. // Returns (blocked item, audit result). blocked is non-nil when the update should be rejected. func (s *Server) auditGateTrackedRepo(name, repoPath, beforeHash string, force bool, threshold string) (*updateResultItem, *audit.Result) { var result *audit.Result var err error if s.IsProjectMode() { result, err = audit.ScanSkillForProject(repoPath, s.projectRoot) } else { result, err = audit.ScanSkill(repoPath) } if err != nil { msg := "security audit failed: " + err.Error() if beforeHash == "" { msg += " (rollback commit unavailable, repository state is unknown)" } else if resetErr := git.ResetHard(repoPath, beforeHash); resetErr != nil { msg += " (WARNING: rollback also failed: " + resetErr.Error() + " — malicious content may remain)" } else { msg += " (rolled back)" } return &updateResultItem{ Name: name, Action: "blocked", Message: msg, IsRepo: true, }, nil } if result.HasSeverityAtOrAbove(threshold) && !force { msg := fmt.Sprintf("blocked by security audit — findings at/above %s detected", threshold) if beforeHash == "" { msg += " (rollback commit unavailable, repository state is unknown)" } else if resetErr := git.ResetHard(repoPath, beforeHash); resetErr != nil { msg += " (WARNING: rollback failed: " + resetErr.Error() + " — malicious content may remain)" } else { msg += ", rolled back" } return &updateResultItem{ Name: name, Action: "blocked", Message: msg, IsRepo: true, }, result } return nil, result } func (s *Server) updateRegularSkill(name, skillPath string, force, skipAudit bool) updateResultItem { entry := s.skillsStore.GetByPath(name) if entry == nil { return updateResultItem{Name: name, Action: "error", Message: "no metadata found"} } source, err := install.ParseSourceWithOptions(entry.Source, s.parseOpts()) if err != nil { return updateResultItem{ Name: name, Action: "error", Message: "invalid source: " + err.Error(), } } source.ApplyRecordedBranch(entry.Branch) sourceDir := s.cfg.EffectiveSkillsSource() opts := install.InstallOptions{ Force: true, AuditOverride: force, Update: true, SkipAudit: skipAudit, AuditThreshold: s.updateAuditThreshold(), SourceDir: sourceDir, } if s.IsProjectMode() { opts.AuditProjectRoot = s.projectRoot } result, err := install.Install(source, skillPath, opts) if err != nil { return updateResultItem{ Name: name, Action: "error", Message: err.Error(), } } if st, loadErr := install.LoadMetadataWithMigration(sourceDir, ""); loadErr == nil && st != nil { s.skillsStore = st } item := updateResultItem{ Name: name, Action: "updated", Message: "reinstalled from source", } if result != nil && result.AuditRiskLabel != "" { item.AuditRiskScore = result.AuditRiskScore item.AuditRiskLabel = result.AuditRiskLabel } return item } func (s *Server) updateAll(force, skipAudit bool) []updateResultItem { var results []updateResultItem // Update tracked repos repos, err := install.GetTrackedRepos(s.cfg.EffectiveSkillsSource()) if err == nil { for _, repo := range repos { repoPath := filepath.Join(s.cfg.EffectiveSkillsSource(), repo) results = append(results, s.updateTrackedRepo(repo, repoPath, force, skipAudit)) } } // Update regular skills with source metadata skills, err := getServerUpdatableSkills(s.cfg.EffectiveSkillsSource(), s.skillsStore) if err == nil { for _, skill := range skills { skillPath := filepath.Join(s.cfg.EffectiveSkillsSource(), skill) results = append(results, s.updateRegularSkill(skill, skillPath, force, skipAudit)) } } return results } // handleMissingTrackedRepos returns tracked repos declared in metadata whose // clone directories are absent on disk (issue #212), so the UI can warn on load. func (s *Server) handleMissingTrackedRepos(w http.ResponseWriter, r *http.Request) { s.mu.RLock() repos := s.missingTrackedRepos() s.mu.RUnlock() if repos == nil { repos = []missingTrackedRepoInfo{} } writeJSON(w, map[string]any{"repos": repos}) } // handleRehydrateTrackedRepos re-clones tracked repos declared in metadata whose // clone directories are absent on disk (issue #212). Mirrors bare CLI install. func (s *Server) handleRehydrateTrackedRepos(w http.ResponseWriter, r *http.Request) { start := time.Now() s.mu.Lock() defer s.mu.Unlock() sourceDir := s.cfg.EffectiveSkillsSource() opts := install.InstallOptions{ AuditThreshold: s.updateAuditThreshold(), SourceDir: sourceDir, } if s.IsProjectMode() { opts.AuditProjectRoot = s.projectRoot } results, err := install.RehydrateMissingTrackedRepos(sourceDir, s.parseOpts(), opts) if err != nil { writeError(w, http.StatusInternalServerError, err.Error()) return } // Reload metadata + reconcile config so newly cloned repos register. if st, lerr := install.LoadMetadataWithMigration(sourceDir, ""); lerr == nil && st != nil { s.skillsStore = st } s.reconcileSkillsConfig(sourceDir) rehydrated, failed := 0, 0 for _, res := range results { if res.Action == "rehydrated" { rehydrated++ } else { failed++ } } status, msg := "ok", "" if failed > 0 { status = "partial" msg = fmt.Sprintf("%d repo(s) failed to rehydrate", failed) } s.writeOpsLog("install", status, start, map[string]any{ "name": "--rehydrate", "tracked": true, "scope": "ui", "rehydrated": rehydrated, "failed": failed, }, msg) writeJSON(w, map[string]any{"results": results}) } // getServerUpdatableSkills returns relative paths of skills that have metadata with a remote source. // It walks the source directory recursively to find nested skills (e.g. utils/ascii-box-check). func getServerUpdatableSkills(sourceDir string, store *install.MetadataStore) ([]string, error) { var skills []string walkRoot := utils.ResolveSymlink(sourceDir) err := filepath.WalkDir(walkRoot, func(path string, d os.DirEntry, err error) error { if err != nil { return nil } if path == walkRoot { return nil } if !d.IsDir() { return nil } name := d.Name() // Skip hidden directories and .git if name == ".git" || (len(name) > 0 && name[0] == '.') { return filepath.SkipDir } // Skip tracked repos (_ prefix with .git inside) if len(name) > 0 && name[0] == '_' { return filepath.SkipDir } // Check if this directory has updatable metadata relName := filepath.Base(path) if relP, relErr2 := filepath.Rel(walkRoot, path); relErr2 == nil { relName = filepath.ToSlash(relP) } entry := store.GetByPath(relName) if entry == nil || entry.Source == "" { return nil // continue walking into subdirectories } relPath, relErr := filepath.Rel(walkRoot, path) if relErr == nil { skills = append(skills, filepath.ToSlash(relPath)) } return filepath.SkipDir // don't recurse into skill directories }) if err != nil { return nil, err } return skills, nil } // trackProjectLock returns a function for defer: it moves the lockfile pins of // the skills the request changed. Global mode has no lockfile. func (s *Server) trackProjectLock() func() { if !s.IsProjectMode() { return func() {} } done := config.TrackProjectLock(s.projectRoot, s.projectCfg, s.cfg.EffectiveSkillsSource()) return func() { if err := done(); err != nil { log.Printf("warning: failed to update %s: %v", install.LockFileName, err) } } }