mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
* fix(config): honor OMP skills directory overrides OMP reads global skills below PI_CODING_AGENT_DIR, but unpinned built-in targets still selected the default home. Resolve that runtime default without changing the canonical template used to derive named accounts. Keep account scan paths independent of the override and document explicit path precedence in target guidance and its existing translations. * fix(config): preserve inferred OMP paths across saves Saving an unpinned OMP target serialized its resolved skills path, so a later agent-directory override no longer selected the native location. Track this fallback with the existing derived-path marker so config saves preserve its inferred status while explicit paths remain pinned. Cover save/reload after environment changes and filter edits, and fold redundant account and project-alias checks into their existing cases. * docs(config): clarify when OMP skills paths stay fixed Initialization and target addition save their selected destination, while an OMP entry with no configured skills path follows later environment changes. Clarify that distinction in public and built-in target guidance and all four existing translations. Keep project alias coverage in its existing owner test and remove redundant OMP matcher and generic save assertions. * test(config): normalize explicit OMP account paths The explicit-path fixture combines a native temporary root with a forward slash suffix. Clean the actual path for comparison so mixed separators match the native expected path on Windows, retaining the original path in failure output. * test(config): use portable OMP whitespace override fixture Windows normalizes a directory component ending in a space during native absolute-path resolution. Use a leading-space component to preserve the check that override values are not trimmed without depending on trailing space filename behavior. * fix(config): preserve default OMP home in account shells Keep plain OMP skills on the canonical home when its environment override matches a declared account, so the unfiltered default target cannot bypass account filters. Share account-aware defaults with discovery and dashboard selection, and keep canonical account templates separate from runtime homes. Require an OMP install before automatic detection because Pi shares the same override. Trim surrounding whitespace, ignore relative overrides, and retain explicit saved paths. Cover account filtering, aliases, symlinks, saves, discovery, and existing environment-selected file homes with regressions.
314 lines
9.7 KiB
Go
314 lines
9.7 KiB
Go
package server
|
|
|
|
import (
|
|
"cmp"
|
|
"errors"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"time"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/hooks"
|
|
"skillshare/internal/plugin"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
func (s *Server) handleGetConfig(w http.ResponseWriter, r *http.Request) {
|
|
// Best-effort refresh so UI reflects external config edits without restart.
|
|
// Keep endpoint usable even when config is temporarily invalid.
|
|
s.mu.Lock()
|
|
_ = s.reloadConfig()
|
|
cfgObj := any(s.cfg)
|
|
if s.IsProjectMode() {
|
|
cfgObj = s.projectCfg
|
|
}
|
|
s.mu.Unlock()
|
|
|
|
raw, err := os.ReadFile(s.configPath())
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to read config: "+err.Error())
|
|
return
|
|
}
|
|
|
|
writeJSON(w, map[string]any{
|
|
"config": cfgObj,
|
|
"raw": string(raw),
|
|
})
|
|
}
|
|
|
|
var syncModes = []string{"merge", "copy", "symlink"}
|
|
|
|
// handlePatchConfig — PATCH /api/config
|
|
// Sets single settings the Settings page owns, so the UI never rewrites the whole YAML.
|
|
// All fields live in the global config only; project mode has no default mode, log limit or backup limits.
|
|
func (s *Server) handlePatchConfig(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
|
|
var body struct {
|
|
Mode *string `json:"mode"`
|
|
LogMaxEntries *int `json:"logMaxEntries"`
|
|
BackupMaxCount *int `json:"backupMaxCount"`
|
|
BackupMaxSizeMB *int64 `json:"backupMaxSizeMB"`
|
|
}
|
|
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
}
|
|
return
|
|
}
|
|
if body.Mode == nil && body.LogMaxEntries == nil && body.BackupMaxCount == nil && body.BackupMaxSizeMB == nil {
|
|
writeError(w, http.StatusBadRequest, "mode, logMaxEntries, backupMaxCount or backupMaxSizeMB is required")
|
|
return
|
|
}
|
|
if body.Mode != nil && !slices.Contains(syncModes, *body.Mode) {
|
|
writeError(w, http.StatusBadRequest, "invalid mode: "+*body.Mode)
|
|
return
|
|
}
|
|
if body.LogMaxEntries != nil && *body.LogMaxEntries < 0 {
|
|
writeError(w, http.StatusBadRequest, "logMaxEntries cannot be negative")
|
|
return
|
|
}
|
|
if body.BackupMaxCount != nil && *body.BackupMaxCount < 0 || body.BackupMaxSizeMB != nil && *body.BackupMaxSizeMB < 0 {
|
|
writeError(w, http.StatusBadRequest, "backup limits cannot be negative")
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if s.IsProjectMode() {
|
|
writeError(w, http.StatusBadRequest, "these settings are global only")
|
|
return
|
|
}
|
|
// /api/config skips the auto-reload middleware, so pick up outside edits before writing.
|
|
_ = s.reloadConfig()
|
|
args := map[string]any{"scope": "ui"}
|
|
if body.Mode != nil {
|
|
// Targets that inherit the mode must still be able to honour their naming.
|
|
for name, t := range s.cfg.Targets {
|
|
sc := t.SkillsConfig()
|
|
if err := config.TargetNamingModeError(sc.TargetNaming, cmp.Or(sc.Mode, *body.Mode)); err != nil && sc.IsEnabled() {
|
|
writeError(w, http.StatusBadRequest, "target "+name+": "+err.Error())
|
|
return
|
|
}
|
|
}
|
|
if err := s.cfg.ProjectNamingError(s.cfg.Projects, *body.Mode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
s.cfg.Mode = *body.Mode
|
|
args["mode"] = *body.Mode
|
|
}
|
|
if body.LogMaxEntries != nil {
|
|
s.cfg.Log.MaxEntries = body.LogMaxEntries
|
|
args["log_max_entries"] = *body.LogMaxEntries
|
|
}
|
|
if body.BackupMaxCount != nil {
|
|
s.cfg.Backup.MaxCount = body.BackupMaxCount
|
|
args["backup_max_count"] = *body.BackupMaxCount
|
|
}
|
|
if body.BackupMaxSizeMB != nil {
|
|
s.cfg.Backup.MaxSizeMB = body.BackupMaxSizeMB
|
|
args["backup_max_size_mb"] = *body.BackupMaxSizeMB
|
|
}
|
|
if err := s.saveConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to save config: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("config-patch", "ok", start, args, "")
|
|
writeJSON(w, map[string]any{"mode": s.cfg.Mode, "logMaxEntries": s.cfg.Log.MaxEntries})
|
|
}
|
|
|
|
func (s *Server) handlePutConfig(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
var body struct {
|
|
Raw string `json:"raw"`
|
|
}
|
|
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
}
|
|
return
|
|
}
|
|
|
|
// Validate YAML syntax + semantic validation before saving
|
|
var warnings []string
|
|
if s.IsProjectMode() {
|
|
var testCfg config.ProjectConfig
|
|
if err := yaml.Unmarshal([]byte(body.Raw), &testCfg); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid YAML: "+err.Error())
|
|
return
|
|
}
|
|
if err := plugin.Validate([]byte(body.Raw), nil); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
w2, validErr := config.ValidateProjectConfig(&testCfg, s.projectRoot)
|
|
if validErr == nil {
|
|
validErr = config.ValidateMCP(testCfg.MCP, testCfg.Sources.MCP)
|
|
}
|
|
if validErr == nil {
|
|
validErr = hooks.ValidateSection(&testCfg.Hooks, s.configPath(), true, nil)
|
|
}
|
|
if validErr != nil {
|
|
writeError(w, http.StatusBadRequest, validErr.Error())
|
|
return
|
|
}
|
|
warnings = w2
|
|
} else {
|
|
var testCfg config.Config
|
|
if err := yaml.Unmarshal([]byte(body.Raw), &testCfg); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid YAML: "+err.Error())
|
|
return
|
|
}
|
|
// An account of an Agent is a target for plugins under the name the config gives it.
|
|
if err := plugin.Validate([]byte(body.Raw), testCfg.AgentConfigDirTargetAgents()); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
w2, validErr := config.ValidateConfig(&testCfg)
|
|
if validErr == nil {
|
|
validErr = config.ValidateMCP(testCfg.MCP, testCfg.Sources.MCP, testCfg.AgentConfigDirTargets()...)
|
|
}
|
|
if validErr == nil {
|
|
validErr = hooks.ValidateSection(&testCfg.Hooks, s.configPath(), false, testCfg.AgentConfigDirTargetAgents())
|
|
}
|
|
if validErr != nil {
|
|
writeError(w, http.StatusBadRequest, validErr.Error())
|
|
return
|
|
}
|
|
warnings = w2
|
|
}
|
|
|
|
// Write a symlinked config's target; a project config must stay inside the project.
|
|
path, err := utils.ConfigWritePath(s.configPath(), s.IsProjectMode())
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if err := os.WriteFile(path, []byte(body.Raw), 0644); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to write config: "+err.Error())
|
|
return
|
|
}
|
|
|
|
if err := s.reloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "config saved but failed to reload: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("config", "ok", start, map[string]any{
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{
|
|
"success": true,
|
|
"warnings": warnings,
|
|
})
|
|
}
|
|
|
|
func (s *Server) handleAvailableTargets(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
projectRoot := s.projectRoot
|
|
targets := s.cloneTargets()
|
|
s.mu.RUnlock()
|
|
|
|
isProjectMode := projectRoot != ""
|
|
|
|
var defaults map[string]config.TargetConfig
|
|
if isProjectMode {
|
|
defaults = config.ProjectTargets()
|
|
} else {
|
|
defaults = (&config.Config{Targets: targets}).DefaultTargets()
|
|
}
|
|
|
|
type availTarget struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
AgentPath string `json:"agentPath,omitempty"`
|
|
// ConfigDir is set when a target can be another config directory of this Agent.
|
|
ConfigDir string `json:"configDir,omitempty"`
|
|
Installed bool `json:"installed"`
|
|
Detected bool `json:"detected"`
|
|
// ReadsFrom names the configured targets with skills on whose skills
|
|
// folder this tool already reads.
|
|
ReadsFrom []string `json:"readsFrom,omitempty"`
|
|
// InstructionsFile is the file name of the tool's instructions file
|
|
// (AGENTS.md, GEMINI.md, ...), empty when it has none.
|
|
InstructionsFile string `json:"instructionsFile,omitempty"`
|
|
// InstructionsPath is that file's default path, for the add dialog's list of writes.
|
|
InstructionsPath string `json:"instructionsPath,omitempty"`
|
|
// ReadBy names the other tools, on this machine or configured, whose
|
|
// default scan paths include this tool's skills folder.
|
|
ReadBy []string `json:"readBy,omitempty"`
|
|
}
|
|
|
|
var agentDefaults map[string]config.TargetConfig
|
|
if isProjectMode {
|
|
agentDefaults = config.ProjectAgentTargets()
|
|
} else {
|
|
agentDefaults = config.DefaultAgentTargets()
|
|
}
|
|
|
|
items := make([]availTarget, 0, len(defaults))
|
|
for name, tc := range defaults {
|
|
_, installed := targets[name]
|
|
// Check if the tool's config directory exists: its declared detect dir,
|
|
// else the parent of the skills path.
|
|
detected := false
|
|
if !installed {
|
|
probe := config.DetectDir(name)
|
|
if probe == "" {
|
|
probe = filepath.Dir(tc.Path)
|
|
}
|
|
if _, err := os.Stat(probe); err == nil {
|
|
detected = true
|
|
}
|
|
}
|
|
item := availTarget{
|
|
Name: name,
|
|
Path: tc.Path,
|
|
Installed: installed,
|
|
Detected: detected,
|
|
ReadsFrom: config.SkillsReadFrom(targets, name, projectRoot),
|
|
}
|
|
if agentTC, ok := agentDefaults[name]; ok {
|
|
item.AgentPath = agentTC.Path
|
|
}
|
|
if it, ok := config.LookupInstructions(name, isProjectMode); ok {
|
|
item.InstructionsFile = filepath.Base(it.Path)
|
|
item.InstructionsPath = it.Path
|
|
}
|
|
if !isProjectMode {
|
|
item.ConfigDir = config.AgentConfigDir(name)
|
|
}
|
|
items = append(items, item)
|
|
}
|
|
|
|
// Who reads each folder, so a shared folder (universal) can show the tools it serves.
|
|
present := func(it availTarget) bool { return it.Installed || it.Detected }
|
|
for i := range items {
|
|
folder := filepath.Clean(config.ExpandPath(items[i].Path))
|
|
for _, other := range items {
|
|
if other.Name == items[i].Name || !present(other) {
|
|
continue
|
|
}
|
|
for _, p := range config.RuntimeScanPaths(other.Name, isProjectMode) {
|
|
if filepath.Clean(config.ExpandPath(p)) == folder {
|
|
items[i].ReadBy = append(items[i].ReadBy, other.Name)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
slices.Sort(items[i].ReadBy)
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"targets": items})
|
|
}
|