mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
* feat(pi): manage individual extensions per target Keep package lifecycle in Plugins while letting global, account, and project Pi targets configure individual extensions with reviewed, lossless changes. Project overrides save only project settings and never grant trust. Bind edits to native version contracts, settings snapshots, source ownership, and discovery; preserve unrelated resources and enforce renewable native locks, stale rejection, and backups. Verify Pi 0.99.2 and 1.0.0 without running extension factories. Simplify configured-state UI and distinguish Skillshare-managed packages from native tool registrations, with localized guidance and regression coverage. Closes #342. * fix(pi): address project extensions review findings Keep exact project delta rules visible when their extension files are missing so users can remove stale rules without changing global settings or trust. Show the project Extensions tab only when its generated Pi target resolves. Cover missing and agents-only projects, absent targets, and another project target with regression tests. * fix(pi): recognize official Windows account launchers Accept pi.cmd and pi.exe account launcher names on Windows, including case-insensitive and native Windows paths, before probing the existing exact-version gate. Preserve POSIX behavior and never probe unrecognized forks or stacked launcher suffixes. Add platform-name and account-gate regressions covering verified, unsupported, and missing CLI versions. Focused race tests, make check, and Windows amd64/arm64 test cross-compilation pass; real Windows runtime remains unverified because the UTM guest is stopped. * fix(pi): align rule removal and backup descriptions Offer Remove rule only for owned exact +/- rules, not project delta globs that the apply path cannot remove. Keep supported glob rows switchable and cover delta and deltaOnly forms with RED/GREEN regressions. Describe retained artifacts as extension-list and file-hash records rather than complete settings backups in English, all four website translations, and the implementation report. * fix(pi): discard records for aborted extension applies Require a validated preview and owned native lock before recording an extension change. Discard only the newly created record if final revalidation, lock ownership, or the atomic settings write fails; retain successful history and propagate cleanup errors with the original failure. Keep discovery revalidation after record I/O so cleanup does not weaken the write-boundary guard. Cover global and new/existing project settings with nine RED/GREEN regressions, including injected commit failures. Align English and translated docs with the retained-record lifecycle. * fix(pi): retain anonymous global packages in projects Keep ordered anonymous registrations separate from the proven-identity map so unsupported query-bearing sources remain visible as redacted read-only packages, rather than being dropped or associated with a project override. Preserve first-global-entry precedence for known identities. Add RED/GREEN coverage for string and object registrations, query/userinfo redaction, project entries, zero-write refusal, ordering, and continued editing of known packages. * fix(pi): deduplicate only proven project identities Exclude unresolved identities from project duplicate tracking. Preserve each anonymous registration as sourceUnknown instead of pretending unrelated query-bearing URLs are the same package. Cover mixed string/object anonymous project sources, redaction and zero-write refusals, retained anonymous globals, and last-project-entry precedence for known packages. Verify known project entries remain editable. * fix(pi): guard unresolved package precedence An unresolved earlier global registration may own a later known package, and an unresolved later project registration may supersede an earlier known entry. Keep those potentially shadowed entries and inherited deltas Unknown/read-only instead of offering edits to ignored registrations. Do not infer identities by dropping credentials or queries. Cover both ordering directions for global, inherited, project-owned, and delta views with RED/GREEN tests. Execute native query identity and dedupe evidence on Pi 0.99.2 and 1.0.0 through core and CLI-bundle contracts, now 28 scenarios and 87 assertions each. Align docs and evidence while retaining independent anonymous entries. * fix(pi): propagate unreadable source ambiguity Treat badSource entries as unresolved instead of letting an unreadable source expose editable later global registrations. Preserve the same uncertainty in inherited globals and before unreadable later project entries. Add twelve global/inherited/project regressions for null, empty, whitespace and invalid UTF-8 sources. Native core and CLI-bundle evidence confirms invalid UTF-8 can decode to and own the same identity as a later valid source on both supported Pi versions; the executed contracts now pass 29 scenarios and 90 assertions. * feat(pi): preserve filtered imports and reclaim stale locks Adopt native object registrations without changing their configured resources. Keep lossless entries in scoped private state, retain current rules across lifecycle operations, restore filters before native installation, and preserve pending retries after failures. Reclaim only unchanged empty directories after the native stale threshold, retaining renewed, replaced, nonempty and non-directory locks. Verify exact supported Pi contracts and keep unsupported cases read-only. * docs(pi): record filtered import verification after branch sync Document the current merged UI test count and repeated checks while retaining the native and visual verification limitations. * docs(pi): clarify stale acquisition exception Keep the lock safety summary consistent with the approved acquisition policy while preserving strict ownership for renewal and release. * fix(pi): keep legacy npm fallback installations unknown A missing user-scoped managed npm root cannot prove a package is absent because native Pi may use a legacy global npm or pnpm root. Keep it read-only without probing host-global state, while retaining missing-state behavior for project npm packages. * fix(pi): preserve project precedence and batch restore ownership Retain empty winning overrides when deleting them could expose older resource filters. Advance filtered restore batches only to exact writes made by the same Apply, while rejecting external changes and retaining failed native retries. Match Pi strict-false autoload semantics instead of treating null as a delta.
655 lines
26 KiB
Go
655 lines
26 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/install"
|
|
"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
|
|
|
|
// 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.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.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()
|
|
}
|
|
|
|
// 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 {
|
|
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
|
|
}
|
|
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
|
|
}
|
|
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,
|
|
})
|
|
}
|