diff --git a/internal/server/handler_extras.go b/internal/server/handler_extras.go new file mode 100644 index 000000000..f2615d9dc --- /dev/null +++ b/internal/server/handler_extras.go @@ -0,0 +1,477 @@ +package server + +import ( + "encoding/json" + "net/http" + "os" + "path/filepath" + "time" + + "skillshare/internal/config" + syncpkg "skillshare/internal/sync" +) + +// extrasListEntry is the JSON response shape for a single extra. +type extrasListEntry struct { + Name string `json:"name"` + SourceDir string `json:"source_dir"` + 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"` + Status string `json:"status"` // "synced", "drift", "not synced", "no source" +} + +// extrasSourceDir returns the source directory for the named extra in the +// current mode. +func (s *Server) extrasSourceDir(name string) string { + if s.IsProjectMode() { + return config.ExtrasSourceDirProject(s.projectRoot, name) + } + return config.ExtrasSourceDir(s.cfg.Source, name) +} + +// 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 +} + +// handleExtras — GET /api/extras +func (s *Server) handleExtras(w http.ResponseWriter, r *http.Request) { + extras := s.extrasConfig() + + entries := make([]extrasListEntry, 0, len(extras)) + for _, extra := range extras { + sourceDir := s.extrasSourceDir(extra.Name) + entry := extrasListEntry{ + Name: extra.Name, + SourceDir: sourceDir, + } + + files, err := syncpkg.DiscoverExtraFiles(sourceDir) + 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 := t.Mode + if m == "" { + m = "merge" + } + ti := extrasTargetInfo{ + Path: t.Path, + Mode: m, + } + + if !entry.SourceExists { + ti.Status = "no source" + } else if _, statErr := os.Stat(t.Path); os.IsNotExist(statErr) { + ti.Status = "not synced" + } else { + ti.Status = checkExtrasSyncStatus(files, sourceDir, t.Path, m) + } + + entry.Targets = append(entry.Targets, ti) + } + + entries = append(entries, entry) + } + + writeJSON(w, map[string]any{"extras": entries}) +} + +// 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) { + filterName := r.URL.Query().Get("name") + extras := s.extrasConfig() + + out := make([]extrasDiffEntry, 0) + for _, extra := range extras { + if filterName != "" && extra.Name != filterName { + continue + } + + sourceDir := s.extrasSourceDir(extra.Name) + 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 := t.Mode + if m == "" { + m = "merge" + } + + items := buildExtrasDiffItems(files, sourceDir, t.Path, m) + 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}) +} + +// buildExtrasDiffItems returns the list of files that differ between source and target. +func buildExtrasDiffItems(sourceFiles []string, sourceDir, targetDir, mode string) []extrasDiffItem { + var items []extrasDiffItem + + for _, rel := range sourceFiles { + sourceFile := filepath.Join(sourceDir, rel) + targetFile := filepath.Join(targetDir, rel) + + 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 info.Mode()&os.ModeSymlink != 0 { + link, readErr := os.Readlink(targetFile) + if readErr != nil || link != 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", + }) + } + } + } + + return items +} + +// handleExtrasCreate — POST /api/extras +func (s *Server) handleExtrasCreate(w http.ResponseWriter, r *http.Request) { + start := time.Now() + + var body struct { + Name string `json:"name"` + Targets []struct { + Path string `json:"path"` + Mode string `json:"mode"` + } `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 values + for _, t := range body.Targets { + if t.Mode != "" && t.Mode != "merge" && t.Mode != "copy" && t.Mode != "symlink" { + writeError(w, http.StatusBadRequest, "invalid mode "+t.Mode+": must be merge, copy, or symlink") + 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} + for _, t := range body.Targets { + et := config.ExtraTargetConfig{Path: t.Path} + if t.Mode != "" { + et.Mode = t.Mode + } + extra.Targets = append(extra.Targets, et) + } + + // Append to config + 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(body.Name) + 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}) +} + +// 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 { + // Use defaults (empty name = all, dryRun=false, force=false) + } + + extras := s.extrasConfig() + + type targetSyncResult 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"` + } + type extraSyncResult struct { + Name string `json:"name"` + Targets []targetSyncResult `json:"targets"` + } + + results := make([]extraSyncResult, 0) + + for _, extra := range extras { + if body.Name != "" && extra.Name != body.Name { + continue + } + + sourceDir := s.extrasSourceDir(extra.Name) + result := extraSyncResult{ + Name: extra.Name, + Targets: make([]targetSyncResult, 0, len(extra.Targets)), + } + + for _, t := range extra.Targets { + m := t.Mode + if m == "" { + m = "merge" + } + + tr := targetSyncResult{ + Target: t.Path, + Mode: m, + Errors: []string{}, + } + + res, err := syncpkg.SyncExtra(sourceDir, t.Path, m, body.DryRun, body.Force) + if err != nil { + tr.Error = err.Error() + } else { + tr.Synced = res.Synced + tr.Skipped = res.Skipped + tr.Pruned = res.Pruned + tr.Errors = res.Errors + if tr.Errors == nil { + tr.Errors = []string{} + } + } + + result.Targets = append(result.Targets, tr) + } + + results = append(results, result) + } + + 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{"results": results}) +} + +// 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 + } + + // 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.saveConfig(); err != nil { + writeError(w, http.StatusInternalServerError, "failed to save config: "+err.Error()) + return + } + + if err := s.reloadConfig(); err != nil { + writeError(w, http.StatusInternalServerError, "failed to reload config: "+err.Error()) + return + } + + s.writeOpsLog("extras-remove", "ok", start, map[string]any{ + "name": name, + "scope": "ui", + }, "") + + writeJSON(w, map[string]any{"success": true, "name": name}) +} + +// checkExtrasSyncStatus mirrors the same function in cmd/skillshare/extras_list.go. +// It compares source files against the target directory and returns a status string. +func checkExtrasSyncStatus(sourceFiles []string, sourceDir, targetDir, mode string) string { + allSynced := true + for _, rel := range sourceFiles { + targetFile := filepath.Join(targetDir, rel) + sourceFile := filepath.Join(sourceDir, rel) + + tInfo, err := os.Lstat(targetFile) + if err != nil { + allSynced = false + break + } + + switch mode { + case "symlink", "merge": + if tInfo.Mode()&os.ModeSymlink != 0 { + link, readErr := os.Readlink(targetFile) + if readErr != nil || link != sourceFile { + allSynced = false + } + } else { + allSynced = false + } + case "copy": + if !tInfo.Mode().IsRegular() { + allSynced = false + } + } + + if !allSynced { + break + } + } + + if allSynced { + return "synced" + } + return "drift" +} diff --git a/internal/server/server.go b/internal/server/server.go index 6d34a11df..2184f81db 100644 --- a/internal/server/server.go +++ b/internal/server/server.go @@ -300,6 +300,13 @@ func (s *Server) registerRoutes() { s.mux.HandleFunc("DELETE /api/trash/{name}", s.handleDeleteTrash) s.mux.HandleFunc("POST /api/trash/empty", s.handleEmptyTrash) + // Extras + s.mux.HandleFunc("GET /api/extras", s.handleExtras) + 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("DELETE /api/extras/{name}", s.handleExtrasDelete) + // Git s.mux.HandleFunc("GET /api/git/status", s.handleGitStatus) s.mux.HandleFunc("POST /api/push", s.handlePush)