Files
skillshare/internal/server/handler_check.go
T
Willie 115236a6fb fix(server): use token auth when checking default-branch skill remotes
The dashboard check fetched the remote HEAD without credentials when a
skill had no pinned branch. Private repos therefore reported an error in
the dashboard while the CLI check, which uses
GetRemoteHeadHashWithAuth, succeeded. The pinned-branch path already
used auth, and the default-branch path now matches it.
2026-09-30 01:44:50 +08:00

189 lines
4.9 KiB
Go

package server
import (
"net/http"
"path/filepath"
"strings"
"skillshare/internal/check"
"skillshare/internal/git"
"skillshare/internal/install"
)
// skillWithMetaEntry holds a skill name paired with its centralized metadata entry.
type skillWithMetaEntry struct {
name string
entry *install.MetadataEntry
}
type repoCheckResult struct {
Name string `json:"name"`
Status string `json:"status"`
Behind int `json:"behind"`
Message string `json:"message,omitempty"`
}
type skillCheckResult struct {
Name string `json:"name"`
Source string `json:"source"`
Version string `json:"version"`
Status string `json:"status"`
InstalledAt string `json:"installed_at,omitempty"`
Kind string `json:"kind,omitempty"`
}
// checkTrackedRepo checks one tracked repo with the same logic as the CLI:
// auth-aware fetch and a reported dirty-check error.
func checkTrackedRepo(name, repoPath string) repoCheckResult {
out := check.ParallelCheckRepos([]check.RepoCheckInput{{Name: name, RepoPath: repoPath}}, nil)[0]
return repoCheckResult{Name: out.Name, Status: out.Status, Behind: out.Behind, Message: out.Message}
}
func (s *Server) handleCheck(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
sourceDir := s.skillsSource()
s.mu.RUnlock()
repos, _ := install.GetTrackedRepos(sourceDir)
skills, _ := install.GetUpdatableSkills(sourceDir)
var repoResults []repoCheckResult
for _, repo := range repos {
repoResults = append(repoResults, checkTrackedRepo(repo, filepath.Join(sourceDir, repo)))
}
// Group skills by repo URL+branch for efficient checking
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,
})
}
skillResults := append([]skillCheckResult{}, localResults...)
for key, group := range urlGroups {
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)
}
continue
}
// Fast path: check if all skills match by commit hash
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)
}
continue
}
// Slow path: HEAD moved — try 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)
}
}
if repoResults == nil {
repoResults = []repoCheckResult{}
}
if skillResults == nil {
skillResults = []skillCheckResult{}
}
writeJSON(w, map[string]any{
"tracked_repos": repoResults,
"skills": skillResults,
})
}
// urlBranchGroup keys skills that share a clone URL and installed branch, so a
// skill installed from a non-default branch is checked against that branch
// rather than the remote HEAD.
type urlBranchGroup struct {
url string
branch string
}
func (g urlBranchGroup) remoteHash() (string, error) {
if g.branch != "" {
return git.GetRemoteRefHashWithAuth(g.url, g.branch)
}
return git.GetRemoteHeadHashWithAuth(g.url)
}