Files
skillshare/internal/server/handler_update_stream.go
T
Willie 0a3e669b09 fix(audit): decouple audit override from Force so --force reaches the gate
InstallOptions.Force carried two meanings: "overwrite what is already
there" and "proceed despite audit findings". Update paths set Force
unconditionally to overwrite a staged temp dir, so they had to leave it
off to keep the audit gate alive -- which swallowed the caller's --force
and made the gate impossible to override from either the CLI or the web
UI.

Split the audit intent into InstallOptions.AuditOverride and route every
gate through it alone. Entry points translate --force explicitly, so a
missed one degrades to "force has no effect" rather than "audit is
bypassed". Scan failures stay fail-closed regardless: accepting known
findings is not the same as being unable to learn any.

This also closes two paths that bypassed the gate outright, since both
inherited Force for overwrite reasons alone: install --json and grouped
batch updates.

In the web UI, Force Retry now appears only on failures force can
actually resolve -- a permission-denied unlink previously offered a
button that could never succeed -- and CLI-only flag hints are stripped
from messages rendered there.

Behaviour change: a --force at install time no longer exempts later
updates from the audit gate; it is a one-off decision per command.
2026-08-27 17:10:29 +08:00

189 lines
4.7 KiB
Go

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), force, skipAudit
func (s *Server) handleUpdateStream(w http.ResponseWriter, r *http.Request) {
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()
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
path string
}
var items []updateItem
if namesParam != "" {
// Update specific items by name
for name := range strings.SplitSeq(namesParam, ",") {
name = strings.TrimSpace(name)
if name == "" {
continue
}
// Check if it's a tracked repo
repoName := name
if !strings.HasPrefix(repoName, "_") {
repoName = "_" + name
}
repoPath := filepath.Join(source, repoName)
if install.IsGitRepo(repoPath) {
items = append(items, updateItem{name: repoName, isRepo: true, path: repoPath})
continue
}
// Check original name as repo
origPath := filepath.Join(source, name)
if install.IsGitRepo(origPath) {
items = append(items, updateItem{name: name, isRepo: true, path: origPath})
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)
if err == nil {
for _, repo := range repos {
items = append(items, updateItem{
name: repo,
isRepo: true,
path: filepath.Join(source, repo),
})
}
}
skills, err := getServerUpdatableSkills(source, s.skillsStore)
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"`
MissingTrackedRepos []missingTrackedRepoInfo `json:"missingTrackedRepos,omitempty"`
}{}
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()
if item.isRepo {
result = s.updateTrackedRepo(item.name, item.path, force, skipAudit)
} else {
result = s.updateRegularSkill(item.name, item.path, force, skipAudit)
}
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.
if namesParam == "" {
s.mu.RLock()
summary.MissingTrackedRepos = s.missingTrackedRepos()
s.mu.RUnlock()
}
// 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,
})
}