mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Separate user-owned followed Git checkouts into linked_repos in check and resources responses so the Updates tab renders information instead of tracked errors or retry actions. Refuse dashboard updates before Git runs, including force retries and descendant skills, while leaving managed repositories unchanged.
201 lines
5.5 KiB
Go
201 lines
5.5 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"`
|
|
Message string `json:"message,omitempty"`
|
|
}
|
|
|
|
// localCheckResult checks a skill without a remote: local installs are
|
|
// compared against their recorded source path, the rest stay "local".
|
|
// projectRoot is the base of relative sources; "" in global mode.
|
|
func localCheckResult(name string, entry *install.MetadataEntry, projectRoot string) skillCheckResult {
|
|
status, message := check.LocalSourceStatus(entry, projectRoot)
|
|
return skillCheckResult{Name: name, Status: status, Message: message}
|
|
}
|
|
|
|
// 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()
|
|
projectRoot := s.projectRoot
|
|
walk := s.skillsWalk()
|
|
s.mu.RUnlock()
|
|
|
|
repos, linked := dashboardRepos(sourceDir, walk)
|
|
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 {
|
|
if followedCheckout(filepath.Join(sourceDir, skill), walk.Follow) != "" {
|
|
continue
|
|
}
|
|
entry := s.skillEntry(skill)
|
|
if entry == nil || entry.RepoURL == "" {
|
|
localResults = append(localResults, localCheckResult(skill, entry, projectRoot))
|
|
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,
|
|
"linked_repos": linked,
|
|
"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)
|
|
}
|