mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
A single-file extra added from the dashboard with the shared source got <extras dir>/<name> as its folder, so a second file in the same folder needed the same name and was refused as a duplicate. Project mode had no source setting at all, so it could never share a folder. The add dialog now has a source folder field that defaults to the name, and project extras accept a source relative to the project root, from the dashboard and from `extras init -p --source`. Paths shown for single-file extras also keep the folder's own separator, so Windows paths no longer mix backslashes with a slash before the file name. Refs #300
1077 lines
33 KiB
Go
1077 lines
33 KiB
Go
package server
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
syncpkg "skillshare/internal/sync"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
// resolveExtensionSpec resolves a target's extension value into a transform
|
|
// spec, mirroring the CLI's resolveExtension. A bare name resolves under the
|
|
// current mode's extensions dir; a path (contains a separator or starts with
|
|
// ".") is used directly. An empty value yields (nil, nil) — no transform.
|
|
func (s *Server) resolveExtensionSpec(ext string) (*syncpkg.ExtensionSpec, error) {
|
|
if ext == "" {
|
|
return nil, nil
|
|
}
|
|
execPath := filepath.Join(s.extensionsDir(), ext)
|
|
if strings.ContainsAny(ext, "/\\") || strings.HasPrefix(ext, ".") {
|
|
execPath = config.ExpandPath(ext)
|
|
}
|
|
return syncpkg.LoadExtensionSpec(execPath, ext)
|
|
}
|
|
|
|
// extrasListEntry is the JSON response shape for a single extra.
|
|
type extrasListEntry struct {
|
|
Name string `json:"name"`
|
|
File string `json:"file,omitempty"` // single-file extra: the synced file in source_dir
|
|
SourceDir string `json:"source_dir"`
|
|
SourceType string `json:"source_type"`
|
|
FileCount int `json:"file_count"`
|
|
SourceExists bool `json:"source_exists"`
|
|
Targets []extrasTargetInfo `json:"targets"`
|
|
}
|
|
|
|
// extrasTargetInfo is the per-target sync status inside an extra entry.
|
|
type extrasTargetInfo struct {
|
|
Path string `json:"path"`
|
|
Mode string `json:"mode"`
|
|
Flatten bool `json:"flatten"`
|
|
Extension string `json:"extension,omitempty"`
|
|
As string `json:"as,omitempty"` // single-file extra: target filename
|
|
Status string `json:"status"` // "synced", "drift", "modified", "not synced", "no source"
|
|
}
|
|
|
|
// extrasSourceDir returns the source directory for the named extra in the
|
|
// current mode.
|
|
func (s *Server) extrasSourceDir(extra config.ExtraConfig) string {
|
|
if s.IsProjectMode() {
|
|
return config.ResolveExtrasSourceDirProject(extra, s.projectCfg.EffectiveExtrasSource(s.projectRoot), s.projectRoot)
|
|
}
|
|
return config.ResolveExtrasSourceDir(extra, s.cfg.EffectiveExtrasSource(), s.cfg.EffectiveSkillsSource())
|
|
}
|
|
|
|
// extrasConfig returns the extras slice for the current mode.
|
|
func (s *Server) extrasConfig() []config.ExtraConfig {
|
|
if s.IsProjectMode() {
|
|
return s.projectCfg.Extras
|
|
}
|
|
return s.cfg.Extras
|
|
}
|
|
|
|
func resolveExtrasTargetPath(projectRoot, path string) string {
|
|
resolved := config.ExpandPath(path)
|
|
if projectRoot != "" && !filepath.IsAbs(resolved) {
|
|
return filepath.Join(projectRoot, filepath.FromSlash(resolved))
|
|
}
|
|
return resolved
|
|
}
|
|
|
|
// handleExtras — GET /api/extras
|
|
func (s *Server) handleExtras(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
extras := s.extrasConfig()
|
|
projectRoot := s.projectRoot
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
extrasSource := s.cfg.EffectiveExtrasSource()
|
|
// rawExtrasSource is the user's explicit configuration value (either the
|
|
// legacy extras_source field or the new sources.extras field). It is empty
|
|
// only when the user did not configure either, so source_type can
|
|
// distinguish "default" (derived) from "extras_source" (user-configured).
|
|
rawExtrasSource := s.cfg.ExtrasSource
|
|
if rawExtrasSource == "" {
|
|
rawExtrasSource = s.cfg.Sources.Extras
|
|
}
|
|
var projectExtrasParent string
|
|
if s.IsProjectMode() {
|
|
projectExtrasParent = s.projectCfg.EffectiveExtrasSource(s.projectRoot)
|
|
}
|
|
s.mu.RUnlock()
|
|
|
|
isProjectMode := projectRoot != ""
|
|
|
|
// Resolve the extras_source value for source_type resolution (global mode only).
|
|
resolvedExtrasSource := ""
|
|
if !isProjectMode {
|
|
resolvedExtrasSource = rawExtrasSource
|
|
}
|
|
|
|
entries := make([]extrasListEntry, 0, len(extras))
|
|
for _, extra := range extras {
|
|
var sourceDir string
|
|
if isProjectMode {
|
|
sourceDir = config.ResolveExtrasSourceDirProject(extra, projectExtrasParent, projectRoot)
|
|
} else {
|
|
sourceDir = config.ResolveExtrasSourceDir(extra, extrasSource, source)
|
|
}
|
|
entry := extrasListEntry{
|
|
Name: extra.Name,
|
|
File: extra.File,
|
|
SourceDir: sourceDir,
|
|
SourceType: config.ResolveExtrasSourceType(extra, resolvedExtrasSource),
|
|
}
|
|
|
|
files, err := syncpkg.DiscoverExtraSource(sourceDir, extra.File)
|
|
if err != nil {
|
|
entry.SourceExists = false
|
|
entry.FileCount = 0
|
|
} else {
|
|
entry.SourceExists = true
|
|
entry.FileCount = len(files)
|
|
}
|
|
|
|
entry.Targets = make([]extrasTargetInfo, 0, len(extra.Targets))
|
|
for _, t := range extra.Targets {
|
|
m := syncpkg.ExtraTargetMode(t.Mode, extra.File != "")
|
|
targetPath := resolveExtrasTargetPath(projectRoot, t.Path)
|
|
ti := extrasTargetInfo{
|
|
Path: t.Path,
|
|
Mode: m,
|
|
Flatten: t.Flatten,
|
|
Extension: t.Extension,
|
|
As: t.As,
|
|
}
|
|
|
|
if extra.File != "" {
|
|
ti.Status = syncpkg.ExtraFileStatus(syncpkg.NewExtraFile(sourceDir, extra.File, targetPath, t.As, m))
|
|
entry.Targets = append(entry.Targets, ti)
|
|
continue
|
|
}
|
|
|
|
// Transform extensions use copy semantics. Resolve the mode through
|
|
// the shared resolver instead of EffectiveMode, whose generic "merge"
|
|
// default for an empty mode would make a valid extension target always
|
|
// report drift.
|
|
if t.Extension != "" {
|
|
resolved, modeErr := syncpkg.ResolveExtensionMode(t.Mode)
|
|
if modeErr != nil {
|
|
// Invalid config (extension with a non-copy mode): sync rejects
|
|
// it with a clear error, so flag drift here rather than guessing.
|
|
ti.Status = "drift"
|
|
entry.Targets = append(entry.Targets, ti)
|
|
continue
|
|
}
|
|
m = resolved
|
|
ti.Mode = m
|
|
}
|
|
|
|
if !entry.SourceExists {
|
|
ti.Status = "no source"
|
|
} else if _, statErr := os.Stat(targetPath); os.IsNotExist(statErr) {
|
|
ti.Status = "not synced"
|
|
} else {
|
|
// A transform extension renames output (e.g. .md → .toml), so
|
|
// resolve its output_ext to compare against the right target
|
|
// filenames — otherwise status is always reported as drift.
|
|
outputExt := ""
|
|
if t.Extension != "" {
|
|
if spec, serr := s.resolveExtensionSpec(t.Extension); serr == nil && spec != nil {
|
|
outputExt = spec.OutputExt
|
|
} else if serr != nil {
|
|
log.Printf("warning: extension %q for extra %q could not be resolved (%v); sync status may be inaccurate", t.Extension, extra.Name, serr)
|
|
}
|
|
}
|
|
ti.Status = syncpkg.CheckSyncStatus(files, sourceDir, targetPath, m, t.Flatten, outputExt)
|
|
}
|
|
|
|
entry.Targets = append(entry.Targets, ti)
|
|
}
|
|
|
|
entries = append(entries, entry)
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"extras": entries})
|
|
}
|
|
|
|
// handleExtrasExtensions — GET /api/extras/extensions
|
|
// Lists transform extensions available in the current mode's extensions
|
|
// directory (~/.config/skillshare/extensions globally, .skillshare/extensions
|
|
// in project mode). Used by the UI to populate the per-target extension picker.
|
|
func (s *Server) handleExtrasExtensions(w http.ResponseWriter, r *http.Request) {
|
|
extDir := filepath.Join(filepath.Dir(s.configPath()), "extensions")
|
|
names, err := syncpkg.ListExtensions(extDir)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
if names == nil {
|
|
names = []string{}
|
|
}
|
|
writeJSON(w, map[string]any{"extensions": names})
|
|
}
|
|
|
|
// extrasDiffItem represents one file that needs action during sync.
|
|
type extrasDiffItem struct {
|
|
Action string `json:"action"` // "create" or "update"
|
|
File string `json:"file"`
|
|
Reason string `json:"reason"`
|
|
}
|
|
|
|
// extrasDiffEntry is the per-extra/target diff response shape.
|
|
type extrasDiffEntry struct {
|
|
Name string `json:"name"`
|
|
Target string `json:"target"`
|
|
Mode string `json:"mode"`
|
|
Synced bool `json:"synced"`
|
|
Items []extrasDiffItem `json:"items"`
|
|
}
|
|
|
|
// handleExtrasDiff — GET /api/extras/diff
|
|
func (s *Server) handleExtrasDiff(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
extras := s.extrasConfig()
|
|
projectRoot := s.projectRoot
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
extrasSource := s.cfg.EffectiveExtrasSource()
|
|
var projectExtrasParent string
|
|
if s.IsProjectMode() {
|
|
projectExtrasParent = s.projectCfg.EffectiveExtrasSource(s.projectRoot)
|
|
}
|
|
s.mu.RUnlock()
|
|
|
|
isProjectMode := projectRoot != ""
|
|
|
|
filterName := r.URL.Query().Get("name")
|
|
|
|
out := make([]extrasDiffEntry, 0)
|
|
for _, extra := range extras {
|
|
if filterName != "" && extra.Name != filterName {
|
|
continue
|
|
}
|
|
|
|
var sourceDir string
|
|
if isProjectMode {
|
|
sourceDir = config.ResolveExtrasSourceDirProject(extra, projectExtrasParent, projectRoot)
|
|
} else {
|
|
sourceDir = config.ResolveExtrasSourceDir(extra, extrasSource, source)
|
|
}
|
|
if extra.File != "" {
|
|
out = append(out, extraFileDiffEntries(extra, sourceDir, projectRoot)...)
|
|
continue
|
|
}
|
|
files, err := syncpkg.DiscoverExtraFiles(sourceDir)
|
|
if err != nil {
|
|
// Source doesn't exist — report every target as needing creation
|
|
for _, t := range extra.Targets {
|
|
m := t.Mode
|
|
if m == "" {
|
|
m = "merge"
|
|
}
|
|
out = append(out, extrasDiffEntry{
|
|
Name: extra.Name,
|
|
Target: t.Path,
|
|
Mode: m,
|
|
Synced: false,
|
|
Items: []extrasDiffItem{{Action: "create", File: "*", Reason: "no source directory"}},
|
|
})
|
|
}
|
|
continue
|
|
}
|
|
|
|
for _, t := range extra.Targets {
|
|
m := syncpkg.ExtraTargetMode(t.Mode, extra.File != "")
|
|
// Transform extensions use copy semantics; resolve through the shared
|
|
// resolver so the diff isn't computed against the merge default. On an
|
|
// invalid (non-copy) mode, leave m as-is — sync surfaces that error.
|
|
// Resolve output_ext too, so the diff compares against the transformed
|
|
// target filenames (e.g. .md → .toml) instead of reporting false drift.
|
|
outputExt := ""
|
|
if t.Extension != "" {
|
|
if resolved, modeErr := syncpkg.ResolveExtensionMode(t.Mode); modeErr == nil {
|
|
m = resolved
|
|
}
|
|
if spec, serr := s.resolveExtensionSpec(t.Extension); serr == nil && spec != nil {
|
|
outputExt = spec.OutputExt
|
|
} else if serr != nil {
|
|
log.Printf("warning: extension %q for extra %q could not be resolved (%v); diff may report false drift", t.Extension, extra.Name, serr)
|
|
}
|
|
}
|
|
|
|
targetPath := resolveExtrasTargetPath(projectRoot, t.Path)
|
|
items := buildExtrasDiffItems(files, sourceDir, targetPath, m, t.Flatten, outputExt)
|
|
synced := len(items) == 0
|
|
|
|
out = append(out, extrasDiffEntry{
|
|
Name: extra.Name,
|
|
Target: t.Path,
|
|
Mode: m,
|
|
Synced: synced,
|
|
Items: items,
|
|
})
|
|
}
|
|
}
|
|
|
|
writeJSON(w, map[string]any{"extras": out})
|
|
}
|
|
|
|
// extraFileDiffEntries reports each target of a single-file extra as one item.
|
|
func extraFileDiffEntries(extra config.ExtraConfig, sourceDir, projectRoot string) []extrasDiffEntry {
|
|
var out []extrasDiffEntry
|
|
for _, t := range extra.Targets {
|
|
f := syncpkg.NewExtraFile(sourceDir, extra.File, resolveExtrasTargetPath(projectRoot, t.Path), t.As, t.Mode)
|
|
entry := extrasDiffEntry{Name: extra.Name, Target: t.Path, Mode: f.Mode, Items: []extrasDiffItem{}}
|
|
switch status := syncpkg.ExtraFileStatus(f); status {
|
|
case "synced":
|
|
entry.Synced = true
|
|
case "no source":
|
|
entry.Items = append(entry.Items, extrasDiffItem{Action: "create", File: extra.File, Reason: "no source file"})
|
|
case "not synced":
|
|
entry.Items = append(entry.Items, extrasDiffItem{Action: "create", File: filepath.Base(f.Target), Reason: "missing in target"})
|
|
default:
|
|
entry.Items = append(entry.Items, extrasDiffItem{Action: "update", File: filepath.Base(f.Target), Reason: status})
|
|
}
|
|
out = append(out, entry)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// buildExtrasDiffItems returns the list of files that differ between source and
|
|
// target. When outputExt is non-empty a transform extension is in effect, so
|
|
// the expected target file carries the transformed extension (e.g. foo.md →
|
|
// foo.toml) — matching sync and status, which otherwise reports false drift.
|
|
func buildExtrasDiffItems(sourceFiles []string, sourceDir, targetDir, mode string, flatten bool, outputExt string) []extrasDiffItem {
|
|
var items []extrasDiffItem
|
|
seen := make(map[string]bool)
|
|
|
|
for _, rel := range sourceFiles {
|
|
tgtRel, ok := syncpkg.FlattenRel(rel, flatten, seen)
|
|
if !ok {
|
|
continue
|
|
}
|
|
tgtRel = syncpkg.ApplyOutputExt(tgtRel, outputExt)
|
|
sourceFile := filepath.Join(sourceDir, rel)
|
|
targetFile := filepath.Join(targetDir, tgtRel)
|
|
|
|
info, err := os.Lstat(targetFile)
|
|
if err != nil {
|
|
// Target file missing
|
|
items = append(items, extrasDiffItem{
|
|
Action: "create",
|
|
File: rel,
|
|
Reason: "missing in target",
|
|
})
|
|
continue
|
|
}
|
|
|
|
switch mode {
|
|
case "symlink", "merge":
|
|
if utils.IsLinkMode(targetFile, info.Mode()) {
|
|
link, readErr := os.Readlink(targetFile)
|
|
if readErr != nil || filepath.Clean(resolveExtrasTargetPath(filepath.Dir(targetFile), link)) != filepath.Clean(sourceFile) {
|
|
items = append(items, extrasDiffItem{
|
|
Action: "update",
|
|
File: rel,
|
|
Reason: "symlink target mismatch",
|
|
})
|
|
}
|
|
} else {
|
|
items = append(items, extrasDiffItem{
|
|
Action: "update",
|
|
File: rel,
|
|
Reason: "not a symlink",
|
|
})
|
|
}
|
|
case "copy":
|
|
if !info.Mode().IsRegular() {
|
|
items = append(items, extrasDiffItem{
|
|
Action: "update",
|
|
File: rel,
|
|
Reason: "not a regular file",
|
|
})
|
|
} else if outputExt == "" && !filesEqual(sourceFile, targetFile) {
|
|
items = append(items, extrasDiffItem{
|
|
Action: "update",
|
|
File: rel,
|
|
Reason: "content differs",
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return items
|
|
}
|
|
|
|
func filesEqual(a, b string) bool {
|
|
left, err := os.ReadFile(a)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
right, err := os.ReadFile(b)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return bytes.Equal(left, right)
|
|
}
|
|
|
|
// handleExtrasCreate — POST /api/extras
|
|
func (s *Server) handleExtrasCreate(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
|
|
var body struct {
|
|
Name string `json:"name"`
|
|
Source string `json:"source,omitempty"`
|
|
Folder string `json:"folder,omitempty"` // a folder in the extras directory, shared by several single-file extras
|
|
File string `json:"file,omitempty"` // single-file extra: the file in the source dir
|
|
Targets []struct {
|
|
Path string `json:"path"`
|
|
Mode string `json:"mode"`
|
|
Flatten bool `json:"flatten"`
|
|
Extension string `json:"extension,omitempty"`
|
|
As string `json:"as,omitempty"` // single-file extra: target filename
|
|
} `json:"targets"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
return
|
|
}
|
|
|
|
if err := config.ValidateExtraName(body.Name); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
if len(body.Targets) == 0 {
|
|
writeError(w, http.StatusBadRequest, "at least one target is required")
|
|
return
|
|
}
|
|
if body.Folder != "" && body.Source != "" {
|
|
writeError(w, http.StatusBadRequest, "source and folder cannot both be set")
|
|
return
|
|
}
|
|
if body.Folder == "." || body.Folder == ".." || strings.ContainsAny(body.Folder, `/\`) {
|
|
writeError(w, http.StatusBadRequest, fmt.Sprintf("folder %q must be a plain folder name", body.Folder))
|
|
return
|
|
}
|
|
|
|
// Validate mode and flatten values
|
|
for _, t := range body.Targets {
|
|
if err := config.ValidateExtraMode(t.Mode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if t.Flatten {
|
|
if err := config.ValidateExtraFlatten(true, t.Mode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// Check for duplicate
|
|
if err := config.ValidateExtraNameUnique(body.Name, s.extrasConfig()); err != nil {
|
|
writeError(w, http.StatusConflict, err.Error())
|
|
return
|
|
}
|
|
|
|
// A folder other than the name becomes the source: absolute in global
|
|
// mode, relative to the project root in project mode.
|
|
if body.Folder != "" && body.Folder != body.Name {
|
|
if s.IsProjectMode() {
|
|
dir := filepath.Join(s.projectCfg.EffectiveExtrasSource(s.projectRoot), body.Folder)
|
|
rel, err := filepath.Rel(s.projectRoot, dir)
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
body.Source = filepath.ToSlash(rel)
|
|
} else {
|
|
body.Source = filepath.Join(s.cfg.EffectiveExtrasSource(), body.Folder)
|
|
}
|
|
}
|
|
|
|
// Build ExtraConfig
|
|
extra := config.ExtraConfig{Name: body.Name, Source: body.Source, File: body.File}
|
|
for _, t := range body.Targets {
|
|
et := config.ExtraTargetConfig{Path: t.Path, Flatten: t.Flatten, As: t.As}
|
|
if t.Mode != "" {
|
|
et.Mode = t.Mode
|
|
}
|
|
if t.Extension != "" {
|
|
// A transform extension only makes sense with copy mode.
|
|
et.Extension = t.Extension
|
|
et.Mode = "copy"
|
|
}
|
|
extra.Targets = append(extra.Targets, et)
|
|
}
|
|
if err := config.ValidateExtraConfig(extra); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
// Append to config (extras source resolution is handled by
|
|
// s.cfg.EffectiveExtrasSource() inside s.extrasSourceDir; no backfill needed).
|
|
// The same ownership and import checks add-target runs.
|
|
var validateErr error
|
|
if s.IsProjectMode() {
|
|
prev := s.projectCfg.Extras
|
|
s.projectCfg.Extras = append(slices.Clone(prev), extra)
|
|
if validateErr = s.projectCfg.ValidateExtras(s.projectRoot, extra.Name); validateErr != nil {
|
|
s.projectCfg.Extras = prev
|
|
}
|
|
} else {
|
|
prev := s.cfg.Extras
|
|
s.cfg.Extras = append(slices.Clone(prev), extra)
|
|
if validateErr = s.cfg.ValidateExtras(extra.Name); validateErr != nil {
|
|
s.cfg.Extras = prev
|
|
}
|
|
}
|
|
if validateErr != nil {
|
|
var conflict *config.ExtraTargetConflict
|
|
if errors.As(validateErr, &conflict) {
|
|
writeExtraTargetConflict(w, validateErr, conflict.Target)
|
|
} else {
|
|
writeError(w, http.StatusBadRequest, validateErr.Error())
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := s.saveConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to save config: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Create source directory
|
|
sourceDir := s.extrasSourceDir(extra)
|
|
if err := os.MkdirAll(sourceDir, 0755); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to create source directory: "+err.Error())
|
|
return
|
|
}
|
|
|
|
if err := s.reloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to reload config: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("extras-init", "ok", start, map[string]any{
|
|
"name": body.Name,
|
|
"targets": len(body.Targets),
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": body.Name})
|
|
}
|
|
|
|
type extraTargetSyncResult struct {
|
|
Target string `json:"target"`
|
|
Mode string `json:"mode"`
|
|
Synced int `json:"synced"`
|
|
Skipped int `json:"skipped"`
|
|
Pruned int `json:"pruned"`
|
|
Errors []string `json:"errors,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
Warnings []string `json:"warnings,omitempty"`
|
|
}
|
|
|
|
type extraSyncResult struct {
|
|
Name string `json:"name"`
|
|
Targets []extraTargetSyncResult `json:"targets"`
|
|
}
|
|
|
|
// handleExtrasSync — POST /api/extras/sync
|
|
func (s *Server) handleExtrasSync(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
|
|
var body struct {
|
|
Name string `json:"name"`
|
|
DryRun bool `json:"dry_run"`
|
|
Force bool `json:"force"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil && r.ContentLength > 0 {
|
|
writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.mu.RLock()
|
|
var validationErr error
|
|
if s.IsProjectMode() {
|
|
validationErr = s.projectCfg.ValidateExtras(s.projectRoot)
|
|
} else {
|
|
validationErr = s.cfg.ValidateExtras()
|
|
}
|
|
if validationErr != nil {
|
|
s.mu.RUnlock()
|
|
if !writeExtraTargetConflict(w, validationErr, body.Name) {
|
|
writeError(w, http.StatusBadRequest, validationErr.Error())
|
|
}
|
|
return
|
|
}
|
|
results := s.syncExtras(body.Name, body.DryRun, body.Force)
|
|
s.mu.RUnlock()
|
|
|
|
if body.Name != "" && len(results) == 0 {
|
|
writeError(w, http.StatusNotFound, "extra not found: "+body.Name)
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("extras-sync", "ok", start, map[string]any{
|
|
"name": body.Name,
|
|
"dryRun": body.DryRun,
|
|
"force": body.Force,
|
|
"count": len(results),
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"extras": results})
|
|
}
|
|
|
|
// syncExtras syncs every extra (or only the one named) into its targets.
|
|
// Per-target failures are reported in the results. Callers must hold s.mu.
|
|
func (s *Server) syncExtras(name string, dryRun, force bool) []extraSyncResult {
|
|
projectRoot := s.projectRoot
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
extrasSource := s.cfg.EffectiveExtrasSource()
|
|
var projectExtrasParent string
|
|
if s.IsProjectMode() {
|
|
projectExtrasParent = s.projectCfg.EffectiveExtrasSource(s.projectRoot)
|
|
}
|
|
|
|
results := make([]extraSyncResult, 0)
|
|
|
|
for _, extra := range s.extrasConfig() {
|
|
if name != "" && extra.Name != name {
|
|
continue
|
|
}
|
|
var sourceDir string
|
|
if projectRoot != "" {
|
|
sourceDir = config.ResolveExtrasSourceDirProject(extra, projectExtrasParent, projectRoot)
|
|
} else {
|
|
sourceDir = config.ResolveExtrasSourceDir(extra, extrasSource, source)
|
|
}
|
|
|
|
// Auto-create source directory if it doesn't exist
|
|
if _, statErr := os.Stat(sourceDir); os.IsNotExist(statErr) {
|
|
os.MkdirAll(sourceDir, 0755)
|
|
}
|
|
|
|
result := extraSyncResult{
|
|
Name: extra.Name,
|
|
Targets: make([]extraTargetSyncResult, 0, len(extra.Targets)),
|
|
}
|
|
|
|
for _, t := range extra.Targets {
|
|
m := syncpkg.EffectiveMode(t.Mode)
|
|
|
|
tr := extraTargetSyncResult{
|
|
Target: t.Path,
|
|
Mode: syncpkg.ExtraTargetMode(t.Mode, extra.File != ""),
|
|
Errors: []string{},
|
|
}
|
|
|
|
// Resolve the per-target transform extension (if any) so the UI
|
|
// sync applies it just like the CLI — otherwise files are copied
|
|
// verbatim instead of being transformed (e.g. .md left as .md).
|
|
spec, specErr := s.resolveExtensionSpec(t.Extension)
|
|
if specErr != nil {
|
|
tr.Error = "extension " + t.Extension + ": " + specErr.Error()
|
|
result.Targets = append(result.Targets, tr)
|
|
continue
|
|
}
|
|
|
|
// Transform extensions emit generated files via copy semantics.
|
|
// Resolve through the shared resolver so the CLI, sync, status, and
|
|
// diff paths all enforce one contract (empty/copy → copy, else error).
|
|
if spec != nil {
|
|
resolved, modeErr := syncpkg.ResolveExtensionMode(t.Mode)
|
|
if modeErr != nil {
|
|
tr.Error = "extension " + t.Extension + ": " + modeErr.Error()
|
|
result.Targets = append(result.Targets, tr)
|
|
continue
|
|
}
|
|
m = resolved
|
|
tr.Mode = m
|
|
}
|
|
|
|
targetPath := resolveExtrasTargetPath(projectRoot, t.Path)
|
|
var res *syncpkg.ExtraResult
|
|
var err error
|
|
switch {
|
|
case extra.File == "":
|
|
res, err = syncpkg.SyncExtra(sourceDir, targetPath, m, dryRun, force, t.Flatten, projectRoot, spec)
|
|
case spec != nil:
|
|
err = fmt.Errorf("extensions are not supported for single-file extras")
|
|
default:
|
|
res, err = syncpkg.SyncExtraFile(syncpkg.NewExtraFile(sourceDir, extra.File, targetPath, t.As, m), dryRun, projectRoot)
|
|
}
|
|
if err != nil {
|
|
tr.Error = err.Error()
|
|
} else {
|
|
tr.Synced = res.Synced
|
|
tr.Skipped = res.Skipped
|
|
tr.Pruned = res.Pruned
|
|
tr.Errors = res.Errors
|
|
tr.Warnings = res.Warnings
|
|
if tr.Errors == nil {
|
|
tr.Errors = []string{}
|
|
}
|
|
}
|
|
|
|
result.Targets = append(result.Targets, tr)
|
|
}
|
|
|
|
results = append(results, result)
|
|
}
|
|
|
|
return results
|
|
}
|
|
|
|
// handleExtrasMode — PATCH /api/extras/{name}/mode
|
|
func (s *Server) handleExtrasMode(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
name := r.PathValue("name")
|
|
|
|
var body struct {
|
|
Target string `json:"target"`
|
|
Mode string `json:"mode"`
|
|
Flatten *bool `json:"flatten,omitempty"`
|
|
Extension *string `json:"extension,omitempty"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
return
|
|
}
|
|
|
|
if body.Target == "" {
|
|
writeError(w, http.StatusBadRequest, "target is required")
|
|
return
|
|
}
|
|
if err := config.ValidateExtraMode(body.Mode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
extras := s.extrasConfig()
|
|
|
|
// Find extra and target, update mode and flatten in-place
|
|
found := false
|
|
for i, extra := range extras {
|
|
if extra.Name != name {
|
|
continue
|
|
}
|
|
for j, t := range extra.Targets {
|
|
if t.Path == body.Target {
|
|
// Determine effective mode, flatten, and extension after this change
|
|
newMode := body.Mode
|
|
if newMode == "" {
|
|
newMode = t.Mode
|
|
}
|
|
newFlatten := t.Flatten
|
|
if body.Flatten != nil {
|
|
newFlatten = *body.Flatten
|
|
}
|
|
newExtension := t.Extension
|
|
if body.Extension != nil {
|
|
newExtension = *body.Extension
|
|
}
|
|
|
|
// An extension transform implies copy mode. Reject only a mode
|
|
// explicitly requested in this call that conflicts; otherwise
|
|
// force copy, overriding any prior mode on the target.
|
|
if newExtension != "" {
|
|
if body.Mode != "" && body.Mode != "copy" {
|
|
writeError(w, http.StatusBadRequest, "extension requires copy mode, but mode "+body.Mode+" was set on the target")
|
|
return
|
|
}
|
|
newMode = "copy"
|
|
}
|
|
|
|
// Validate the combination
|
|
if err := config.ValidateExtraFlatten(newFlatten, newMode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if extra.File != "" || newMode == "import" {
|
|
changed := config.ExtraTargetConfig{Path: t.Path, Mode: newMode, Flatten: newFlatten, Extension: newExtension, As: t.As}
|
|
if err := config.ValidateExtraConfig(config.ExtraConfig{Name: extra.Name, File: extra.File, Targets: []config.ExtraTargetConfig{changed}}); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
extras[i].Targets[j].Mode = newMode
|
|
if body.Flatten != nil {
|
|
extras[i].Targets[j].Flatten = *body.Flatten
|
|
}
|
|
if body.Extension != nil {
|
|
extras[i].Targets[j].Extension = *body.Extension
|
|
}
|
|
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
writeError(w, http.StatusNotFound, "target not found: "+body.Target)
|
|
return
|
|
}
|
|
break
|
|
}
|
|
if !found {
|
|
writeError(w, http.StatusNotFound, "extra not found: "+name)
|
|
return
|
|
}
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("extras-mode", "ok", start, map[string]any{
|
|
"name": name,
|
|
"target": body.Target,
|
|
"mode": body.Mode,
|
|
"scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": name, "target": body.Target, "mode": body.Mode})
|
|
}
|
|
|
|
// handleExtrasDelete — DELETE /api/extras/{name}
|
|
func (s *Server) handleExtrasDelete(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
name := r.PathValue("name")
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// Find the extra
|
|
extras := s.extrasConfig()
|
|
idx := -1
|
|
for i, e := range extras {
|
|
if e.Name == name {
|
|
idx = i
|
|
break
|
|
}
|
|
}
|
|
if idx == -1 {
|
|
writeCodedError(w, http.StatusNotFound, "instructions_shared_not_found", "extra not found: "+name, map[string]string{"name": name})
|
|
return
|
|
}
|
|
|
|
removed := extras[idx]
|
|
sourceDir := s.extrasSourceDir(removed)
|
|
|
|
// A single-file extra's targets go back to how they were (as the CLI does).
|
|
projectRoot := s.projectRoot
|
|
restored, restoreErr := syncpkg.RestoreExtraFileTargets(removed, sourceDir, func(p string) string {
|
|
return resolveExtrasTargetPath(projectRoot, p)
|
|
})
|
|
if restoreErr == nil {
|
|
// Remove from config
|
|
if s.IsProjectMode() {
|
|
s.projectCfg.Extras = append(s.projectCfg.Extras[:idx], s.projectCfg.Extras[idx+1:]...)
|
|
} else {
|
|
s.cfg.Extras = append(s.cfg.Extras[:idx], s.cfg.Extras[idx+1:]...)
|
|
}
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeCodedError(w, http.StatusInternalServerError, "instructions_save_failed", err.Error(), map[string]string{"name": name, "detail": err.Error()})
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
status, msg := "ok", ""
|
|
if restoreErr != nil {
|
|
status, msg = "partial", restoreErr.Error()
|
|
}
|
|
s.writeOpsLog("extras-remove", status, start, map[string]any{
|
|
"name": name,
|
|
"restored": restored,
|
|
"scope": "ui",
|
|
}, msg)
|
|
|
|
if restoreErr != nil {
|
|
writeCodedError(w, http.StatusInternalServerError, "instructions_restore_failed", restoreErr.Error(), map[string]string{"name": name, "detail": restoreErr.Error()})
|
|
return
|
|
}
|
|
writeJSON(w, map[string]any{"success": true, "name": name, "restored": restored})
|
|
}
|
|
|
|
// handleExtrasAddTarget — POST /api/extras/{name}/targets
|
|
// Adds a new target to an existing extra. Config-only (no sync).
|
|
func (s *Server) handleExtrasAddTarget(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
name := r.PathValue("name")
|
|
|
|
var body struct {
|
|
Path string `json:"path"`
|
|
Mode string `json:"mode"`
|
|
Flatten bool `json:"flatten"`
|
|
As string `json:"as"` // single-file extra: target filename
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
return
|
|
}
|
|
if body.Path == "" {
|
|
writeError(w, http.StatusBadRequest, "path is required")
|
|
return
|
|
}
|
|
if err := config.ValidateExtraMode(body.Mode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
if err := config.ValidateExtraFlatten(body.Flatten, body.Mode); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
extras := s.extrasConfig()
|
|
idx := -1
|
|
for i := range extras {
|
|
if extras[i].Name == name {
|
|
idx = i
|
|
break
|
|
}
|
|
}
|
|
if idx == -1 {
|
|
writeError(w, http.StatusNotFound, "extra not found: "+name)
|
|
return
|
|
}
|
|
newPath := filepath.Clean(resolveExtrasTargetPath(s.projectRoot, body.Path))
|
|
for _, t := range extras[idx].Targets {
|
|
if filepath.Clean(resolveExtrasTargetPath(s.projectRoot, t.Path)) == newPath {
|
|
writeError(w, http.StatusConflict, "target already exists: "+body.Path)
|
|
return
|
|
}
|
|
}
|
|
|
|
storedPath := body.Path
|
|
if !s.IsProjectMode() {
|
|
storedPath = newPath
|
|
}
|
|
et := config.ExtraTargetConfig{Path: storedPath, Flatten: body.Flatten, As: body.As}
|
|
if body.Mode != "" {
|
|
et.Mode = body.Mode
|
|
}
|
|
if err := config.ValidateExtraConfig(config.ExtraConfig{Name: name, File: extras[idx].File, Targets: []config.ExtraTargetConfig{et}}); err != nil {
|
|
writeError(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
prev := extras[idx].Targets
|
|
extras[idx].Targets = append(slices.Clone(prev), et)
|
|
|
|
// The same ownership and import checks the CLI runs after --add-target.
|
|
var validateErr error
|
|
if s.IsProjectMode() {
|
|
validateErr = s.projectCfg.ValidateExtras(s.projectRoot, name)
|
|
} else {
|
|
validateErr = s.cfg.ValidateExtras(name)
|
|
}
|
|
if validateErr != nil {
|
|
extras[idx].Targets = prev
|
|
if !writeExtraTargetConflict(w, validateErr, body.Path) {
|
|
writeError(w, http.StatusBadRequest, validateErr.Error())
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("extras-target", "ok", start, map[string]any{
|
|
"name": name, "target": body.Path, "action": "add", "scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": name, "target": body.Path})
|
|
}
|
|
|
|
// handleExtrasRemoveTarget — DELETE /api/extras/{name}/targets
|
|
// Removes one target from an existing extra. For a directory extra it is
|
|
// config-only; a single-file extra's target is restored first (its link or
|
|
// import line goes and the file it replaced comes back), like --prune.
|
|
func (s *Server) handleExtrasRemoveTarget(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
name := r.PathValue("name")
|
|
|
|
var body struct {
|
|
Path string `json:"path"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body")
|
|
return
|
|
}
|
|
if body.Path == "" {
|
|
writeError(w, http.StatusBadRequest, "path is required")
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
extras := s.extrasConfig()
|
|
idx := -1
|
|
for i := range extras {
|
|
if extras[i].Name == name {
|
|
idx = i
|
|
break
|
|
}
|
|
}
|
|
if idx == -1 {
|
|
writeError(w, http.StatusNotFound, "extra not found: "+name)
|
|
return
|
|
}
|
|
tIdx := -1
|
|
for j, t := range extras[idx].Targets {
|
|
if t.Path == body.Path {
|
|
tIdx = j
|
|
break
|
|
}
|
|
}
|
|
if tIdx == -1 {
|
|
writeError(w, http.StatusNotFound, "target not found: "+body.Path)
|
|
return
|
|
}
|
|
if len(extras[idx].Targets) == 1 && extras[idx].File == "" {
|
|
writeError(w, http.StatusBadRequest, "cannot remove the last target; delete the extra instead")
|
|
return
|
|
}
|
|
|
|
if extra := extras[idx]; extra.File != "" {
|
|
t := extra.Targets[tIdx]
|
|
f := syncpkg.NewExtraFile(s.extrasSourceDir(extra), extra.File, resolveExtrasTargetPath(s.projectRoot, t.Path), t.As, t.Mode)
|
|
if _, err := syncpkg.RestoreExtraTarget(f); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to restore target: "+err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
extras[idx].Targets = append(extras[idx].Targets[:tIdx], extras[idx].Targets[tIdx+1:]...)
|
|
|
|
if err := s.saveAndReloadConfig(); err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("extras-target", "ok", start, map[string]any{
|
|
"name": name, "target": body.Path, "action": "remove", "scope": "ui",
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{"success": true, "name": name, "target": body.Path})
|
|
}
|