Files
skillshare/internal/server/handler_update.go
T
Willie b8a189ba58 Improve resource install agent support
Add local-path resource discovery so install flows can detect agents as well as skills. Preserve nested agent paths and suffixless agent metadata keys during batch install and update, and refresh the UI copy to use resource-aware wording on the install surface.
2026-04-10 01:26:40 +08:00

480 lines
13 KiB
Go

package server
import (
"encoding/json"
"fmt"
"net/http"
"os"
"path/filepath"
"strings"
"time"
"skillshare/internal/audit"
"skillshare/internal/git"
"skillshare/internal/install"
"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"`
}
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()
var body updateRequest
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
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})
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
}
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.Source, name)
if entry := s.skillsStore.GetByPath(name); entry != nil && entry.Source != "" {
return s.updateRegularSkill(name, skillPath, 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, _ bool, _ 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()}
}
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.ParseSource(entry.Source)
if err != nil {
return updateResultItem{Name: metaKey, Kind: "agent", Action: "error", Message: "invalid source: " + err.Error()}
}
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
res, err := install.InstallAgentFromDiscovery(discovery, *target, destDir, install.InstallOptions{
Kind: "agent",
Force: true,
SourceDir: agentsSource,
})
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, 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, 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) {
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, 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(),
}
}
opts := install.InstallOptions{
Force: true,
Update: true,
SkipAudit: skipAudit,
AuditThreshold: s.updateAuditThreshold(),
}
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(),
}
}
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
repos, err := install.GetTrackedRepos(s.cfg.Source)
if err == nil {
for _, repo := range repos {
repoPath := filepath.Join(s.cfg.Source, repo)
results = append(results, s.updateTrackedRepo(repo, repoPath, force, skipAudit))
}
}
// Update regular skills with source metadata
skills, err := getServerUpdatableSkills(s.cfg.Source, s.skillsStore)
if err == nil {
for _, skill := range skills {
skillPath := filepath.Join(s.cfg.Source, skill)
results = append(results, s.updateRegularSkill(skill, skillPath, skipAudit))
}
}
return 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) ([]string, error) {
var skills []string
walkRoot := utils.ResolveSymlink(sourceDir)
err := filepath.WalkDir(walkRoot, 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
}