package server import ( "encoding/json" "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"` 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"` } 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, 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...) }(), } switch mode { case "merge", "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() } 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"` // Instructions optionally names the instruction file of a custom target. Instructions *config.TargetInstructionsConfig `json:"instructions"` } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { 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) if err != nil { writeError(w, http.StatusBadRequest, err.Error()) return } 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 } } tc := config.TargetConfig{Skills: &config.ResourceTargetConfig{Path: body.Path}, Instructions: body.Instructions} 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() { s.projectCfg.Targets = append(s.projectCfg.Targets, config.ProjectTargetEntry{Name: body.Name, Instructions: body.Instructions}) } 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. if 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 } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { 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 } 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.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 } 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 action := "filter" if hasSetting && hasFilter { action = "settings+filter" } else if hasSetting { action = "settings" } s.writeOpsLog("target", "ok", start, map[string]any{ "action": action, "name": name, "scope": "ui", }, "") writeJSON(w, map[string]any{"success": true}) } // 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 }) }