mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
Pi forks such as omo keep Pi's directory layout and commands but ship their own executable, so an account target pointed at one still ran `pi` for plugin commands. A shell alias cannot help, since Skillshare runs the CLI without a shell. An account target can now set `cli` (or `target add --cli`) to a name on PATH or an absolute path. Pi accounts also export SENPI_CODING_AGENT_DIR and OMO_CODING_AGENT_DIR, which omo reads before PI_CODING_AGENT_DIR. A missing CLI fails instead of falling back, and a missing working directory is no longer reported as a missing CLI. Refs #307
746 lines
23 KiB
Go
746 lines
23 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/mcp"
|
|
ssync "skillshare/internal/sync"
|
|
"skillshare/internal/targetsummary"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
type targetItem struct {
|
|
Name string `json:"name"`
|
|
Project string `json:"project,omitempty"` // root of the project this target belongs to
|
|
Agent string `json:"agent,omitempty"` // the built-in Agent this is another config directory of
|
|
ConfigDir string `json:"configDir,omitempty"`
|
|
CLI string `json:"cli,omitempty"` // the executable that runs its plugin commands, when not the Agent's own
|
|
Path string `json:"path"`
|
|
Mode string `json:"mode"`
|
|
TargetNaming string `json:"targetNaming"`
|
|
Status string `json:"status"`
|
|
LinkedCount int `json:"linkedCount"`
|
|
LocalCount int `json:"localCount"`
|
|
Include []string `json:"include"`
|
|
Exclude []string `json:"exclude"`
|
|
ExpectedSkillCount int `json:"expectedSkillCount"`
|
|
SkippedSkillCount int `json:"skippedSkillCount,omitempty"`
|
|
CollisionCount int `json:"collisionCount,omitempty"`
|
|
AgentPath string `json:"agentPath,omitempty"`
|
|
AgentMode string `json:"agentMode,omitempty"`
|
|
AgentExtension string `json:"agentExtension,omitempty"`
|
|
AgentInclude []string `json:"agentInclude,omitempty"`
|
|
AgentExclude []string `json:"agentExclude,omitempty"`
|
|
AgentLinkedCount *int `json:"agentLinkedCount,omitempty"`
|
|
AgentLocalCount *int `json:"agentLocalCount,omitempty"`
|
|
AgentExpectedCount *int `json:"agentExpectedCount,omitempty"`
|
|
SkillsEnabled bool `json:"skillsEnabled"`
|
|
// SkillsReadFrom (skills off) names the enabled targets whose skills folder
|
|
// this tool still reads; SkillsAlsoReadBy (skills on) names the targets with
|
|
// skills off whose tool reads this target's folder.
|
|
SkillsReadFrom []string `json:"skillsReadFrom,omitempty"`
|
|
SkillsAlsoReadBy []string `json:"skillsAlsoReadBy,omitempty"`
|
|
}
|
|
|
|
var removeTargetPath = os.Remove
|
|
|
|
func (s *Server) handleListTargets(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
cfgMode := s.cfg.Mode
|
|
targets := s.cloneTargets()
|
|
isProjectMode := s.IsProjectMode()
|
|
projectRoot := s.projectRoot
|
|
agentsSourcePath := s.agentsSource()
|
|
cfgSnapshot := *s.cfg
|
|
var projectEntries []config.ProjectTargetEntry
|
|
if isProjectMode && s.projectCfg != nil {
|
|
projectEntries = append([]config.ProjectTargetEntry(nil), s.projectCfg.Targets...)
|
|
}
|
|
s.mu.RUnlock()
|
|
|
|
globalMode := cfgMode
|
|
if globalMode == "" {
|
|
globalMode = "merge"
|
|
}
|
|
|
|
projectEntryByName := make(map[string]config.ProjectTargetEntry, len(projectEntries))
|
|
for _, entry := range projectEntries {
|
|
projectEntryByName[entry.Name] = entry
|
|
}
|
|
|
|
var (
|
|
agentBuilder *targetsummary.Builder
|
|
err error
|
|
)
|
|
if isProjectMode {
|
|
agentBuilder, err = targetsummary.NewProjectBuilder(agentsSourcePath, projectRoot)
|
|
} else {
|
|
agentBuilder, err = targetsummary.NewGlobalBuilder(&cfgSnapshot)
|
|
}
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to discover agents: "+err.Error())
|
|
return
|
|
}
|
|
|
|
items := make([]targetItem, 0, len(targets))
|
|
discovered, discoveredErr := ssync.DiscoverSourceSkills(source)
|
|
|
|
// Project targets are edited under projects, so they are listed only on request:
|
|
// scope=projects for them alone, scope=all for what a sync writes.
|
|
scope := r.URL.Query().Get("scope")
|
|
for name, target := range targets {
|
|
if scope != "all" && (target.ProjectRoot() != "") != (scope == "projects") {
|
|
continue
|
|
}
|
|
sc := target.SkillsConfig()
|
|
mode := sc.Mode
|
|
if mode == "" {
|
|
mode = globalMode
|
|
}
|
|
|
|
item := targetItem{
|
|
Name: name,
|
|
Project: target.ProjectRoot(),
|
|
Agent: target.Agent,
|
|
ConfigDir: target.ConfigDir,
|
|
CLI: target.CLI,
|
|
Path: sc.Path,
|
|
Mode: mode,
|
|
TargetNaming: config.EffectiveTargetNaming(sc.TargetNaming),
|
|
Include: func() []string {
|
|
if len(sc.Include) == 0 {
|
|
return []string{}
|
|
}
|
|
return append([]string(nil), sc.Include...)
|
|
}(),
|
|
Exclude: func() []string {
|
|
if len(sc.Exclude) == 0 {
|
|
return []string{}
|
|
}
|
|
return append([]string(nil), sc.Exclude...)
|
|
}(),
|
|
SkillsEnabled: sc.IsEnabled(),
|
|
}
|
|
|
|
switch {
|
|
case !sc.IsEnabled():
|
|
item.Status = "skills off"
|
|
item.SkillsReadFrom = config.SkillsReadFrom(targets, name, projectRoot)
|
|
case mode == "merge" || mode == "copy":
|
|
if discoveredErr == nil {
|
|
filtered, err := ssync.FilterSkills(discovered, sc.Include, sc.Exclude)
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid include/exclude for target "+name+": "+err.Error())
|
|
return
|
|
}
|
|
filtered = ssync.FilterSkillsByTarget(filtered, name)
|
|
resolution, resErr := ssync.ResolveTargetSkillsForTarget(name, config.ResourceTargetConfig{
|
|
Path: sc.Path,
|
|
TargetNaming: sc.TargetNaming,
|
|
}, filtered)
|
|
if resErr == nil {
|
|
item.ExpectedSkillCount = len(resolution.Skills)
|
|
item.SkippedSkillCount = len(filtered) - len(resolution.Skills)
|
|
item.CollisionCount = len(resolution.Collisions)
|
|
} else {
|
|
item.ExpectedSkillCount = len(filtered)
|
|
}
|
|
}
|
|
if mode == "merge" {
|
|
status, linked, local := ssync.CheckStatusMerge(sc.Path, source)
|
|
item.Status = status.String()
|
|
item.LinkedCount = linked
|
|
item.LocalCount = local
|
|
} else {
|
|
status, managed, local := ssync.CheckStatusCopy(sc.Path)
|
|
item.Status = status.String()
|
|
item.LinkedCount = managed
|
|
item.LocalCount = local
|
|
}
|
|
default:
|
|
status := ssync.CheckStatus(sc.Path, source)
|
|
item.Status = status.String()
|
|
}
|
|
item.SkillsAlsoReadBy = config.SkillsAlsoReadBy(targets, name, projectRoot)
|
|
|
|
var agentSummary *targetsummary.AgentSummary
|
|
if isProjectMode {
|
|
if entry, ok := projectEntryByName[name]; ok {
|
|
agentSummary, err = agentBuilder.ProjectTarget(entry)
|
|
}
|
|
} else {
|
|
agentSummary, err = agentBuilder.GlobalTarget(name, target)
|
|
}
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid agent include/exclude for target "+name+": "+err.Error())
|
|
return
|
|
}
|
|
if agentSummary != nil {
|
|
item.AgentPath = agentSummary.Path
|
|
item.AgentMode = agentSummary.Mode
|
|
item.AgentExtension = agentSummary.Extension
|
|
item.AgentInclude = agentSummary.Include
|
|
item.AgentExclude = agentSummary.Exclude
|
|
item.AgentLinkedCount = intPtr(agentSummary.ManagedCount)
|
|
item.AgentLocalCount = intPtr(agentSummary.LocalCount)
|
|
item.AgentExpectedCount = intPtr(agentSummary.ExpectedCount)
|
|
}
|
|
|
|
items = append(items, item)
|
|
}
|
|
|
|
// Count source skills for drift detection
|
|
sourceSkillCount := 0
|
|
if discoveredErr == nil {
|
|
sourceSkillCount = len(discovered)
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"targets": items, "sourceSkillCount": sourceSkillCount})
|
|
}
|
|
|
|
func intPtr(v int) *int {
|
|
return &v
|
|
}
|
|
|
|
func (s *Server) handleAddTarget(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
var body struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
AgentPath string `json:"agentPath"`
|
|
// Agent and ConfigDir add another config directory of a built-in Agent instead.
|
|
Agent string `json:"agent"`
|
|
ConfigDir string `json:"configDir"`
|
|
CLI string `json:"cli"`
|
|
// Instructions optionally names the instruction file of a custom target.
|
|
Instructions *config.TargetInstructionsConfig `json:"instructions"`
|
|
// SkillsEnabled false adds the target with skills off (default true).
|
|
SkillsEnabled *bool `json:"skills_enabled"`
|
|
}
|
|
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
}
|
|
return
|
|
}
|
|
|
|
if body.Name == "" {
|
|
writeError(w, http.StatusBadRequest, "name is required")
|
|
return
|
|
}
|
|
|
|
if body.Agent != "" || body.ConfigDir != "" {
|
|
if s.IsProjectMode() {
|
|
writeError(w, http.StatusBadRequest, "a project has no Agent config directory to add")
|
|
return
|
|
}
|
|
if _, exists := s.cfg.Targets[body.Name]; exists {
|
|
writeError(w, http.StatusConflict, "target already exists: "+body.Name)
|
|
return
|
|
}
|
|
path, err := s.cfg.AddAgentConfigDirTarget(body.Name, body.Agent, body.ConfigDir, body.CLI)
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if body.SkillsEnabled != nil && !*body.SkillsEnabled {
|
|
tc := s.cfg.Targets[body.Name]
|
|
tc.EnsureSkills().SetEnabled(false)
|
|
s.cfg.Targets[body.Name] = tc
|
|
}
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
s.writeOpsLog("target", "ok", start, map[string]any{"action": "add", "name": body.Name, "target": path, "scope": "ui"}, "")
|
|
writeJSON(w, map[string]any{"success": true})
|
|
return
|
|
}
|
|
|
|
// In project mode, path can be resolved from known targets
|
|
if body.Path == "" {
|
|
if s.IsProjectMode() {
|
|
if known, ok := config.LookupProjectTarget(body.Name); ok {
|
|
body.Path = known.Path
|
|
} else {
|
|
writeError(w, http.StatusBadRequest, "unknown target, path is required")
|
|
return
|
|
}
|
|
} else {
|
|
writeError(w, http.StatusBadRequest, "name and path are required")
|
|
return
|
|
}
|
|
}
|
|
|
|
if _, exists := s.cfg.Targets[body.Name]; exists {
|
|
writeError(w, http.StatusConflict, "target already exists: "+body.Name)
|
|
return
|
|
}
|
|
if ic := body.Instructions; ic != nil {
|
|
ic.Path = strings.TrimSpace(ic.Path)
|
|
if err := config.ValidateTargetInstructions(ic, s.IsProjectMode()); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
skillsOff := body.SkillsEnabled != nil && !*body.SkillsEnabled
|
|
tc := config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: body.Path}, Instructions: body.Instructions}
|
|
tc.Skills.SetEnabled(!skillsOff)
|
|
if body.AgentPath != "" {
|
|
tc.Agents = &config.ResourceTargetConfig{Path: body.AgentPath}
|
|
}
|
|
s.cfg.Targets[body.Name] = tc
|
|
|
|
// In project mode, also update the project config
|
|
if s.IsProjectMode() {
|
|
entry := config.ProjectTargetEntry{Name: body.Name, Instructions: body.Instructions}
|
|
if skillsOff {
|
|
entry.EnsureSkills().SetEnabled(false)
|
|
}
|
|
s.projectCfg.Targets = append(s.projectCfg.Targets, entry)
|
|
}
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("target", "ok", start, map[string]any{
|
|
"action": "add",
|
|
"name": body.Name,
|
|
"target": body.Path,
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true})
|
|
}
|
|
|
|
func (s *Server) handleRemoveTarget(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
name := r.PathValue("name")
|
|
|
|
target, exists := s.cfg.Targets[name]
|
|
if !exists {
|
|
writeError(w, http.StatusNotFound, "target not found: "+name)
|
|
return
|
|
}
|
|
|
|
sc := target.SkillsConfig()
|
|
|
|
if target.ProjectRoot() != "" {
|
|
writeError(w, http.StatusBadRequest, name+" belongs to a project; remove the project instead")
|
|
return
|
|
}
|
|
// Another target writing the same folder (codex and universal) still owns its
|
|
// links; a target with skills off no longer manages its folder.
|
|
if sc.IsEnabled() && config.SkillsPathKeptBy(s.cfg.Targets, name, nil) == "" {
|
|
if status, err := s.detachSkillsTarget(sc.Path); err != nil {
|
|
writeError(w, status, err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
// Read the MCP config before it is saved without the target: afterwards its own
|
|
// name no longer resolves, so the config no longer loads.
|
|
var warnings []string
|
|
if target.Agent != "" {
|
|
if warning := mcp.ReferenceWarning(s.configPath(), name); warning != "" {
|
|
warnings = append(warnings, warning)
|
|
}
|
|
}
|
|
|
|
delete(s.cfg.Targets, name)
|
|
|
|
// In project mode, also remove from project config
|
|
if s.IsProjectMode() {
|
|
filtered := make([]config.ProjectTargetEntry, 0, len(s.projectCfg.Targets))
|
|
for _, t := range s.projectCfg.Targets {
|
|
if t.Name != name {
|
|
filtered = append(filtered, t)
|
|
}
|
|
}
|
|
s.projectCfg.Targets = filtered
|
|
}
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("target", "ok", start, map[string]any{
|
|
"action": "remove",
|
|
"name": name,
|
|
"target": sc.Path,
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": name, "warnings": warnings})
|
|
}
|
|
|
|
func (s *Server) handleUpdateTarget(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
name := r.PathValue("name")
|
|
|
|
target, exists := s.cfg.Targets[name]
|
|
if !exists {
|
|
writeError(w, http.StatusNotFound, "target not found: "+name)
|
|
return
|
|
}
|
|
if target.ProjectRoot() != "" {
|
|
writeError(w, http.StatusBadRequest, name+" belongs to a project; edit the project instead")
|
|
return
|
|
}
|
|
// Skills and Agents are pointers shared with s.cfg; edit copies so a
|
|
// request rejected halfway leaves the config untouched.
|
|
if target.Skills != nil {
|
|
sk := *target.Skills
|
|
target.Skills = &sk
|
|
}
|
|
if target.Agents != nil {
|
|
ag := *target.Agents
|
|
target.Agents = &ag
|
|
}
|
|
|
|
var body struct {
|
|
Include *[]string `json:"include"` // null = no change, [] = clear
|
|
Exclude *[]string `json:"exclude"`
|
|
Mode *string `json:"mode"`
|
|
TargetNaming *string `json:"target_naming"`
|
|
AgentMode *string `json:"agent_mode"`
|
|
AgentInclude *[]string `json:"agent_include"`
|
|
AgentExclude *[]string `json:"agent_exclude"`
|
|
AgentExtension *string `json:"agent_extension"` // "" = clear
|
|
SkillsEnabled *bool `json:"skills_enabled"`
|
|
}
|
|
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
}
|
|
return
|
|
}
|
|
|
|
// An extension converts each agent, so it implies copy mode. Reject a
|
|
// conflicting mode sent in this same call, as extras targets do.
|
|
if body.AgentExtension != nil && *body.AgentExtension != "" && body.AgentMode != nil && *body.AgentMode != "copy" {
|
|
writeError(w, http.StatusBadRequest, "agent extension requires copy mode, but agent_mode "+*body.AgentMode+" was set")
|
|
return
|
|
}
|
|
|
|
target.EnsureSkills()
|
|
|
|
// Validate patterns
|
|
if body.Include != nil {
|
|
if _, err := ssync.FilterSkills(nil, *body.Include, nil); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid include pattern: "+err.Error())
|
|
return
|
|
}
|
|
target.Skills.Include = *body.Include
|
|
}
|
|
if body.Exclude != nil {
|
|
if _, err := ssync.FilterSkills(nil, nil, *body.Exclude); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid exclude pattern: "+err.Error())
|
|
return
|
|
}
|
|
target.Skills.Exclude = *body.Exclude
|
|
}
|
|
|
|
if body.Mode != nil {
|
|
switch *body.Mode {
|
|
case "merge", "symlink", "copy":
|
|
target.Skills.Mode = *body.Mode
|
|
default:
|
|
writeError(w, http.StatusBadRequest, "invalid mode: "+*body.Mode+"; must be merge, symlink, or copy")
|
|
return
|
|
}
|
|
}
|
|
|
|
if body.TargetNaming != nil {
|
|
if !config.IsValidTargetNaming(*body.TargetNaming) {
|
|
writeError(w, http.StatusBadRequest, "invalid target_naming: "+*body.TargetNaming+"; must be flat or standard")
|
|
return
|
|
}
|
|
target.Skills.TargetNaming = *body.TargetNaming
|
|
}
|
|
|
|
if body.AgentMode != nil {
|
|
switch *body.AgentMode {
|
|
case "merge", "symlink", "copy":
|
|
target.EnsureAgents().Mode = *body.AgentMode
|
|
default:
|
|
writeError(w, http.StatusBadRequest, "invalid agent_mode: "+*body.AgentMode+"; must be merge, symlink, or copy")
|
|
return
|
|
}
|
|
}
|
|
|
|
if body.AgentExtension != nil {
|
|
if *body.AgentExtension != "" {
|
|
target.EnsureAgents().Mode = "copy"
|
|
}
|
|
target.EnsureAgents().Extension = *body.AgentExtension
|
|
}
|
|
|
|
if body.AgentInclude != nil {
|
|
if _, err := ssync.FilterSkills(nil, *body.AgentInclude, nil); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid agent include pattern: "+err.Error())
|
|
return
|
|
}
|
|
target.EnsureAgents().Include = *body.AgentInclude
|
|
}
|
|
if body.AgentExclude != nil {
|
|
if _, err := ssync.FilterSkills(nil, nil, *body.AgentExclude); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid agent exclude pattern: "+err.Error())
|
|
return
|
|
}
|
|
target.EnsureAgents().Exclude = *body.AgentExclude
|
|
}
|
|
|
|
if body.SkillsEnabled != nil {
|
|
target.Skills.SetEnabled(*body.SkillsEnabled)
|
|
}
|
|
|
|
s.cfg.Targets[name] = target
|
|
|
|
// In project mode, also update the project config
|
|
if s.IsProjectMode() {
|
|
for i := range s.projectCfg.Targets {
|
|
if s.projectCfg.Targets[i].Name == name {
|
|
sk := s.projectCfg.Targets[i].EnsureSkills()
|
|
if body.SkillsEnabled != nil {
|
|
sk.SetEnabled(*body.SkillsEnabled)
|
|
}
|
|
if body.Include != nil {
|
|
sk.Include = *body.Include
|
|
}
|
|
if body.Exclude != nil {
|
|
sk.Exclude = *body.Exclude
|
|
}
|
|
if body.Mode != nil {
|
|
sk.Mode = *body.Mode
|
|
}
|
|
if body.TargetNaming != nil {
|
|
sk.TargetNaming = *body.TargetNaming
|
|
}
|
|
if body.AgentMode != nil {
|
|
s.projectCfg.Targets[i].EnsureAgents().Mode = *body.AgentMode
|
|
}
|
|
if body.AgentInclude != nil {
|
|
s.projectCfg.Targets[i].EnsureAgents().Include = *body.AgentInclude
|
|
}
|
|
if body.AgentExclude != nil {
|
|
s.projectCfg.Targets[i].EnsureAgents().Exclude = *body.AgentExclude
|
|
}
|
|
if body.AgentExtension != nil {
|
|
ag := s.projectCfg.Targets[i].EnsureAgents()
|
|
if *body.AgentExtension != "" {
|
|
ag.Mode = "copy"
|
|
}
|
|
ag.Extension = *body.AgentExtension
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
// Skills off applies at once: the folder keeps only what skillshare did not link.
|
|
var detach *ssync.SkillsOffResult
|
|
if body.SkillsEnabled != nil && !*body.SkillsEnabled {
|
|
res, err := ssync.DetachSkills(s.cfg.Targets, name, s.cfg.EffectiveSkillsSource(), false)
|
|
if err != nil {
|
|
s.writeOpsLog("target", "error", start, map[string]any{"action": "skills", "name": name, "enabled": false, "scope": "ui"}, err.Error())
|
|
writeError(w, http.StatusInternalServerError, "skills off saved, but removing links failed: "+err.Error())
|
|
return
|
|
}
|
|
detach = res
|
|
}
|
|
|
|
hasFilter := body.Include != nil || body.Exclude != nil || body.AgentInclude != nil || body.AgentExclude != nil
|
|
hasSetting := body.Mode != nil || body.TargetNaming != nil || body.AgentMode != nil || body.AgentExtension != nil || body.SkillsEnabled != nil
|
|
action := "filter"
|
|
if hasSetting && hasFilter {
|
|
action = "settings+filter"
|
|
} else if hasSetting {
|
|
action = "settings"
|
|
}
|
|
logArgs := map[string]any{
|
|
"action": action,
|
|
"name": name,
|
|
"scope": "ui",
|
|
}
|
|
if body.SkillsEnabled != nil {
|
|
logArgs["skills_enabled"] = *body.SkillsEnabled
|
|
}
|
|
if detach != nil {
|
|
logArgs["removed"] = len(detach.Removed)
|
|
logArgs["kept"] = len(detach.Kept)
|
|
logArgs["copies"] = len(detach.Copies)
|
|
}
|
|
s.writeOpsLog("target", "ok", start, logArgs, "")
|
|
|
|
resp := map[string]any{"success": true}
|
|
if detach != nil {
|
|
resp["detach"] = map[string]any{"removed": detach.Removed, "kept": detach.Kept, "copies": detach.Copies}
|
|
}
|
|
writeJSON(w, resp)
|
|
}
|
|
|
|
// handleSkillsOffPreview reports what turning skills off for a target would
|
|
// remove and keep, without writing anything.
|
|
func (s *Server) handleSkillsOffPreview(w http.ResponseWriter, r *http.Request) {
|
|
s.mu.RLock()
|
|
targets := s.cloneTargets()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
s.mu.RUnlock()
|
|
|
|
name := r.PathValue("name")
|
|
target, ok := targets[name]
|
|
if !ok {
|
|
writeError(w, http.StatusNotFound, "target not found: "+name)
|
|
return
|
|
}
|
|
if target.ProjectRoot() != "" {
|
|
writeError(w, http.StatusBadRequest, name+" belongs to a project; edit the project instead")
|
|
return
|
|
}
|
|
res, err := ssync.DetachSkills(targets, name, source, true)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
resp := map[string]any{"remove": res.Removed, "keep": res.Kept, "copies": res.Copies}
|
|
if res.SharedWith != "" {
|
|
resp["sharedWith"] = res.SharedWith
|
|
}
|
|
writeJSON(w, resp)
|
|
}
|
|
|
|
// detachSkillsTarget removes what sync owns in a skills folder before its target leaves
|
|
// the config: the folder symlink, or the manifest and the symlinks into the source.
|
|
// Copies and local skills stay.
|
|
func (s *Server) detachSkillsTarget(path string) (int, error) {
|
|
info, err := os.Lstat(path)
|
|
if os.IsNotExist(err) {
|
|
return 0, nil
|
|
}
|
|
if err != nil {
|
|
return http.StatusInternalServerError, fmt.Errorf("failed to inspect target: %w", err)
|
|
}
|
|
if utils.IsLinkMode(path, info.Mode()) {
|
|
// Symlink mode: entire directory is a symlink
|
|
if err := removeTargetPath(path); err != nil {
|
|
return http.StatusInternalServerError, fmt.Errorf("failed to remove target symlink: %w", err)
|
|
}
|
|
} else if info.IsDir() {
|
|
// Remove manifest if present (merge/copy mode)
|
|
if err := ssync.RemoveManifest(path); err != nil {
|
|
return http.StatusInternalServerError, fmt.Errorf("failed to remove target manifest: %w", err)
|
|
}
|
|
// Merge mode: remove individual skill symlinks pointing to source
|
|
if err := s.unlinkMergeSymlinks(path); err != nil {
|
|
return http.StatusInternalServerError, fmt.Errorf("failed to clean target symlinks: %w", err)
|
|
}
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
// unlinkMergeSymlinks removes symlinks in targetPath that point under the
|
|
// source directory and copies the skill contents back as real files.
|
|
func (s *Server) unlinkMergeSymlinks(targetPath string) error {
|
|
entries, err := os.ReadDir(targetPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
absSource, err := filepath.Abs(s.cfg.EffectiveSkillsSource())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
absSourcePrefix := absSource + string(filepath.Separator)
|
|
|
|
for _, entry := range entries {
|
|
skillPath := filepath.Join(targetPath, entry.Name())
|
|
|
|
if !utils.IsSymlinkOrJunction(skillPath) {
|
|
continue
|
|
}
|
|
|
|
absLink, err := utils.ResolveLinkTarget(skillPath)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if !utils.PathHasPrefix(absLink, absSourcePrefix) {
|
|
continue
|
|
}
|
|
|
|
// Remove symlink and copy the skill back if source still exists
|
|
if err := removeTargetPath(skillPath); err != nil {
|
|
return fmt.Errorf("remove %s: %w", skillPath, err)
|
|
}
|
|
if _, statErr := os.Stat(absLink); statErr == nil {
|
|
if err := copySkillDir(absLink, skillPath); err != nil {
|
|
return fmt.Errorf("restore %s from %s: %w", skillPath, absLink, err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// copySkillDir copies a directory tree from src to dst.
|
|
func copySkillDir(src, dst string) error {
|
|
return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
relPath, err := filepath.Rel(src, path)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to compute relative path from %s to %s: %w", src, path, err)
|
|
}
|
|
dstPath := filepath.Join(dst, relPath)
|
|
|
|
if info.IsDir() {
|
|
return os.MkdirAll(dstPath, info.Mode())
|
|
}
|
|
|
|
srcFile, err := os.Open(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
dstFile, err := os.OpenFile(dstPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, info.Mode())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer dstFile.Close()
|
|
|
|
_, err = io.Copy(dstFile, srcFile)
|
|
return err
|
|
})
|
|
}
|