Files
skillshare/internal/server/handler_update.go
T
Willie 89fc4fbdf1 feat(sourcewalk): follow first-level source links when enabled
Users link a checkout directly under the skills source (e.g.
skills/_dev-skills -> ~/code/dev-skills) and expect it to behave like any
other first-level entry. sourcewalk resolved only the root, so these links
were invisible to discovery, sync, update, and the dashboard.

follow_source_links (global and project config, default false) enables a
per-operation sourcewalk.Follow policy. Walk, WalkDir, and ReadDir report a
followed link under its own name as a directory and descend into its
target, so names, RelPath, FlatName, SourcePath, tracked-repo detection, and
metadata keys stay logical. Only entries directly under the source root are
followed. The policy is built from config and passed explicitly to every
discovery caller in the CLI, server, and reconcile, so counts agree; the
server keeps a per-instance snapshot refreshed on config load and save
instead of a process-global flag.

A link is skipped, with one warning per operation, when its target is
missing or unreadable, is the source or a parent of it, or overlaps an
active skills target. A missing or unreadable target marks the operation
incomplete: sync then skips pruning and copy-orphan deletion, and reconcile
keeps metadata, so an unmounted drive or a re-clone in progress cannot
erase target entries or install records. A link to an existing file is not
a directory link and stays an ordinary entry; treating it as incomplete
would disable pruning for anyone sharing a file such as .skillignore.

doctor keeps raw link identity: with the key off it still says the link is
not followed and names follow_source_links: true; with it on it reports
followed links and skipped links with the reason.

The raw-walk allowlist gains entries for the policy path in Walk and
WalkDir: the source root walk with a policy, and the walk of a validated
link target whose paths are remapped to the logical link path. Both live
in sourcewalk itself, the package that owns source traversal.

Refs #274
2026-10-05 14:26:09 +08:00

611 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/git"
"skillshare/internal/install"
"skillshare/internal/sourcewalk"
"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())
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)
}
// Try exact skill path first (prevents basename collision with nested repos)
skillPath := filepath.Join(s.cfg.EffectiveSkillsSource(), name)
if entry := s.skillsStore.GetByPath(name); entry != nil && entry.Source != "" {
return s.updateRegularSkill(name, skillPath, force, skipAudit)
}
// Try tracked repo (flat, nested, or basename fallback)
repoName, repoPath, err := s.resolveTrackedRepo(name)
if err != nil {
return updateResultItem{Name: name, Action: "error", Message: err.Error()}
}
if repoPath != "" {
return s.updateTrackedRepo(repoName, repoPath, force, skipAudit)
}
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,
}
}
func (s *Server) updateTrackedRepo(name, repoPath string, force, skipAudit bool) updateResultItem {
// Check for uncommitted changes
if isDirty, _ := git.IsDirty(repoPath); isDirty {
if !force {
return updateResultItem{
Name: name,
Action: "skipped",
Message: "has uncommitted changes (use force to discard)",
IsRepo: true,
}
}
if err := git.Restore(repoPath); err != nil {
return updateResultItem{
Name: name,
Action: "error",
Message: "failed to discard changes: " + err.Error(),
IsRepo: true,
}
}
}
var info *git.UpdateInfo
var err error
if force {
info, err = git.ForcePullWithAuth(repoPath)
} else {
info, err = git.PullWithAuth(repoPath)
}
if err != nil {
msg := err.Error()
if !force {
msg += " (try force update)"
}
return updateResultItem{
Name: name,
Action: "error",
Message: msg,
IsRepo: true,
}
}
if info.UpToDate {
return updateResultItem{Name: name, Action: "up-to-date", IsRepo: true}
}
// Post-pull audit gate
item := updateResultItem{
Name: name,
Action: "updated",
Message: fmt.Sprintf("%d commits, %d files changed", len(info.Commits), info.Stats.FilesChanged),
IsRepo: true,
}
if !skipAudit {
blocked, auditResult := s.auditGateTrackedRepo(name, repoPath, info.BeforeHash, force, s.updateAuditThreshold())
if blocked != nil {
return *blocked
}
if auditResult != nil {
item.AuditRiskScore = auditResult.RiskScore
item.AuditRiskLabel = auditResult.RiskLabel
}
}
return item
}
// auditGateTrackedRepo scans a tracked repo after pull and rolls back if findings are detected
// at or above the active threshold.
// Returns (blocked item, audit result). blocked is non-nil when the update should be rejected.
func (s *Server) auditGateTrackedRepo(name, repoPath, beforeHash string, force bool, threshold string) (*updateResultItem, *audit.Result) {
var result *audit.Result
var err error
if s.IsProjectMode() {
result, err = audit.ScanSkillForProject(repoPath, s.projectRoot)
} else {
result, err = audit.ScanSkill(repoPath)
}
if err != nil {
msg := "security audit failed: " + err.Error()
if beforeHash == "" {
msg += " (rollback commit unavailable, repository state is unknown)"
} else if resetErr := git.ResetHard(repoPath, beforeHash); resetErr != nil {
msg += " (WARNING: rollback also failed: " + resetErr.Error() + " — malicious content may remain)"
} else {
msg += " (rolled back)"
}
return &updateResultItem{
Name: name,
Action: "blocked",
Message: msg,
IsRepo: true,
}, nil
}
if result.HasSeverityAtOrAbove(threshold) && !force {
msg := fmt.Sprintf("blocked by security audit — findings at/above %s detected", threshold)
if beforeHash == "" {
msg += " (rollback commit unavailable, repository state is unknown)"
} else if resetErr := git.ResetHard(repoPath, beforeHash); resetErr != nil {
msg += " (WARNING: rollback failed: " + resetErr.Error() + " — malicious content may remain)"
} else {
msg += ", rolled back"
}
return &updateResultItem{
Name: name,
Action: "blocked",
Message: msg,
IsRepo: true,
}, result
}
return nil, result
}
func (s *Server) updateRegularSkill(name, skillPath string, force, skipAudit bool) updateResultItem {
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 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, force, skipAudit))
}
}
// 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))
}
}
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,
}
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)
}
}
}