package server import ( "fmt" "net/http" "path/filepath" "strings" "time" "skillshare/internal/install" ) // handleUpdateStream serves an SSE endpoint that streams update progress in real time. // Events: // - "start" → {"total": N} after collecting updatable items // - "result" → updateResultItem after each item is updated // - "done" → {"results":…,"summary":…} final payload // // Query params: names (comma-separated), kind (skill or agent), force, skipAudit func (s *Server) handleUpdateStream(w http.ResponseWriter, r *http.Request) { // Agents are updated by name only; nothing updates them all at once. kind := r.URL.Query().Get("kind") if kind != "" && kind != "skill" && kind != "agent" { writeError(w, http.StatusBadRequest, "invalid kind: "+kind) return } if kind == "agent" && r.URL.Query().Get("names") == "" { writeError(w, http.StatusBadRequest, "names are required for agents") return } safeSend, ok := initSSE(w) if !ok { return } start := time.Now() ctx := r.Context() force := r.URL.Query().Get("force") == "true" skipAudit := r.URL.Query().Get("skipAudit") == "true" // Snapshot source under RLock, then release before slow I/O. s.mu.RLock() source := s.cfg.EffectiveSkillsSource() walk := s.skillsWalk() s.mu.RUnlock() // Collect items to update based on "names" query param. // If names is empty, update all updatable items. namesParam := r.URL.Query().Get("names") type updateItem struct { name string isRepo bool agent bool path string invalid bool // the name would resolve outside the source; reported, never touched } var items []updateItem if namesParam != "" { // Update specific items by name for name := range strings.SplitSeq(namesParam, ",") { name = strings.TrimSpace(name) if name == "" { continue } if !validSourceName(name) { items = append(items, updateItem{name: name, invalid: true}) continue } if kind == "agent" { items = append(items, updateItem{name: name, agent: true}) continue } // A tracked repo (a _-prefixed checkout; an unprefixed one is a regular skill) if repoName, repoPath := install.FindTrackedCheckoutUnlessSkill(source, name); repoPath != "" { items = append(items, updateItem{name: repoName, isRepo: true, path: repoPath}) continue } // Regular skill skillPath := filepath.Join(source, name) items = append(items, updateItem{name: name, isRepo: false, path: skillPath}) } } else { // Update all: tracked repos + regular skills repos, err := install.GetTrackedRepos(source, walk) if err == nil { for _, repo := range repos { items = append(items, updateItem{ name: repo, isRepo: true, path: filepath.Join(source, repo), }) } } s.mu.RLock() skills, err := getServerUpdatableSkills(source, s.skillsStore, walk) s.mu.RUnlock() if err == nil { for _, skill := range skills { items = append(items, updateItem{ name: skill, isRepo: false, path: filepath.Join(source, skill), }) } } } safeSend("start", map[string]int{"total": len(items)}) var results []updateResultItem summary := struct { Updated int `json:"updated"` UpToDate int `json:"upToDate"` Blocked int `json:"blocked"` Errors int `json:"errors"` Skipped int `json:"skipped"` }{} for _, item := range items { // Check if client disconnected select { case <-ctx.Done(): return default: } var result updateResultItem // Lock per-item for write operations s.mu.Lock() switch { case item.invalid: result = updateResultItem{Name: item.name, Action: "error", Message: "invalid skill name: " + item.name} case item.agent: result = s.updateSingleByKind(item.name, "agent", force, skipAudit) case item.isRepo: result = s.updateTrackedRepo(item.name, item.path, s.cfg.EffectiveSkillsSource(), force, skipAudit, walk.Follow) default: result = s.updateRegularSkill(item.name, item.path, force, skipAudit, walk.Follow) } s.mu.Unlock() results = append(results, result) switch result.Action { case "updated": summary.Updated++ case "up-to-date": summary.UpToDate++ case "blocked": summary.Blocked++ case "error": summary.Errors++ case "skipped": summary.Skipped++ } safeSend("result", result) } // Surface tracked repos declared in metadata but absent on disk (issue #212). // Only relevant for the update-all flow, not targeted updates. // Write ops log s.mu.Lock() status := "ok" msg := "" if summary.Blocked > 0 { status = "partial" msg = fmt.Sprintf("%d update(s) blocked by security audit", summary.Blocked) } if summary.Errors > 0 { status = "partial" if msg != "" { msg += fmt.Sprintf(", %d update(s) failed", summary.Errors) } else { msg = fmt.Sprintf("%d update(s) failed", summary.Errors) } } s.writeOpsLog("update", status, start, map[string]any{ "name": "--all-stream", "force": force, "skip_audit": skipAudit, "results_total": len(results), "results_failed": summary.Errors, "results_blocked": summary.Blocked, "scope": "ui", }, msg) s.mu.Unlock() safeSend("done", map[string]any{ "results": results, "summary": summary, }) }