Files
skillshare/internal/server/handler_check_stream.go
T
Willie 9847f59a3e feat(check): detect changes at local install sources (#334)
* feat(check): detect changes at local install sources

Skills installed from a local path (for example a skill shipped inside an
app bundle) could already be refreshed with `update`, but `check` always
reported them as "local source", so users had no signal that the source
had changed after an app update.

`check` now re-hashes the files at the recorded source path and compares
them with the hashes stored at install/update time. It reports
update_available on a difference, up_to_date on a match, and an error
naming the path when the source is gone. The path is resolved the same
way `update` resolves it before re-copying, so a successful update always
brings the status back to up_to_date. The CLI and both Web API check
handlers share the comparison in internal/check.

Refs #206

* fix(check): avoid false local-source updates and show check errors

Review follow-ups for local-source change detection:

- The dashboard installs the root of a directory that also holds child
  skills as its SKILL.md alone, so hashing the whole source reported
  update_available right after a clean install. Compare only the files
  such an install copies, recognized by recorded hashes that contain none
  of the child skills present in the source.
- A relative source path resolves against the cwd of the install, which
  is not recorded, so checking from another directory reported a missing
  source. Relative sources are no longer compared.
- The dashboard dropped the new check `message`, so a missing source only
  showed a generic "Check failed". Carry it into the status tooltip.

* revert: restore video files accidentally removed in 1fb13b75

The review-fix commit picked up unrelated staged deletions under video/. They belong to separate work and are not part of this change.
2026-10-02 19:50:58 +08:00

219 lines
5.3 KiB
Go

package server
import (
"net/http"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"time"
"skillshare/internal/check"
"skillshare/internal/install"
)
// handleCheckStream serves an SSE endpoint that streams check progress in real time.
// Events:
// - "discovering" → {"phase":"..."} immediately on connect
// - "start" → {"total": N, "repos": R, "sources": S} after discovery (N = work units)
// - "progress" → {"checked": N} every 200ms
// - "done" → {"tracked_repos":…,"skills":…} final payload (same shape as GET /api/check)
//
// "total" counts actual work units (repos + remote URL groups), NOT individual skills.
// This ensures the progress bar advances evenly — one tick per network call.
func (s *Server) handleCheckStream(w http.ResponseWriter, r *http.Request) {
safeSend, ok := initSSE(w)
if !ok {
return
}
ctx := r.Context()
// Snapshot config under RLock, then release before slow I/O.
s.mu.RLock()
sourceDir := s.skillsSource()
s.mu.RUnlock()
// Immediate feedback before the potentially slow discovery walk.
safeSend("discovering", map[string]string{"phase": "scanning source directory"})
repos, _ := install.GetTrackedRepos(sourceDir)
skills, _ := install.GetUpdatableSkills(sourceDir)
// --- Pre-process: group skills by URL (fast, local only) ---
urlGroups := make(map[urlBranchGroup][]skillWithMetaEntry)
var localResults []skillCheckResult
for _, skill := range skills {
entry := s.skillEntry(skill)
if entry == nil || entry.RepoURL == "" {
localResults = append(localResults, localCheckResult(skill, entry))
continue
}
key := urlBranchGroup{url: entry.RepoURL, branch: entry.Branch}
urlGroups[key] = append(urlGroups[key], skillWithMetaEntry{
name: skill,
entry: entry,
})
}
// Total = repos + URL groups (the actual network-bound work units).
total := len(repos) + len(urlGroups)
safeSend("start", map[string]any{
"total": total,
"repos": len(repos),
"sources": len(urlGroups),
})
// Atomic counter + ticker for progress events
var checked atomic.Int64
done := make(chan struct{})
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
ticker := time.NewTicker(200 * time.Millisecond)
defer ticker.Stop()
for {
select {
case <-ticker.C:
safeSend("progress", map[string]int64{"checked": checked.Load()})
case <-done:
return
case <-ctx.Done():
return
}
}
}()
// --- Phase 1: Check tracked repos (1 work unit per repo) ---
var repoResults []repoCheckResult
for _, repo := range repos {
select {
case <-ctx.Done():
close(done)
wg.Wait()
return
default:
}
repoResults = append(repoResults, checkTrackedRepo(repo, filepath.Join(sourceDir, repo)))
checked.Add(1)
}
// --- Phase 2: Check skills by URL group (1 work unit per URL) ---
skillResults := append([]skillCheckResult{}, localResults...)
for key, group := range urlGroups {
select {
case <-ctx.Done():
close(done)
wg.Wait()
return
default:
}
remoteHash, err := key.remoteHash()
if err != nil {
for _, sw := range group {
r := skillCheckResult{
Name: sw.name,
Source: sw.entry.Source,
Version: sw.entry.Version,
Status: "error",
}
if !sw.entry.InstalledAt.IsZero() {
r.InstalledAt = sw.entry.InstalledAt.Format("2006-01-02")
}
skillResults = append(skillResults, r)
}
checked.Add(1)
continue
}
// Fast path: all commit hashes match
allMatch := true
for _, sw := range group {
if sw.entry.Version != remoteHash {
allMatch = false
break
}
}
if allMatch {
for _, sw := range group {
r := skillCheckResult{
Name: sw.name,
Source: sw.entry.Source,
Version: sw.entry.Version,
Status: "up_to_date",
}
if !sw.entry.InstalledAt.IsZero() {
r.InstalledAt = sw.entry.InstalledAt.Format("2006-01-02")
}
skillResults = append(skillResults, r)
}
checked.Add(1)
continue
}
// Slow path: tree hash comparison
var hasTreeHash bool
for _, sw := range group {
if sw.entry.TreeHash != "" && sw.entry.Subdir != "" {
hasTreeHash = true
break
}
}
var remoteTreeHashes map[string]string
if hasTreeHash {
remoteTreeHashes = check.FetchRemoteTreeHashesForRef(key.url, key.branch)
}
for _, sw := range group {
r := skillCheckResult{
Name: sw.name,
Source: sw.entry.Source,
Version: sw.entry.Version,
}
if !sw.entry.InstalledAt.IsZero() {
r.InstalledAt = sw.entry.InstalledAt.Format("2006-01-02")
}
if sw.entry.Version == remoteHash {
r.Status = "up_to_date"
} else if sw.entry.TreeHash != "" && sw.entry.Subdir != "" && remoteTreeHashes != nil {
normalizedSubdir := strings.TrimPrefix(sw.entry.Subdir, "/")
if rh, ok := remoteTreeHashes[normalizedSubdir]; ok && sw.entry.TreeHash == rh {
r.Status = "up_to_date"
} else {
r.Status = "update_available"
}
} else {
r.Status = "update_available"
}
skillResults = append(skillResults, r)
}
checked.Add(1)
}
// Stop ticker
close(done)
wg.Wait()
if repoResults == nil {
repoResults = []repoCheckResult{}
}
if skillResults == nil {
skillResults = []skillCheckResult{}
}
safeSend("done", map[string]any{
"tracked_repos": repoResults,
"skills": skillResults,
})
}