Files
skillshare/internal/server/handler_update.go
T
Willie f2f663689b fix(install): warn about submodules on tracked updates
The CLI and dashboard update a tracked repo through update.TrackedRepo,
which never looked for submodules. A pull that turned a skill directory
into a submodule reported success and the skill vanished on the next
sync. TrackedRepoResult now carries the skipped-submodule warnings and
both callers show them.

Refs #433
2026-10-07 09:35:59 +08:00

591 lines
18 KiB
Go

package server
import (
"errors"
"fmt"
"log"
"net/http"
"os"
"path/filepath"
"strings"
"time"
"skillshare/internal/audit"
"skillshare/internal/config"
"skillshare/internal/install"
"skillshare/internal/sourcewalk"
"skillshare/internal/update"
"skillshare/internal/utils"
)
type updateRequest struct {
Name string `json:"name"`
Kind string `json:"kind,omitempty"`
Force bool `json:"force"`
All bool `json:"all"`
SkipAudit bool `json:"skipAudit"`
}
// missingTrackedRepoInfo describes a tracked repo declared in metadata whose
// clone directory is absent on disk. Carried in update responses so the UI can
// warn and offer rehydration (issue #212).
type missingTrackedRepoInfo struct {
Name string `json:"name"`
Source string `json:"source"`
Branch string `json:"branch,omitempty"`
}
// missingTrackedRepos returns tracked repos declared in metadata but absent on disk.
func (s *Server) missingTrackedRepos() []missingTrackedRepoInfo {
repos, err := install.GetMissingTrackedRepos(s.cfg.EffectiveSkillsSource(), s.skillsWalk())
if err != nil || len(repos) == 0 {
return nil
}
out := make([]missingTrackedRepoInfo, 0, len(repos))
for _, r := range repos {
out = append(out, missingTrackedRepoInfo{Name: r.Name, Source: r.Source, Branch: r.Branch})
}
return out
}
type updateResultItem struct {
Name string `json:"name"`
Action string `json:"action"` // "updated", "up-to-date", "skipped", "error", "blocked"
Message string `json:"message,omitempty"`
IsRepo bool `json:"isRepo"`
AuditRiskScore int `json:"auditRiskScore,omitempty"`
AuditRiskLabel string `json:"auditRiskLabel,omitempty"`
Kind string `json:"kind,omitempty"`
}
func (s *Server) updateAuditThreshold() string {
if s.IsProjectMode() && s.projectCfg != nil {
if threshold, err := audit.NormalizeThreshold(s.projectCfg.Audit.BlockThreshold); err == nil {
return threshold
}
return audit.DefaultThreshold()
}
if s.cfg != nil {
if threshold, err := audit.NormalizeThreshold(s.cfg.Audit.BlockThreshold); err == nil {
return threshold
}
}
return audit.DefaultThreshold()
}
func (s *Server) handleUpdate(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
defer s.trackProjectLock()()
var body updateRequest
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if body.All {
results := s.updateAll(body.Force, body.SkipAudit)
total := len(results)
failed := 0
blocked := 0
for _, item := range results {
if item.Action == "error" {
failed++
} else if item.Action == "blocked" {
blocked++
}
}
status := "ok"
msg := ""
if blocked > 0 {
status = "partial"
msg = fmt.Sprintf("%d update(s) blocked by security audit", blocked)
}
if failed > 0 {
status = "partial"
if msg != "" {
msg += fmt.Sprintf(", %d update(s) failed", failed)
} else {
msg = fmt.Sprintf("%d update(s) failed", failed)
}
}
s.writeOpsLog("update", status, start, map[string]any{
"name": "--all",
"force": body.Force,
"skip_audit": body.SkipAudit,
"results_total": total,
"results_failed": failed,
"results_blocked": blocked,
"scope": "ui",
}, msg)
writeJSON(w, map[string]any{"results": results, "missingTrackedRepos": s.missingTrackedRepos()})
return
}
if body.Name == "" {
writeError(w, http.StatusBadRequest, "name is required (or use all: true)")
return
}
if body.Kind != "" && body.Kind != "skill" && body.Kind != "agent" {
writeError(w, http.StatusBadRequest, "invalid kind: "+body.Kind)
return
}
if body.Kind != "agent" && !validSourceName(body.Name) {
writeError(w, http.StatusBadRequest, "invalid skill name: "+body.Name)
return
}
result := s.updateSingleByKind(body.Name, body.Kind, body.Force, body.SkipAudit)
status := "ok"
msg := ""
if result.Action == "error" {
status = "error"
msg = result.Message
} else if result.Action == "blocked" {
status = "error"
msg = result.Message
} else if result.Action == "skipped" {
status = "partial"
msg = result.Message
}
s.writeOpsLog("update", status, start, map[string]any{
"name": body.Name,
"force": body.Force,
"skip_audit": body.SkipAudit,
"scope": "ui",
}, msg)
writeJSON(w, map[string]any{"results": []updateResultItem{result}})
}
func (s *Server) updateSingle(name string, force, skipAudit bool) updateResultItem {
return s.updateSingleByKind(name, "", force, skipAudit)
}
func (s *Server) updateSingleByKind(name, kind string, force, skipAudit bool) updateResultItem {
if kind == "agent" {
return s.updateAgent(name, force, skipAudit)
}
walk := s.skillsWalk()
// Try exact skill path first (prevents basename collision with nested repos)
skillPath := filepath.Join(s.cfg.EffectiveSkillsSource(), name)
if refusal := s.refuseFollowedCheckout(name, skillPath, []*sourcewalk.Follow{walk.Follow}); refusal != nil {
return *refusal
}
if entry := s.skillsStore.GetByPath(name); entry != nil && entry.Source != "" {
return s.updateRegularSkill(name, skillPath, force, skipAudit, walk.Follow)
}
// Try tracked repo (flat, nested, or basename fallback)
repoName, repoPath, err := s.resolveTrackedRepo(name, walk)
if err != nil {
return updateResultItem{Name: name, Action: "error", Message: err.Error()}
}
if repoPath != "" {
return s.updateTrackedRepo(repoName, repoPath, s.cfg.EffectiveSkillsSource(), force, skipAudit, walk.Follow)
}
return updateResultItem{
Name: name,
Action: "error",
Message: fmt.Sprintf("'%s' not found as tracked repo or updatable skill", name),
}
}
func (s *Server) updateAgent(name string, force, skipAudit bool) updateResultItem {
agentsSource := s.agentsSource()
if agentsSource == "" {
return updateResultItem{Name: name, Kind: "agent", Action: "error", Message: "agents source is not configured"}
}
localAgent, err := resolveAgentResource(agentsSource, name)
if err != nil {
return updateResultItem{Name: name, Kind: "agent", Action: "error", Message: err.Error()}
}
if localAgent.RepoRelPath != "" {
repoPath := filepath.Join(agentsSource, filepath.FromSlash(localAgent.RepoRelPath))
return s.updateTrackedRepo(agentMetaKey(localAgent.RelPath), repoPath, "", force, skipAudit)
}
metaKey := agentMetaKey(localAgent.RelPath)
entry := s.agentsStore.GetByPath(metaKey)
if entry == nil || entry.Source == "" {
return updateResultItem{
Name: metaKey,
Kind: "agent",
Action: "skipped",
Message: "agent is local and has no update source",
}
}
source, err := install.ParseSourceWithOptions(entry.Source, s.parseOpts())
if err != nil {
return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: "invalid source: " + err.Error()}
}
source.ApplyRecordedBranch(entry.Branch)
repoSubdir := strings.TrimSuffix(source.Subdir, entry.Subdir)
repoSubdir = strings.TrimRight(repoSubdir, "/")
source.Subdir = repoSubdir
var discovery *install.DiscoveryResult
if source.HasSubdir() {
discovery, err = install.DiscoverFromGitSubdir(source)
} else {
discovery, err = install.DiscoverFromGit(source)
}
if err != nil {
return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: err.Error()}
}
defer install.CleanupDiscovery(discovery)
if discovery.CommitHash != "" && discovery.CommitHash == entry.Version {
return updateResultItem{Name: metaKey, Kind: "agent", Action: "up-to-date"}
}
var target *install.AgentInfo
for i := range discovery.Agents {
candidate := discovery.Agents[i]
if candidate.Path == entry.Subdir ||
candidate.FileName == filepath.Base(localAgent.RelPath) ||
candidate.Name == filepath.Base(metaKey) {
target = &discovery.Agents[i]
break
}
}
if target == nil {
return updateResultItem{
Name: metaKey,
Kind: "agent",
Action: "error",
Message: fmt.Sprintf("agent path %q not found in repository", entry.Subdir),
}
}
destDir := agentsSource
opts := install.InstallOptions{
Kind: "agent",
Force: force,
Update: true,
SkipAudit: skipAudit,
AuditThreshold: s.updateAuditThreshold(),
SourceDir: agentsSource,
}
if s.IsProjectMode() {
opts.AuditProjectRoot = s.projectRoot
}
res, err := install.UpdateAgentFromDiscovery(discovery, *target, destDir, opts)
if err != nil {
return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: err.Error()}
}
if st, loadErr := install.LoadMetadataWithMigration(agentsSource, install.MetadataKindAgent); loadErr == nil && st != nil {
s.agentsStore = st
}
message := res.Action
if message == "" {
message = "updated"
}
return updateResultItem{
Name: metaKey,
Kind: "agent",
Action: "updated",
Message: message,
}
}
// updateTrackedRepo runs the shared tracked-repo update and reports it as a
// result item. sourceDir is the source root whose metadata is refreshed; pass
// "" for repos that have none there (agent repos).
func (s *Server) updateTrackedRepo(name, repoPath, sourceDir string, force, skipAudit bool, follow ...*sourcewalk.Follow) updateResultItem {
if refusal := s.refuseFollowedCheckout(name, repoPath, follow); refusal != nil {
return *refusal
}
// AcceptedFindings stays off: a dashboard force update is not remembered,
// and findings accepted from the CLI still block here.
opts := update.TrackedRepoOptions{
SourceDir: sourceDir,
Force: force,
SkipAudit: skipAudit,
Threshold: s.updateAuditThreshold(),
}
if len(follow) > 0 {
opts.Follow = follow[0]
}
if s.IsProjectMode() {
opts.ProjectRoot = s.projectRoot
}
res, err := update.TrackedRepo(repoPath, opts)
item := updateResultItem{Name: name, IsRepo: true}
var blocked *install.AuditGateError
var opErr *update.Error
switch {
case errors.As(err, &blocked):
item.Action = "blocked"
item.Message = trackedBlockMessage(blocked)
return item
case errors.As(err, &opErr) && opErr.Stage == update.StagePull:
item.Action = "error"
item.Message = opErr.Err.Error()
if !force {
item.Message += " (try force update)"
}
return item
case err != nil:
item.Action = "error"
item.Message = err.Error()
return item
}
if res.MetadataErr != nil {
log.Printf("warning: failed to refresh metadata for %s: %v", name, res.MetadataErr)
}
if res.MetadataChanged {
s.reloadSkillsStore()
}
switch res.Status {
case update.StatusDirty:
item.Action = "skipped"
item.Message = "has uncommitted changes (use force to discard)"
case update.StatusUpToDate:
item.Action = "up-to-date"
default:
item.Action = "updated"
item.Message = fmt.Sprintf("%d commits, %d files changed", len(res.Info.Commits), res.Info.Stats.FilesChanged)
for _, w := range res.Warnings {
item.Message += "; " + w
}
if res.Audit != nil {
item.AuditRiskScore = res.Audit.RiskScore
item.AuditRiskLabel = res.Audit.RiskLabel
}
}
return item
}
// trackedBlockMessage words a blocked update for the dashboard, which offers
// Force Retry only for messages containing "blocked by security audit".
func trackedBlockMessage(e *install.AuditGateError) string {
switch {
case e.Rollback == install.RollbackUnavailable:
return "security audit failed (" + e.RollbackNote() + ")"
case e.ScanErr != nil:
return "security audit failed: " + e.ScanErr.Error() + " (" + e.RollbackNote() + ")"
case e.Rollback == install.RolledBack:
return fmt.Sprintf("blocked by security audit — findings at/above %s detected, rolled back", e.Threshold)
}
return fmt.Sprintf("blocked by security audit — findings at/above %s detected (%s)", e.Threshold, e.RollbackNote())
}
func (s *Server) updateRegularSkill(name, skillPath string, force, skipAudit bool, follow ...*sourcewalk.Follow) updateResultItem {
if refusal := s.refuseFollowedCheckout(name, skillPath, follow); refusal != nil {
return *refusal
}
entry := s.skillsStore.GetByPath(name)
if entry == nil {
return updateResultItem{Name: name, Action: "error", Message: "no metadata found"}
}
source, err := install.ParseSourceWithOptions(entry.Source, s.parseOpts())
if err != nil {
return updateResultItem{
Name: name,
Action: "error",
Message: "invalid source: " + err.Error(),
}
}
source.ApplyRecordedBranch(entry.Branch)
sourceDir := s.cfg.EffectiveSkillsSource()
opts := install.InstallOptions{
Force: true,
AuditOverride: force,
Update: true,
SkipAudit: skipAudit,
AuditThreshold: s.updateAuditThreshold(),
SourceDir: sourceDir,
}
if len(follow) > 0 {
opts.SourceFollow = follow[0]
}
if s.IsProjectMode() {
opts.AuditProjectRoot = s.projectRoot
}
result, err := install.Install(source, skillPath, opts)
if err != nil {
return updateResultItem{
Name: name,
Action: "error",
Message: err.Error(),
}
}
if st, loadErr := install.LoadMetadataWithMigration(sourceDir, ""); loadErr == nil && st != nil {
s.skillsStore = st
}
item := updateResultItem{
Name: name,
Action: "updated",
Message: "reinstalled from source",
}
if result != nil && result.AuditRiskLabel != "" {
item.AuditRiskScore = result.AuditRiskScore
item.AuditRiskLabel = result.AuditRiskLabel
}
return item
}
func (s *Server) updateAll(force, skipAudit bool) []updateResultItem {
var results []updateResultItem
// Update tracked repos
walk := s.skillsWalk()
repos, err := install.GetTrackedRepos(s.cfg.EffectiveSkillsSource(), walk)
if err == nil {
for _, repo := range repos {
repoPath := filepath.Join(s.cfg.EffectiveSkillsSource(), repo)
results = append(results, s.updateTrackedRepo(repo, repoPath, s.cfg.EffectiveSkillsSource(), force, skipAudit, walk.Follow))
}
}
// Update regular skills with source metadata
skills, err := getServerUpdatableSkills(s.cfg.EffectiveSkillsSource(), s.skillsStore, walk)
if err == nil {
for _, skill := range skills {
skillPath := filepath.Join(s.cfg.EffectiveSkillsSource(), skill)
results = append(results, s.updateRegularSkill(skill, skillPath, force, skipAudit, walk.Follow))
}
}
return results
}
// handleMissingTrackedRepos returns tracked repos declared in metadata whose
// clone directories are absent on disk (issue #212), so the UI can warn on load.
func (s *Server) handleMissingTrackedRepos(w http.ResponseWriter, r *http.Request) {
s.mu.RLock()
repos := s.missingTrackedRepos()
s.mu.RUnlock()
if repos == nil {
repos = []missingTrackedRepoInfo{}
}
writeJSON(w, map[string]any{"repos": repos})
}
// handleRehydrateTrackedRepos re-clones tracked repos declared in metadata whose
// clone directories are absent on disk (issue #212). Mirrors bare CLI install.
func (s *Server) handleRehydrateTrackedRepos(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
sourceDir := s.cfg.EffectiveSkillsSource()
opts := install.InstallOptions{
AuditThreshold: s.updateAuditThreshold(),
SourceDir: sourceDir,
SourceFollow: s.skillsWalk().Follow,
}
if s.IsProjectMode() {
opts.AuditProjectRoot = s.projectRoot
}
results, err := install.RehydrateMissingTrackedRepos(sourceDir, s.parseOpts(), opts)
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
// Reload metadata + reconcile config so newly cloned repos register.
if st, lerr := install.LoadMetadataWithMigration(sourceDir, ""); lerr == nil && st != nil {
s.skillsStore = st
}
s.reconcileSkillsConfig(sourceDir)
rehydrated, failed := 0, 0
for _, res := range results {
if res.Action == "rehydrated" {
rehydrated++
} else {
failed++
}
}
status, msg := "ok", ""
if failed > 0 {
status = "partial"
msg = fmt.Sprintf("%d repo(s) failed to rehydrate", failed)
}
s.writeOpsLog("install", status, start, map[string]any{
"name": "--rehydrate",
"tracked": true,
"scope": "ui",
"rehydrated": rehydrated,
"failed": failed,
}, msg)
writeJSON(w, map[string]any{"results": results})
}
// getServerUpdatableSkills returns relative paths of skills that have metadata with a remote source.
// It walks the source directory recursively to find nested skills (e.g. utils/ascii-box-check).
func getServerUpdatableSkills(sourceDir string, store *install.MetadataStore, walk sourcewalk.Options) ([]string, error) {
var skills []string
walkRoot := utils.ResolveSymlink(sourceDir)
err := sourcewalk.WalkDir(walkRoot, walk, func(path string, d os.DirEntry, err error) error {
if err != nil {
return nil
}
if path == walkRoot {
return nil
}
if !d.IsDir() {
return nil
}
name := d.Name()
// Skip hidden directories and .git
if name == ".git" || (len(name) > 0 && name[0] == '.') {
return filepath.SkipDir
}
// Skip tracked repos (_ prefix with .git inside)
if len(name) > 0 && name[0] == '_' {
return filepath.SkipDir
}
// Check if this directory has updatable metadata
relName := filepath.Base(path)
if relP, relErr2 := filepath.Rel(walkRoot, path); relErr2 == nil {
relName = filepath.ToSlash(relP)
}
entry := store.GetByPath(relName)
if entry == nil || entry.Source == "" {
return nil // continue walking into subdirectories
}
relPath, relErr := filepath.Rel(walkRoot, path)
if relErr == nil {
skills = append(skills, filepath.ToSlash(relPath))
}
return filepath.SkipDir // don't recurse into skill directories
})
if err != nil {
return nil, err
}
return skills, nil
}
// trackProjectLock returns a function for defer: it moves the lockfile pins of
// the skills the request changed. Global mode has no lockfile.
func (s *Server) trackProjectLock() func() {
if !s.IsProjectMode() {
return func() {}
}
done := config.TrackProjectLock(s.projectRoot, s.projectCfg, s.cfg.EffectiveSkillsSource())
return func() {
if err := done(); err != nil {
log.Printf("warning: failed to update %s: %v", install.LockFileName, err)
}
}
}