Files
skillshare/internal/server/server.go
T
Willie 89fc4fbdf1 feat(sourcewalk): follow first-level source links when enabled
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
2026-10-05 14:26:09 +08:00

696 lines
27 KiB
Go

package server
import (
"context"
"fmt"
"net"
"net/http"
"os"
"os/signal"
"strings"
"sync"
"sync/atomic"
"syscall"
"time"
"skillshare/internal/config"
"skillshare/internal/install"
"skillshare/internal/sourcewalk"
"skillshare/internal/version"
)
// Server holds the HTTP server state
type Server struct {
cfg *config.Config
skillsStore *install.MetadataStore
agentsStore *install.MetadataStore
addr string
mux *http.ServeMux
handler http.Handler
mu sync.RWMutex // protects config: Lock for writes/reloads, RLock for reads
startTime time.Time // for uptime reporting in health check
// follow is nil while follow_source_links is off; see snapshotFollow.
follow atomic.Pointer[followConfig]
// Project mode fields (empty/nil for global mode)
projectRoot string
projectCfg *config.ProjectConfig
// unresolvedTargets are project targets left out of cfg.Targets because
// they cannot resolve (no path); sync reports them as failed.
unresolvedTargets map[string]error
// uiDistDir, when non-empty, serves UI from this disk directory
// instead of the embedded SPA. Used for runtime-downloaded UI assets.
uiDistDir string
// basePath is the URL prefix under which the UI and API are served
// (e.g. "/app"). Empty means serve at root.
basePath string
// onReady is called after the listener is bound but before serving.
// Used to open the browser only after the port is confirmed available.
onReady func()
}
// NormalizeBasePath ensures the base path starts with "/" and has no trailing slash.
// An empty or "/" input returns "".
func NormalizeBasePath(p string) string {
p = strings.TrimRight(p, "/")
if p == "" {
return ""
}
if !strings.HasPrefix(p, "/") {
p = "/" + p
}
return p
}
// wrapBasePath wraps the handler chain with StripPrefix and bare-path redirect
// when basePath is set. Skips wrapping in dev mode (no uiDistDir) and prints a warning.
func (s *Server) wrapBasePath() {
if s.basePath == "" {
return
}
if s.uiDistDir == "" {
fmt.Fprintf(os.Stderr, "Warning: --base-path is ignored in dev mode (no UI assets). Start Vite without base path.\n")
s.basePath = ""
return
}
stripped := http.StripPrefix(s.basePath, s.handler)
s.handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == s.basePath {
http.Redirect(w, r, s.basePath+"/", http.StatusMovedPermanently)
return
}
stripped.ServeHTTP(w, r)
})
}
// New creates a new Server for global mode.
// uiDistDir, when non-empty, serves UI from disk instead of the embedded SPA.
func New(cfg *config.Config, addr, basePath, uiDistDir string) *Server {
skillsStore, _ := install.LoadMetadataWithMigration(cfg.EffectiveSkillsSource(), "")
if skillsStore == nil {
skillsStore = install.NewMetadataStore()
}
agentsStore, _ := install.LoadMetadataWithMigration(cfg.EffectiveAgentsSource(), "agent")
if agentsStore == nil {
agentsStore = install.NewMetadataStore()
}
s := &Server{
cfg: cfg,
skillsStore: skillsStore,
agentsStore: agentsStore,
addr: addr,
mux: http.NewServeMux(),
basePath: NormalizeBasePath(basePath),
uiDistDir: uiDistDir,
}
s.snapshotFollow()
s.registerRoutes()
s.handler = s.withConfigAutoReload(s.mux)
s.wrapBasePath()
return s
}
// NewProject creates a new Server for project mode.
// uiDistDir, when non-empty, serves UI from disk instead of the embedded SPA.
func NewProject(cfg *config.Config, projectCfg *config.ProjectConfig, projectRoot, addr, basePath, uiDistDir string) *Server {
skillsDir := projectCfg.EffectiveSkillsSource(projectRoot)
agentsDir := projectCfg.EffectiveAgentsSource(projectRoot)
skillsStore, _ := install.LoadMetadataWithMigration(skillsDir, "")
if skillsStore == nil {
skillsStore = install.NewMetadataStore()
}
agentsStore, _ := install.LoadMetadataWithMigration(agentsDir, "agent")
if agentsStore == nil {
agentsStore = install.NewMetadataStore()
}
s := &Server{
cfg: cfg,
skillsStore: skillsStore,
agentsStore: agentsStore,
addr: addr,
mux: http.NewServeMux(),
basePath: NormalizeBasePath(basePath),
projectRoot: projectRoot,
projectCfg: projectCfg,
uiDistDir: uiDistDir,
}
_, s.unresolvedTargets = config.ResolveValidProjectTargets(projectRoot, projectCfg)
s.snapshotFollow()
s.registerRoutes()
s.handler = s.withConfigAutoReload(s.mux)
s.wrapBasePath()
return s
}
// IsProjectMode returns true when serving a project-scoped dashboard
func (s *Server) IsProjectMode() bool {
return s.projectRoot != ""
}
// skillEntry returns a copy of the skills metadata entry for relPath, or nil.
// It takes s.mu.RLock, so the caller must not hold s.mu.
func (s *Server) skillEntry(relPath string) *install.MetadataEntry {
s.mu.RLock()
defer s.mu.RUnlock()
return copyMetadataEntry(s.skillsStore.GetByPath(relPath))
}
// agentEntry returns a copy of the agents metadata entry for key, or nil.
// It takes s.mu.RLock, so the caller must not hold s.mu.
func (s *Server) agentEntry(key string) *install.MetadataEntry {
s.mu.RLock()
defer s.mu.RUnlock()
return copyMetadataEntry(s.agentsStore.GetByPath(key))
}
// copyMetadataEntry returns a shallow copy so callers can read the entry after
// s.mu is released while other requests replace or mutate the store.
func copyMetadataEntry(e *install.MetadataEntry) *install.MetadataEntry {
if e == nil {
return nil
}
c := *e
return &c
}
// skillsSource returns the skills source directory for the current mode.
// Caller must hold s.mu (RLock or Lock) when accessing s.cfg.
func (s *Server) skillsSource() string {
if s.IsProjectMode() {
return s.projectCfg.EffectiveSkillsSource(s.projectRoot)
}
return s.cfg.EffectiveSkillsSource()
}
// followConfig is the config skillsWalk reads, copied whenever the config is
// loaded, reloaded, or saved, so handlers can build a policy without s.mu.
type followConfig struct {
source string
targets map[string]config.TargetConfig
}
// snapshotFollow records the current mode's follow_source_links setting.
// Caller must hold s.mu or own s exclusively.
func (s *Server) snapshotFollow() {
enabled := s.cfg.FollowSourceLinks
if s.IsProjectMode() {
enabled = s.projectCfg.FollowSourceLinks
}
if !enabled {
s.follow.Store(nil)
return
}
s.follow.Store(&followConfig{source: s.skillsSource(), targets: s.cloneTargets()})
}
// skillsWalk returns a fresh skills source traversal policy for one request,
// following first-level source links when the current mode's config enables it.
func (s *Server) skillsWalk() sourcewalk.Options {
f := s.follow.Load()
if f == nil {
return sourcewalk.Options{}
}
return config.SkillsWalk(true, f.source, f.targets)
}
// agentsSource returns the agents source directory for the current mode.
// Caller must hold s.mu (RLock or Lock) when accessing s.cfg.
func (s *Server) agentsSource() string {
if s.IsProjectMode() {
return s.projectCfg.EffectiveAgentsSource(s.projectRoot)
}
return s.cfg.EffectiveAgentsSource()
}
// cloneTargets returns a shallow copy of the Targets map.
// Callers must hold s.mu (RLock or Lock).
func (s *Server) cloneTargets() map[string]config.TargetConfig {
targets := make(map[string]config.TargetConfig, len(s.cfg.Targets))
for k, v := range s.cfg.Targets {
targets[k] = v
}
return targets
}
// parseOpts returns install.ParseOptions from the current config.
// In project mode, project config is used unconditionally (not a fallback to global).
func (s *Server) parseOpts() install.ParseOptions {
if s.IsProjectMode() && s.projectCfg != nil {
return install.ParseOptions{
GitLabHosts: s.projectCfg.EffectiveGitLabHosts(),
AzureHosts: s.projectCfg.EffectiveAzureHosts(),
CNBHosts: s.projectCfg.EffectiveCNBHosts(),
GiteaHosts: s.projectCfg.EffectiveGiteaHosts(),
}
}
return install.ParseOptions{
GitLabHosts: s.cfg.EffectiveGitLabHosts(),
AzureHosts: s.cfg.EffectiveAzureHosts(),
CNBHosts: s.cfg.EffectiveCNBHosts(),
GiteaHosts: s.cfg.EffectiveGiteaHosts(),
}
}
// gitignoreDir returns the directory containing the managed .gitignore.
// In project mode this is .skillshare/ (entries are "skills/<name>/");
// in global mode this is the source skill directory.
func (s *Server) gitignoreDir() string {
if s.IsProjectMode() {
dir, _ := config.ProjectGitignoreTarget(s.projectRoot, s.skillsSource())
return dir
}
return s.cfg.EffectiveSkillsSource()
}
func (s *Server) projectGitignorePrefix() string {
_, prefix := config.ProjectGitignoreTarget(s.projectRoot, s.skillsSource())
return prefix
}
// configPath returns the config file path for the current mode
func (s *Server) configPath() string {
if s.IsProjectMode() {
return config.ProjectConfigPath(s.projectRoot)
}
return config.ConfigPath()
}
// saveConfig persists the config for the current mode
func (s *Server) saveConfig() error {
s.snapshotFollow()
if s.IsProjectMode() {
return s.projectCfg.Save(s.projectRoot)
}
return s.cfg.Save()
}
// saveAndReloadConfig persists config to disk then reloads it into memory.
// Callers must hold s.mu.
func (s *Server) saveAndReloadConfig() error {
if err := s.saveConfig(); err != nil {
return fmt.Errorf("failed to save config: %w", err)
}
if err := s.reloadConfig(); err != nil {
return fmt.Errorf("failed to reload config: %w", err)
}
return nil
}
// reloadConfig reloads the config for the current mode
func (s *Server) reloadConfig() error {
if s.IsProjectMode() {
pcfg, err := config.LoadProject(s.projectRoot)
if err != nil {
return err
}
s.projectCfg = pcfg
s.cfg.Targets, s.unresolvedTargets = config.ResolveValidProjectTargets(s.projectRoot, pcfg)
skillsDir := pcfg.EffectiveSkillsSource(s.projectRoot)
agentsDir := pcfg.EffectiveAgentsSource(s.projectRoot)
s.cfg.Source = skillsDir
s.cfg.AgentsSource = agentsDir
if st, err := install.LoadMetadata(skillsDir); err == nil {
s.skillsStore = st
}
if st, err := install.LoadMetadata(agentsDir); err == nil {
s.agentsStore = st
}
s.snapshotFollow()
return nil
}
newCfg, err := config.Load()
if err != nil {
return err
}
s.cfg = newCfg
if st, err := install.LoadMetadata(newCfg.EffectiveSkillsSource()); err == nil {
s.skillsStore = st
}
if st, err := install.LoadMetadata(newCfg.EffectiveAgentsSource()); err == nil {
s.agentsStore = st
}
s.snapshotFollow()
return nil
}
func (s *Server) refreshConfig() error {
s.mu.Lock()
defer s.mu.Unlock()
return s.reloadConfig()
}
func (s *Server) shouldAutoReloadConfig(path string) bool {
if !strings.HasPrefix(path, "/api/") {
return false
}
if path == "/api/health" {
return false
}
// Keep config editor recoverable even if config file is temporarily invalid.
if path == "/api/config" {
return false
}
return true
}
func (s *Server) withConfigAutoReload(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if s.shouldAutoReloadConfig(r.URL.Path) {
if err := s.refreshConfig(); err != nil {
writeError(w, http.StatusInternalServerError, "failed to reload config: "+err.Error())
return
}
}
next.ServeHTTP(w, r)
})
}
// Start starts the HTTP server with graceful shutdown on SIGTERM/SIGINT.
func (s *Server) Start() error {
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
return s.StartWithContext(ctx)
}
// SetOnReady sets a callback invoked after the listener is bound but before
// serving begins. Used to open the browser only after the port is confirmed
// available.
func (s *Server) SetOnReady(fn func()) {
s.onReady = fn
}
// StartWithContext starts the HTTP server and shuts down gracefully when ctx is cancelled.
func (s *Server) StartWithContext(ctx context.Context) error {
s.startTime = time.Now()
// Bind the port first so callers know immediately if it's in use.
ln, err := net.Listen("tcp", s.addr)
if err != nil {
return err
}
if s.basePath != "" {
fmt.Printf("Skillshare UI running at http://%s%s/\n", s.addr, s.basePath)
} else {
fmt.Printf("Skillshare UI running at http://%s\n", s.addr)
}
if s.onReady != nil {
s.onReady()
}
srv := &http.Server{
Handler: s.handler,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
}
errCh := make(chan error, 1)
go func() {
errCh <- srv.Serve(ln)
}()
select {
case err := <-errCh:
return err
case <-ctx.Done():
}
fmt.Println("\nShutting down server...")
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
return fmt.Errorf("server shutdown: %w", err)
}
fmt.Println("Server stopped gracefully")
return nil
}
// registerRoutes sets up all API and static file routes
func (s *Server) registerRoutes() {
// Health check
s.mux.HandleFunc("GET /api/health", s.handleHealth)
// Overview
s.mux.HandleFunc("GET /api/overview", s.handleOverview)
// Resources (skills + agents)
s.mux.HandleFunc("GET /api/resources", s.handleListSkills)
s.mux.HandleFunc("GET /api/resources/templates", s.handleGetTemplates)
s.mux.HandleFunc("GET /api/resources/templates/preview", s.handlePreviewSkill)
s.mux.HandleFunc("POST /api/resources", s.handleCreateSkill)
s.mux.HandleFunc("GET /api/resources/{name}", s.handleGetSkill)
s.mux.HandleFunc("GET /api/resources/{name}/files/{filepath...}", s.handleGetSkillFile)
s.mux.HandleFunc("PUT /api/resources/{name}/content", s.handlePutSkillContent)
s.mux.HandleFunc("PATCH /api/resources/{name}/source", s.handlePatchSkillSource)
s.mux.HandleFunc("POST /api/resources/{name}/open-in-editor", s.handleOpenSkillInEditor)
s.mux.HandleFunc("POST /api/resources/{name}/disable", s.handleDisableSkill)
s.mux.HandleFunc("POST /api/resources/{name}/enable", s.handleEnableSkill)
s.mux.HandleFunc("DELETE /api/resources/{name}", s.handleUninstallSkill)
s.mux.HandleFunc("POST /api/resources/batch/targets", s.handleBatchSetTargets)
s.mux.HandleFunc("POST /api/resources/batch/toggle", s.handleBatchToggleSkills)
s.mux.HandleFunc("PATCH /api/resources/{name}/targets", s.handleSetSkillTargets)
// Targets
s.mux.HandleFunc("GET /api/targets", s.handleListTargets)
s.mux.HandleFunc("POST /api/targets", s.handleAddTarget)
s.mux.HandleFunc("PATCH /api/targets/{name}", s.handleUpdateTarget)
s.mux.HandleFunc("DELETE /api/targets/{name}", s.handleRemoveTarget)
s.mux.HandleFunc("GET /api/targets/{name}/skills-off-preview", s.handleSkillsOffPreview)
s.mux.HandleFunc("GET /api/targets/{name}/instructions", s.handleGetTargetInstructions)
s.mux.HandleFunc("PUT /api/targets/{name}/instructions", s.handlePutTargetInstructions)
s.mux.HandleFunc("POST /api/targets/{name}/instructions/convert", s.handleConvertTargetInstructions)
s.mux.HandleFunc("PUT /api/targets/{name}/instructions/setup", s.handlePutTargetInstructionsSetup)
s.mux.HandleFunc("DELETE /api/targets/{name}/instructions/setup", s.handleDeleteTargetInstructionsSetup)
s.mux.HandleFunc("GET /api/targets/{name}/files", s.handleListTargetFiles)
s.mux.HandleFunc("POST /api/targets/{name}/files", s.handleAddTargetFile)
s.mux.HandleFunc("DELETE /api/targets/{name}/files", s.handleRemoveTargetFile)
s.mux.HandleFunc("GET /api/targets/{name}/files/content", s.handleGetTargetFileContent)
s.mux.HandleFunc("PUT /api/targets/{name}/files/content", s.handlePutTargetFileContent)
s.mux.HandleFunc("GET /api/targets/{name}/pi-extensions", s.requireLocalPlugin(s.handlePiExtensions))
s.mux.HandleFunc("POST /api/targets/{name}/pi-extensions/preview", s.requireLocalPlugin(s.handlePiExtensionsPreview))
s.mux.HandleFunc("POST /api/targets/{name}/pi-extensions/apply", s.requireLocalPlugin(s.handlePiExtensionsApply))
// Instruction files: shared files (tool targets are global only) and the project AGENTS.md
s.mux.HandleFunc("GET /api/instructions", s.handleListSharedInstructions)
s.mux.HandleFunc("POST /api/instructions", s.handleCreateSharedInstructions)
s.mux.HandleFunc("POST /api/instructions/assign", s.requireGlobalInstructions(s.handleAssignSharedInstructions))
s.mux.HandleFunc("GET /api/instructions/{name}/content", s.handleGetSharedInstructionsContent)
s.mux.HandleFunc("PUT /api/instructions/{name}/content", s.handlePutSharedInstructionsContent)
s.mux.HandleFunc("POST /api/instructions/{name}/restore", s.requireGlobalInstructions(s.handleRestoreSharedInstructions))
s.mux.HandleFunc("POST /api/instructions/{name}/resolve", s.handleResolveSharedInstructions)
s.mux.HandleFunc("GET /api/instructions/{name}/restore-preview", s.requireGlobalInstructions(s.handleSharedInstructionsRestorePreview))
s.mux.HandleFunc("PUT /api/instructions/{name}/targets/{target}/mode", s.requireGlobalInstructions(s.handlePutSharedInstructionsMode))
s.mux.HandleFunc("POST /api/instructions/{name}/locations", s.handleAddSharedInstructionsLocation)
s.mux.HandleFunc("DELETE /api/instructions/{name}/locations", s.handleDeleteSharedInstructionsLocation)
s.mux.HandleFunc("PUT /api/instructions/{name}/locations/mode", s.handlePutSharedInstructionsLocationMode)
s.mux.HandleFunc("GET /api/instructions/{name}/locations/restore-preview", s.handleSharedInstructionsLocationRestorePreview)
s.mux.HandleFunc("GET /api/instructions/project", s.requireProjectInstructions(s.handleGetProjectInstructions))
s.mux.HandleFunc("PUT /api/instructions/project", s.requireProjectInstructions(s.handlePutProjectInstructions))
s.mux.HandleFunc("POST /api/instructions/project/shim", s.requireProjectInstructions(s.handleProjectInstructionsShim))
// Projects (global config only)
s.mux.HandleFunc("GET /api/projects", s.requireGlobalProjects(s.handleListProjects))
s.mux.HandleFunc("PUT /api/projects", s.requireGlobalProjects(s.handleSaveProject))
s.mux.HandleFunc("DELETE /api/projects", s.requireGlobalProjects(s.handleRemoveProject))
s.mux.HandleFunc("POST /api/projects/convert", s.requireGlobalProjects(s.handleConvertProject))
// Sync matrix
s.mux.HandleFunc("GET /api/sync-matrix", s.handleSyncMatrix)
s.mux.HandleFunc("POST /api/sync-matrix/preview", s.handleSyncMatrixPreview)
// Sync
s.mux.HandleFunc("POST /api/sync", s.handleSync)
s.mux.HandleFunc("GET /api/diff/stream", s.handleDiffStream)
s.mux.HandleFunc("GET /api/diff", s.handleDiff)
// Collect
s.mux.HandleFunc("GET /api/collect/scan", s.handleCollectScan)
s.mux.HandleFunc("POST /api/collect", s.handleCollect)
// Hub
s.mux.HandleFunc("GET /api/hub/drafts", s.handleHubDrafts)
s.mux.HandleFunc("POST /api/hub/drafts", s.handleHubDrafts)
s.mux.HandleFunc("GET /api/hub/drafts/candidates", s.handleHubDraftCandidates)
s.mux.HandleFunc("POST /api/hub/drafts/import", s.handleHubDraftImport)
s.mux.HandleFunc("GET /api/hub/drafts/{id}", s.handleHubDraft)
s.mux.HandleFunc("PUT /api/hub/drafts/{id}", s.handleHubDraft)
s.mux.HandleFunc("DELETE /api/hub/drafts/{id}", s.handleHubDraft)
s.mux.HandleFunc("POST /api/hub/drafts/{id}/export", s.handleHubDraftExport)
s.mux.HandleFunc("GET /api/hub/index", s.handleHubIndex)
s.mux.HandleFunc("POST /api/hub/refs", s.handleHubRefs)
s.mux.HandleFunc("GET /api/hub/saved", s.handleGetHubSaved)
s.mux.HandleFunc("PUT /api/hub/saved", s.handlePutHubSaved)
s.mux.HandleFunc("POST /api/hub/saved", s.handlePostHubSaved)
s.mux.HandleFunc("DELETE /api/hub/saved/{label}", s.handleDeleteHubSaved)
// Search & Install
s.mux.HandleFunc("GET /api/search", s.handleSearch)
s.mux.HandleFunc("GET /api/preview", s.handlePreview)
s.mux.HandleFunc("POST /api/discover", s.handleDiscover)
s.mux.HandleFunc("POST /api/install", s.handleInstall)
s.mux.HandleFunc("POST /api/install/batch", s.handleInstallBatch)
s.mux.HandleFunc("POST /api/uninstall/batch", s.handleBatchUninstall)
// Update & Check
s.mux.HandleFunc("POST /api/update", s.handleUpdate)
s.mux.HandleFunc("GET /api/update/stream", s.handleUpdateStream)
s.mux.HandleFunc("GET /api/update/missing-tracked-repos", s.handleMissingTrackedRepos)
s.mux.HandleFunc("POST /api/update/rehydrate", s.handleRehydrateTrackedRepos)
s.mux.HandleFunc("GET /api/check/stream", s.handleCheckStream)
s.mux.HandleFunc("GET /api/check", s.handleCheck)
// Repo uninstall
s.mux.HandleFunc("DELETE /api/repos/{name}", s.handleUninstallRepo)
// Version check / app lifecycle
s.mux.HandleFunc("GET /api/version", s.handleVersionCheck)
s.mux.HandleFunc("POST /api/upgrade", s.handleUpgrade)
s.mux.HandleFunc("POST /api/restart", s.handleRestart)
// Doctor (health check)
s.mux.HandleFunc("GET /api/doctor", s.handleDoctor)
// Backups
s.mux.HandleFunc("GET /api/backups", s.handleListBackups)
s.mux.HandleFunc("DELETE /api/backups", s.handleDeleteAllBackups)
s.mux.HandleFunc("DELETE /api/backups/{timestamp}", s.handleDeleteBackup)
s.mux.HandleFunc("POST /api/backup", s.handleCreateBackup)
s.mux.HandleFunc("POST /api/backup/cleanup", s.handleCleanupBackups)
s.mux.HandleFunc("POST /api/restore", s.handleRestore)
s.mux.HandleFunc("POST /api/restore/validate", s.handleValidateRestore)
// File history (backups of single files skillshare rewrote)
s.mux.HandleFunc("GET /api/file-backups", s.handleListFileBackups)
s.mux.HandleFunc("GET /api/file-backups/versions", s.handleFileBackupVersions)
s.mux.HandleFunc("GET /api/file-backups/version", s.handleFileBackupVersion)
s.mux.HandleFunc("POST /api/file-backups/restore", s.handleRestoreFileBackup)
// Trash
s.mux.HandleFunc("GET /api/trash", s.handleListTrash)
s.mux.HandleFunc("POST /api/trash/{name}/restore", s.handleRestoreTrash)
s.mux.HandleFunc("DELETE /api/trash/{name}", s.handleDeleteTrash)
s.mux.HandleFunc("POST /api/trash/empty", s.handleEmptyTrash)
// Extras
s.mux.HandleFunc("GET /api/plugins", s.requireLocalPlugin(s.handlePluginList))
s.mux.HandleFunc("GET /api/plugins/{name}/files", s.requireLocalPlugin(s.handlePluginFiles))
s.mux.HandleFunc("GET /api/plugins/{name}/files/{filepath...}", s.requireLocalPlugin(s.handlePluginFile))
s.mux.HandleFunc("POST /api/plugins/discover", s.requireLocalPlugin(s.handlePluginDiscover))
s.mux.HandleFunc("POST /api/plugins/preview", s.requireLocalPlugin(s.handlePluginPreview))
s.mux.HandleFunc("POST /api/plugins/apply", s.requireLocalPlugin(s.handlePluginApply))
s.mux.HandleFunc("GET /api/mcp", s.requireLocalMCP(s.handleMCPList))
s.mux.HandleFunc("POST /api/mcp", s.requireLocalMCP(s.handleMCPConfigure))
s.mux.HandleFunc("GET /api/mcp/check", s.requireLocalMCP(s.handleMCPCheck))
s.mux.HandleFunc("POST /api/mcp/probe", s.requireLocalMCP(s.handleMCPProbe))
s.mux.HandleFunc("POST /api/mcp/preview", s.requireLocalMCP(s.handleMCPPreview))
s.mux.HandleFunc("POST /api/mcp/render", s.requireLocalMCP(s.handleMCPRender))
s.mux.HandleFunc("POST /api/mcp/import", s.requireLocalMCP(s.handleMCPImport))
s.mux.HandleFunc("POST /api/mcp/restore", s.requireLocalMCP(s.handleMCPRestore))
s.mux.HandleFunc("GET /api/hooks", s.requireLocalHooks(s.handleHooksList))
s.mux.HandleFunc("POST /api/hooks", s.requireLocalHooks(s.handleHooksConfigure))
s.mux.HandleFunc("POST /api/hooks/preview", s.requireLocalHooks(s.handleHooksPreview))
s.mux.HandleFunc("POST /api/hooks/render", s.requireLocalHooks(s.handleHooksRender))
s.mux.HandleFunc("POST /api/hooks/import", s.requireLocalHooks(s.handleHooksImport))
s.mux.HandleFunc("POST /api/hooks/restore", s.requireLocalHooks(s.handleHooksRestore))
s.mux.HandleFunc("GET /api/hooks/catalog", s.requireLocalHooks(s.handleHooksCatalog))
s.mux.HandleFunc("GET /api/extras", s.handleExtras)
s.mux.HandleFunc("GET /api/extras/memory/notes", s.handleMemoryNotes)
s.mux.HandleFunc("POST /api/extras/memory/init", s.handleMemoryInit)
s.mux.HandleFunc("PUT /api/extras/memory/index", s.handleMemoryIndex)
s.mux.HandleFunc("POST /api/extras/memory/move", s.handleMemoryMove)
s.mux.HandleFunc("GET /api/extras/memory/notes/content", s.handleMemoryContent)
s.mux.HandleFunc("PUT /api/extras/memory/notes/content", s.handleMemoryWrite)
s.mux.HandleFunc("DELETE /api/extras/memory/notes/content", s.handleMemoryDelete)
s.mux.HandleFunc("GET /api/extras/memory/guidance", s.handleMemoryGuidance)
s.mux.HandleFunc("POST /api/extras/memory/guidance/plan", s.handleMemoryGuidancePlan)
s.mux.HandleFunc("POST /api/extras/memory/guidance/apply", s.handleMemoryGuidanceApply)
s.mux.HandleFunc("GET /api/extras/extensions", s.handleExtrasExtensions)
s.mux.HandleFunc("GET /api/extras/diff", s.handleExtrasDiff)
s.mux.HandleFunc("POST /api/extras", s.handleExtrasCreate)
s.mux.HandleFunc("POST /api/extras/sync", s.handleExtrasSync)
s.mux.HandleFunc("PATCH /api/extras/{name}/mode", s.handleExtrasMode)
s.mux.HandleFunc("DELETE /api/extras/{name}", s.handleExtrasDelete)
s.mux.HandleFunc("POST /api/extras/{name}/targets", s.handleExtrasAddTarget)
s.mux.HandleFunc("DELETE /api/extras/{name}/targets", s.handleExtrasRemoveTarget)
// Extensions (transform extensions management)
s.mux.HandleFunc("GET /api/extensions", s.handleExtensionsList)
s.mux.HandleFunc("POST /api/extensions/install", s.handleExtensionsInstall)
s.mux.HandleFunc("POST /api/extensions/open", s.handleExtensionsOpen)
s.mux.HandleFunc("DELETE /api/extensions/{name}", s.handleExtensionsRemove)
// Git
s.mux.HandleFunc("GET /api/git/status", s.handleGitStatus)
s.mux.HandleFunc("POST /api/git/root", s.handleSetGitRoot)
s.mux.HandleFunc("GET /api/git/branches", s.handleGitBranches)
s.mux.HandleFunc("POST /api/git/checkout", s.handleGitCheckout)
s.mux.HandleFunc("POST /api/git/commit", s.handleGitCommit)
s.mux.HandleFunc("POST /api/git/discard", s.handleGitDiscard)
s.mux.HandleFunc("POST /api/git/absorb-nested", s.handleAbsorbNested)
s.mux.HandleFunc("POST /api/push", s.handlePush)
s.mux.HandleFunc("POST /api/pull", s.handlePull)
// Audit
s.mux.HandleFunc("GET /api/audit/stream", s.handleAuditStream)
s.mux.HandleFunc("PATCH /api/audit/policy", s.handleAuditPolicy)
s.mux.HandleFunc("GET /api/audit/rules/compiled", s.handleGetCompiledRules)
s.mux.HandleFunc("POST /api/audit/rules/toggle", s.handleToggleRule)
s.mux.HandleFunc("POST /api/audit/rules/reset", s.handleResetRules)
s.mux.HandleFunc("GET /api/audit/rules", s.handleGetAuditRules)
s.mux.HandleFunc("PUT /api/audit/rules", s.handlePutAuditRules)
s.mux.HandleFunc("POST /api/audit/rules", s.handleInitAuditRules)
s.mux.HandleFunc("GET /api/audit", s.handleAuditAll)
s.mux.HandleFunc("GET /api/audit/{name}", s.handleAuditSkill)
// Analyze (context-window budget)
s.mux.HandleFunc("GET /api/analyze", s.handleAnalyze)
// Log
s.mux.HandleFunc("GET /api/log", s.handleListLog)
s.mux.HandleFunc("GET /api/log/stats", s.handleLogStats)
s.mux.HandleFunc("DELETE /api/log", s.handleClearLog)
// Config
s.mux.HandleFunc("GET /api/config", s.handleGetConfig)
s.mux.HandleFunc("PUT /api/config", s.handlePutConfig)
s.mux.HandleFunc("PATCH /api/config", s.handlePatchConfig)
s.mux.HandleFunc("GET /api/config/available-targets", s.handleAvailableTargets)
// Skillignore
s.mux.HandleFunc("GET /api/skillignore", s.handleGetSkillignore)
s.mux.HandleFunc("PUT /api/skillignore", s.handlePutSkillignore)
// Agentignore
s.mux.HandleFunc("GET /api/agentignore", s.handleGetAgentignore)
s.mux.HandleFunc("PUT /api/agentignore", s.handlePutAgentignore)
// SPA fallback — must be last
if s.uiDistDir != "" {
s.mux.Handle("/", spaHandlerFromDisk(s.uiDistDir, s.basePath))
} else {
s.mux.Handle("/", uiPlaceholderHandler())
}
}
// handleHealth responds with status, version, and uptime
func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
uptime := int64(0)
if !s.startTime.IsZero() {
uptime = int64(time.Since(s.startTime).Seconds())
}
writeJSON(w, map[string]any{
"status": "ok",
"version": version.Version,
"uptime_seconds": uptime,
})
}