Files
skillshare/internal/server/handler_extras.go
T
Willie c7eb59a78f fix(sync): stop linking single files with junctions on Windows
createLink always tried `mklink /J` first. mklink does not check the
source type, so agents, single-file extras such as a shared AGENTS.md, and
per-file extras links became directory junctions that point at a file:
Explorer shows a folder and tools cannot read it. Sync then compared only
the link destination and kept the broken junction forever.

Files now get real symlinks only. When the OS cannot create them (Windows
without Developer Mode, non-elevated), file-based link modes fall back to
copies at the mode level, so status, doctor, the API and later syncs all
see an effective `copy` mode. Fallback copies are tracked by hash so they
keep updating and pruning without touching the user's own files, and turn
back into links once links work. Single-file extras remember what they last
wrote, so an unedited copy is replaced silently instead of producing a
drift backup on every source edit, and switching a target back to import
restores the user's attach-time content plus the import block.

Includes a Windows runbook and script, verified on a Windows 11 ARM64 VM
with and without symlink rights.

Refs #299
2026-09-28 13:54:52 +08:00

996 lines
30 KiB
Go

package server
import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
"os"
"path/filepath"
"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.ExtrasSourceDirProject(s.projectCfg.EffectiveExtrasSource(s.projectRoot), extra.Name)
}
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.ExtrasSourceDirProject(projectExtrasParent, extra.Name)
} 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.ExtrasSourceDirProject(projectExtrasParent, extra.Name)
} 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"`
Targets []struct {
Path string `json:"path"`
Mode string `json:"mode"`
Flatten bool `json:"flatten"`
Extension string `json:"extension,omitempty"`
} `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
}
// 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
}
// Build ExtraConfig
extra := config.ExtraConfig{Name: body.Name, Source: body.Source}
for _, t := range body.Targets {
et := config.ExtraTargetConfig{Path: t.Path, Flatten: t.Flatten}
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).
if s.IsProjectMode() {
s.projectCfg.Extras = append(s.projectCfg.Extras, extra)
} else {
s.cfg.Extras = append(s.cfg.Extras, extra)
}
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()
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.ExtrasSourceDirProject(projectExtrasParent, extra.Name)
} 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 {
writeError(w, http.StatusNotFound, "extra not found: "+name)
return
}
removed := extras[idx]
sourceDir := s.extrasSourceDir(removed)
// 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 {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
// 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)
})
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 {
writeError(w, http.StatusInternalServerError, 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"`
}
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}
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
}
extras[idx].Targets = append(extras[idx].Targets, et)
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})
}