Files
skillshare/internal/server/handler_install.go
Willie cfe235a84d fix(install): report reinstalls from the same repo as skipped (#887)
* fix(install): report reinstalls from the same repo as skipped

checkExistingConflict read only the legacy .skillshare-meta.json
sidecar, which installs no longer write, so reinstalling a skill from
the same repo was reported as "already exists" and counted as failed,
contrary to the documented skip. It now reads the skill's record in
.metadata.json, falling back to the sidecar, and skips only the same
skill of that repo: another skill installed under the same name stays
a conflict instead of being reported as installed.

The dashboard logged an existing agent as installed and a same-repo
skill as failed. Batch installs now return those as skipped and log
them as skipped_skills, passing --into so a reinstall into a group
folder finds its record; the install dialog warns that they are
already installed. A same-repo tracked reinstall returns 409 and is
logged as skipped instead of a 500 logged as failed.

ss search installs, batch and single, log the names they skip, and
the Herdr panel reports skipped names like failed ones. The install
docs and their translations say that only the same skill is skipped.

* fix(install): install requested agents when the only skill is skipped

Reinstalling a single-skill repo with `-s alpha -a helper` returned as
soon as the skill was skipped as already installed, so the requested
agent was never installed while the command reported success. Both
single-skill branches now continue to the agent phase, as the
multi-skill path already does.
2026-11-14 00:03:17 +08:00

668 lines
20 KiB
Go

package server
import (
"errors"
"fmt"
"log"
"net/http"
"path/filepath"
"strconv"
"time"
"skillshare/internal/config"
"skillshare/internal/install"
"skillshare/internal/skillmove"
"skillshare/internal/sourcefs"
)
// reloadSkillsStore refreshes the in-memory skills metadata store from disk.
// install.Install writes metadata to the file via its own store instance, so the
// server's cached s.skillsStore stays stale after an install — a freshly
// installed skill would then render with an empty source/type (shown as "Local"
// with a blank source in the UI) until the server restarts.
func (s *Server) reloadSkillsStore() error {
st, err := install.LoadMetadataWithMigration(s.cfg.EffectiveSkillsSource(), "")
if err != nil {
return err
}
s.skillsStore = st
return nil
}
// reconcileSkillsConfig syncs the skills config with the metadata store,
// logging failures as warnings so the calling operation still succeeds.
func (s *Server) reconcileSkillsConfig(sourceDir string) {
if err := s.reconcileSkills(sourceDir, true); err != nil {
log.Printf("warning: failed to reconcile skills config: %v", err)
}
}
// skillsStoreOnDisk reads the store an install is about to change. The cached
// one may lag a CLI command run while the dashboard is open.
func (s *Server) skillsStoreOnDisk() *install.MetadataStore {
if st, err := install.LoadMetadataWithMigration(s.cfg.EffectiveSkillsSource(), ""); err == nil && st != nil {
return st
}
return s.skillsStore
}
// reconcileInstalledSkills is reconcileSkillsConfig after an install. before
// is the store as it was before the install, so a project config entry follows
// a skill installed from another source (config.ReconcileProjectInstall).
func (s *Server) reconcileInstalledSkills(before *install.MetadataStore, sourceDir string) {
if !s.IsProjectMode() {
s.reconcileSkillsConfig(sourceDir)
return
}
if err := config.ReconcileProjectInstall(s.projectRoot, s.projectCfg, before, s.skillsStore, sourceDir); err != nil {
log.Printf("warning: failed to reconcile skills config: %v", err)
}
}
// reconcileSkills is reconcileSkillsConfig for a caller that reports the error.
// Without prune it only adopts moved records.
func (s *Server) reconcileSkills(sourceDir string, prune bool) error {
if s.IsProjectMode() {
if prune {
return config.ReconcileProjectSkills(s.projectRoot, s.projectCfg, s.skillsStore, sourceDir)
}
return config.AdoptMovedProjectSkills(s.projectRoot, s.projectCfg, s.skillsStore, sourceDir)
}
if prune {
return config.ReconcileGlobalSkills(s.cfg, s.skillsStore)
}
return config.AdoptMovedGlobalSkills(s.cfg, s.skillsStore)
}
// adoptMovedSkills is the sync step. It reads the store from disk first: the
// cached one may be the empty stand-in New uses when the file does not load,
// and saving that would drop every record.
func (s *Server) adoptMovedSkills() error {
if err := s.reloadSkillsStore(); err != nil {
return err
}
return s.reconcileSkills(s.cfg.EffectiveSkillsSource(), false)
}
// checkInstallInto refuses an into folder an install must not land in: inside
// a skill or inside a tracked checkout, with the codes move uses. A path below
// a source link is left to the install, which follows it or refuses it itself. It writes the response and returns false when it refuses.
// Agents install under the agents source, which these rules do not describe.
func (s *Server) checkInstallInto(w http.ResponseWriter, into, kind string) bool {
if into == "" || kind == "agent" {
return true
}
opts := skillmove.Options{SourceDir: s.cfg.EffectiveSkillsSource(), Follow: s.skillsWalk().Follow, Install: true}
_, refusal := skillmove.CheckDest(into, opts)
if refusal == nil {
return true
}
status := http.StatusConflict
if refusal.Code == skillmove.CodeInvalidDest {
status = http.StatusBadRequest
}
writeCodedError(w, status, string(refusal.Code), refusal.Error(), nil)
return false
}
func discoverInstallSource(source *install.Source) (*install.DiscoveryResult, error) {
if source.IsGit() {
if source.HasSubdir() {
return install.DiscoverFromGitSubdir(source)
}
return install.DiscoverFromGit(source)
}
return install.DiscoverLocal(source)
}
// handleDiscover clones a git repo to a temp dir, discovers skills, then cleans up.
// Returns whether the caller needs to present a selection UI.
func (s *Server) handleDiscover(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
parseOpts := s.parseOpts()
s.mu.RUnlock()
var body struct {
Source string `json:"source"`
Branch string `json:"branch"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if body.Source == "" {
writeError(w, http.StatusBadRequest, "source is required")
return
}
source, err := install.ParseSourceWithOptions(body.Source, parseOpts)
if err != nil {
writeError(w, http.StatusBadRequest, "invalid source: "+err.Error())
return
}
if body.Branch != "" {
source.Branch = body.Branch
}
discovery, err := discoverInstallSource(source)
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
defer install.CleanupDiscovery(discovery)
skills := make([]map[string]string, len(discovery.Skills))
for i, sk := range discovery.Skills {
skills[i] = map[string]string{"name": sk.Name, "path": sk.Path, "description": sk.Description, "kind": "skill"}
}
agents := make([]map[string]string, len(discovery.Agents))
for i, ag := range discovery.Agents {
agents[i] = map[string]string{"name": ag.Name, "path": ag.Path, "fileName": ag.FileName, "kind": "agent"}
}
writeJSON(w, map[string]any{
"needsSelection": len(discovery.Skills) > 1 || len(discovery.Agents) > 0,
"skills": skills,
"agents": agents,
"warnings": discovery.Warnings,
})
}
// handleInstallBatch re-clones a repo and installs each selected skill.
func (s *Server) handleInstallBatch(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
defer s.trackProjectLock()()
before := s.skillsStoreOnDisk()
var body struct {
Source string `json:"source"`
Branch string `json:"branch"`
Skills []struct {
Name string `json:"name"`
Path string `json:"path"`
} `json:"skills"`
Force bool `json:"force"`
SkipAudit bool `json:"skipAudit"`
Into string `json:"into"`
Name string `json:"name"`
Kind string `json:"kind,omitempty"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if body.Source == "" || len(body.Skills) == 0 {
writeError(w, http.StatusBadRequest, "source and skills are required")
return
}
if !s.checkInstallInto(w, body.Into, body.Kind) {
return
}
source, err := install.ParseSourceWithOptions(body.Source, s.parseOpts())
if err != nil {
writeError(w, http.StatusBadRequest, "invalid source: "+err.Error())
return
}
if body.Branch != "" {
source.Branch = body.Branch
}
if s.IsProjectMode() {
if err := install.RejectProjectRootLocalInstall(source, s.projectRoot); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
} else if source.Type == install.SourceTypeLocalPath {
// Global metadata has no fixed base for a relative path.
source.Raw = source.Path
}
discovery, err := discoverInstallSource(source)
if err != nil {
writeError(w, http.StatusInternalServerError, "discovery failed: "+err.Error())
return
}
defer install.CleanupDiscovery(discovery)
type batchResultItem struct {
Name string `json:"name"`
Action string `json:"action,omitempty"`
Warnings []string `json:"warnings,omitempty"`
Error string `json:"error,omitempty"`
}
// Ensure Into directory exists
if body.Into != "" {
baseDir, follow := s.cfg.EffectiveSkillsSource(), s.skillsWalk().Follow
if body.Kind == "agent" {
baseDir, follow = s.agentsSource(), nil
}
if err := sourcefs.MkdirAllIn(baseDir, body.Into, follow); err != nil {
writeError(w, http.StatusInternalServerError, "failed to create into directory: "+err.Error())
return
}
}
// Note: no cross-path duplicate check for batch — user explicitly selected
// specific skills from discovery, so installing to a different path is intentional.
results := make([]batchResultItem, 0, len(body.Skills))
installOpts := install.InstallOptions{
Force: body.Force,
AuditOverride: body.Force,
SkipAudit: body.SkipAudit,
AuditThreshold: s.auditThreshold(),
Into: body.Into,
Branch: body.Branch,
SourceDir: s.cfg.EffectiveSkillsSource(),
SourceFollow: s.skillsWalk().Follow,
}
if s.IsProjectMode() {
installOpts.AuditProjectRoot = s.projectRoot
}
isAgent := body.Kind == "agent"
if isAgent {
installOpts.SourceDir, installOpts.SourceFollow = s.agentsSource(), nil
}
for _, sel := range body.Skills {
skillName := sel.Name
if body.Name != "" && len(body.Skills) == 1 {
skillName = body.Name
}
if isAgent {
// Agent install: copy single .md file to agents source
agentsDir := s.agentsSource()
if body.Into != "" {
agentsDir = filepath.Join(agentsDir, body.Into)
}
agentInfo := install.AgentInfo{
Name: sel.Name,
Path: sel.Path,
FileName: filepath.Base(sel.Path),
}
res, err := install.InstallAgentFromDiscovery(discovery, agentInfo, agentsDir, installOpts)
if err != nil {
results = append(results, batchResultItem{
Name: skillName,
Error: err.Error(),
})
continue
}
results = append(results, batchResultItem{
Name: skillName,
Action: res.Action,
Warnings: res.Warnings,
})
} else {
// Skill install: copy directory to skills source
destPath := filepath.Join(s.cfg.EffectiveSkillsSource(), body.Into, skillName)
res, err := install.InstallFromDiscovery(discovery, install.SkillInfo{
Name: sel.Name,
Path: sel.Path,
}, destPath, installOpts)
if errors.Is(err, install.ErrSkipSameRepo) {
// Already installed from this repo: kept, as an existing agent is.
results = append(results, batchResultItem{Name: skillName, Action: "skipped"})
continue
}
if err != nil {
results = append(results, batchResultItem{
Name: skillName,
Error: err.Error(),
})
continue
}
results = append(results, batchResultItem{
Name: skillName,
Action: res.Action,
Warnings: res.Warnings,
})
}
}
// Summary for toast
installed := 0
installedSkills := make([]string, 0, len(results))
skippedSkills := make([]string, 0, len(results))
failedSkills := make([]string, 0, len(results))
var firstErr string
for _, r := range results {
switch {
case r.Error != "":
if firstErr == "" {
firstErr = r.Error
}
failedSkills = append(failedSkills, r.Name)
case r.Action == "skipped":
skippedSkills = append(skippedSkills, r.Name)
default:
installed++
installedSkills = append(installedSkills, r.Name)
}
}
kindLabel := "skills"
if isAgent {
kindLabel = "agents"
}
summary := fmt.Sprintf("Installed %d of %d %s", installed, len(body.Skills), kindLabel)
if firstErr != "" {
summary += " (some errors)"
}
if isAgent && installed > 0 && !s.cfg.HasAgentTarget() {
summary += ". Warning: none of your configured targets support agents"
}
status := "ok"
if installed+len(skippedSkills) < len(body.Skills) {
status = "partial"
}
args := map[string]any{
"source": body.Source,
"mode": s.installLogMode(),
"force": body.Force,
"scope": "ui",
"threshold": s.auditThreshold(),
"skill_count": installed,
}
if body.SkipAudit {
args["skip_audit"] = true
}
if body.Into != "" {
args["into"] = body.Into
}
if len(installedSkills) > 0 {
args["installed_skills"] = installedSkills
}
if len(failedSkills) > 0 {
args["failed_skills"] = failedSkills
}
if len(skippedSkills) > 0 {
args["skipped_skills"] = skippedSkills
}
s.writeOpsLog("install", status, start, args, firstErr)
// Reconcile config after install
if installed > 0 {
if isAgent {
if st, loadErr := install.LoadMetadataWithMigration(s.agentsSource(), install.MetadataKindAgent); loadErr == nil && st != nil {
s.agentsStore = st
}
} else {
s.reloadSkillsStore()
}
s.reconcileInstalledSkills(before, s.cfg.EffectiveSkillsSource())
}
writeJSON(w, map[string]any{
"results": results,
"summary": summary,
})
}
func (s *Server) handleInstall(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
defer s.trackProjectLock()()
before := s.skillsStoreOnDisk()
var body struct {
Source string `json:"source"`
Branch string `json:"branch"`
Name string `json:"name"`
Force bool `json:"force"`
SkipAudit bool `json:"skipAudit"`
Track bool `json:"track"`
Into string `json:"into"`
Kind string `json:"kind,omitempty"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON body")
}
return
}
if body.Source == "" {
writeError(w, http.StatusBadRequest, "source is required")
return
}
// A tracked repo's kind is known only after inspecting it; see below.
if !body.Track && !s.checkInstallInto(w, body.Into, body.Kind) {
return
}
source, err := install.ParseSourceWithOptions(body.Source, s.parseOpts())
if err != nil {
writeError(w, http.StatusBadRequest, "invalid source: "+err.Error())
return
}
if body.Branch != "" {
source.Branch = body.Branch
}
if s.IsProjectMode() {
if err := install.RejectProjectRootLocalInstall(source, s.projectRoot); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
} else if source.Type == install.SourceTypeLocalPath {
// Global metadata has no fixed base for a relative path.
source.Raw = source.Path
}
if body.Name != "" {
source.Name = body.Name
}
// Tracked repo install
if body.Track {
trackedKind, err := install.InferTrackedKind(source, body.Kind)
if err != nil {
var ambig *install.TrackKindAmbiguousError
if errors.As(err, &ambig) {
writeCodedError(w, http.StatusBadRequest,
"install.track_kind_ambiguous", err.Error(),
map[string]string{
"skills": strconv.Itoa(ambig.Skills),
"agents": strconv.Itoa(ambig.Agents),
})
return
}
writeError(w, http.StatusBadRequest, err.Error())
return
}
if !s.checkInstallInto(w, body.Into, trackedKind) {
return
}
trackSourceDir, trackFollow := s.cfg.EffectiveSkillsSource(), s.skillsWalk().Follow
if trackedKind == "agent" {
trackSourceDir, trackFollow = s.agentsSource(), nil
}
installOpts := install.InstallOptions{
Name: body.Name,
Kind: trackedKind,
Force: body.Force,
AuditOverride: body.Force,
SkipAudit: body.SkipAudit,
Into: body.Into,
Branch: body.Branch,
AuditThreshold: s.auditThreshold(),
SourceDir: trackSourceDir,
SourceFollow: trackFollow,
}
if s.IsProjectMode() {
installOpts.AuditProjectRoot = s.projectRoot
}
result, err := install.InstallTrackedRepo(source, trackSourceDir, install.InstallOptions{
Name: installOpts.Name,
Kind: installOpts.Kind,
Force: installOpts.Force,
AuditOverride: installOpts.AuditOverride,
SkipAudit: installOpts.SkipAudit,
Into: installOpts.Into,
Branch: installOpts.Branch,
AuditThreshold: installOpts.AuditThreshold,
AuditProjectRoot: installOpts.AuditProjectRoot,
SourceFollow: installOpts.SourceFollow,
})
if errors.Is(err, install.ErrSkipSameRepo) && result != nil {
// Already tracked from this repo: kept, not failed. Nothing was
// installed, so the request is still refused.
s.writeOpsLog("install", "ok", start, map[string]any{
"source": body.Source,
"mode": s.installLogMode(),
"tracked": true,
"force": body.Force,
"threshold": s.auditThreshold(),
"scope": "ui",
"skipped_skills": []string{result.RepoName},
}, "")
writeError(w, http.StatusConflict, err.Error())
return
}
if err != nil {
s.writeOpsLog("install", "error", start, map[string]any{
"source": body.Source,
"mode": s.installLogMode(),
"tracked": true,
"force": body.Force,
"threshold": s.auditThreshold(),
"scope": "ui",
"failed_skills": []string{source.Name},
}, err.Error())
writeError(w, http.StatusInternalServerError, err.Error())
return
}
// Reconcile config after tracked repo install
if trackedKind == "skill" {
s.reloadSkillsStore()
s.reconcileInstalledSkills(before, s.cfg.EffectiveSkillsSource())
}
args := map[string]any{
"source": body.Source,
"mode": s.installLogMode(),
"tracked": true,
"kind": trackedKind,
"force": body.Force,
"threshold": s.auditThreshold(),
"scope": "ui",
"skill_count": result.SkillCount,
}
if body.SkipAudit {
args["skip_audit"] = true
}
if body.Into != "" {
args["into"] = body.Into
}
if len(result.Skills) > 0 {
args["installed_skills"] = result.Skills
}
s.writeOpsLog("install", "ok", start, args, "")
writeJSON(w, map[string]any{
"repoName": result.RepoName,
"skillCount": result.SkillCount,
"agentCount": result.AgentCount,
"skills": result.Skills,
"agents": result.Agents,
"action": result.Action,
"warnings": result.Warnings,
})
return
}
// Cross-path duplicate detection
if !body.Force && source.CloneURL != "" {
if err := install.CheckCrossPathDuplicate(s.cfg.EffectiveSkillsSource(), source.CloneURL, body.Into); err != nil {
writeError(w, http.StatusConflict, err.Error())
return
}
}
// Regular install
destPath := filepath.Join(s.cfg.EffectiveSkillsSource(), body.Into, source.Name)
if body.Into != "" {
if err := sourcefs.MkdirAllIn(s.cfg.EffectiveSkillsSource(), body.Into, s.skillsWalk().Follow); err != nil {
writeError(w, http.StatusInternalServerError, "failed to create into directory: "+err.Error())
return
}
}
result, err := install.Install(source, destPath, install.InstallOptions{
SourceFollow: s.skillsWalk().Follow,
Name: body.Name,
Force: body.Force,
AuditOverride: body.Force,
SkipAudit: body.SkipAudit,
Branch: body.Branch,
AuditThreshold: s.auditThreshold(),
AuditProjectRoot: func() string {
if s.IsProjectMode() {
return s.projectRoot
}
return ""
}(),
})
if err != nil {
s.writeOpsLog("install", "error", start, map[string]any{
"source": body.Source,
"mode": s.installLogMode(),
"force": body.Force,
"threshold": s.auditThreshold(),
"scope": "ui",
"failed_skills": []string{source.Name},
}, err.Error())
writeError(w, http.StatusInternalServerError, err.Error())
return
}
// Reconcile config after single install
s.reloadSkillsStore()
s.reconcileInstalledSkills(before, s.cfg.EffectiveSkillsSource())
okArgs := map[string]any{
"source": body.Source,
"mode": s.installLogMode(),
"force": body.Force,
"threshold": s.auditThreshold(),
"scope": "ui",
"skill_count": 1,
"installed_skills": []string{result.SkillName},
}
if body.SkipAudit {
okArgs["skip_audit"] = true
}
if body.Into != "" {
okArgs["into"] = body.Into
}
s.writeOpsLog("install", "ok", start, okArgs, "")
writeJSON(w, map[string]any{
"skillName": result.SkillName,
"action": result.Action,
"warnings": result.Warnings,
})
}
func (s *Server) installLogMode() string {
if s.IsProjectMode() {
return "project"
}
return "global"
}