Files
skillshare/internal/server/handler_update_stream.go
T
Willie 4dd62d4ce5 fix: treat tracked repos installed with --into as repos
`install --track --into org` clones to org/_repo, but skill discovery
only marked a skill as in-repo when the first path segment started with
"_". Everything downstream also assumed the repo name was that first
segment. Skills of such a repo were therefore treated as loose skills:
no source in the dashboard, not grouped under the repo, a skill count of
0 in `status`, and an install hint that pointed at the wrong name.

Discovery now records each skill's tracked repo root (RepoRelPath). A
first-segment "_" folder still counts as before; a deeper one counts
only when the walk saw it as a git clone, so a plain org/_drafts folder
stays a folder. The repo's .skillignore is looked up by the same root.

Consumers move from "first segment" to that root:
- the API exposes it as repoPath, and the dashboard groups, updates and
  uninstalls repos by it;
- `list` and `status` use it for repo names and counts;
- batch uninstall accepts a nested repo name, so the dashboard can still
  remove an --into repo now that its skills are in-repo;
- repo names sent to the dashboard by check and update-all use slash
  paths, so they match repoPath on Windows too;
- the install hint suggests `skillshare update org/_repo`.

Fixes #470
2026-10-07 21:23:26 +08:00

200 lines
5.2 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()
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
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
}
// 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, walk)
if err == nil {
for _, repo := range repos {
items = append(items, updateItem{
name: filepath.ToSlash(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"`
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()
switch {
case item.invalid:
result = updateResultItem{Name: item.name, Action: "error", Message: "invalid skill name: " + item.name}
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.
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,
})
}