mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
The dashboard check reimplemented the CLI's per-repo check but fetched without the HTTPS token and ignored git status errors. Private tracked repos could fail in the dashboard while `skillshare check` worked, and a repo whose status could not be read showed as up to date. Both check endpoints now call check.ParallelCheckRepos, the same code the CLI uses. The JSON and SSE response shape does not change. Batch uninstall treated a failed dirty check as clean and moved the repo to trash. Without force, that item now fails with the git error instead. This is stricter than the CLI, which only warns and continues. Batch target updates ignored metadata save failures and still reported success, so an override could silently disappear on the next reload. They now return 500.
222 lines
5.3 KiB
Go
222 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, skillCheckResult{
|
|
Name: skill,
|
|
Status: "local",
|
|
})
|
|
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,
|
|
})
|
|
}
|