mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
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
750 lines
23 KiB
Go
750 lines
23 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/hooks"
|
|
"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, s.skillsWalk())
|
|
|
|
// 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)
|
|
}
|
|
if warning := hooks.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
|
|
})
|
|
}
|