diff --git a/.devcontainer/bin/ui b/.devcontainer/bin/ui index 193b549f8..0f0d27da4 100755 --- a/.devcontainer/bin/ui +++ b/.devcontainer/bin/ui @@ -158,7 +158,7 @@ for p in "$(go env GOPATH)/bin/air" /go/bin/air /usr/local/go/bin/air; do done if [ -z "$AIR_BIN" ]; then echo " air not found — installing..." >&2 - go install github.com/air-verse/air@v1.67.0 # v1.67.3+ needs go >= 1.26 + go install github.com/air-verse/air@v1.67.1 # v1.67.2+ needs go >= 1.26 AIR_BIN="$(go env GOPATH)/bin/air" fi diff --git a/cmd/skillshare/backup.go b/cmd/skillshare/backup.go index 43a80eaa9..a84184981 100644 --- a/cmd/skillshare/backup.go +++ b/cmd/skillshare/backup.go @@ -319,15 +319,17 @@ func planBackupCleanup(backups []backup.BackupInfo, cfg backup.CleanupConfig, no } size := backup.Size(backupInfo.Path) - totalSize += size - if cfg.MaxSizeMB > 0 && totalSize > cfg.MaxSizeMB*1024*1024 { + if !shouldRemove && cfg.MaxSizeMB > 0 && i > 0 && + totalSize+size > cfg.MaxSizeMB*1024*1024 { shouldRemove = true } if shouldRemove { removed++ removedSize += size + continue } + totalSize += size } return removed, removedSize diff --git a/cmd/skillshare/backup_test.go b/cmd/skillshare/backup_test.go new file mode 100644 index 000000000..bf84f0b73 --- /dev/null +++ b/cmd/skillshare/backup_test.go @@ -0,0 +1,63 @@ +package main + +import ( + "os" + "path/filepath" + "testing" + "time" + + "skillshare/internal/backup" +) + +func TestPlanBackupCleanup_OverSizeCapKeepsNewestBackup(t *testing.T) { + backupPath := filepath.Join(t.TempDir(), "2026-07-30_00-00-00") + if err := os.MkdirAll(filepath.Join(backupPath, "claude"), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(backupPath, "claude", "big.bin"), make([]byte, 2<<20), 0644); err != nil { + t.Fatal(err) + } + + backups := []backup.BackupInfo{{ + Timestamp: "2026-07-30_00-00-00", + Path: backupPath, + Date: time.Now(), + }} + removed, freed := planBackupCleanup(backups, backup.CleanupConfig{MaxSizeMB: 1}, time.Now()) + + if removed != 0 { + t.Errorf("removed = %d, want 0", removed) + } + if freed != 0 { + t.Errorf("freed = %d, want 0", freed) + } +} + +func TestPlanBackupCleanup_SizeCapCountsOnlyRetainedBackups(t *testing.T) { + root := t.TempDir() + sizes := []int{400 << 10, 700 << 10, 400 << 10} + backups := make([]backup.BackupInfo, 0, len(sizes)) + + for i, size := range sizes { + path := filepath.Join(root, time.Now().Add(-time.Duration(i)*time.Hour).Format("2006-01-02_15-04-05")) + if err := os.MkdirAll(filepath.Join(path, "claude"), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(path, "claude", "payload.bin"), make([]byte, size), 0644); err != nil { + t.Fatal(err) + } + backups = append(backups, backup.BackupInfo{ + Timestamp: filepath.Base(path), + Path: path, + Date: time.Now().Add(-time.Duration(i) * time.Hour), + }) + } + + removed, freed := planBackupCleanup(backups, backup.CleanupConfig{MaxSizeMB: 1}, time.Now()) + if removed != 1 { + t.Errorf("removed = %d, want 1", removed) + } + if freed != int64(sizes[1]) { + t.Errorf("freed = %d, want %d", freed, sizes[1]) + } +} diff --git a/cmd/skillshare/doctor.go b/cmd/skillshare/doctor.go index f008673b9..8b20bdebb 100644 --- a/cmd/skillshare/doctor.go +++ b/cmd/skillshare/doctor.go @@ -487,7 +487,7 @@ func checkTargets(cfg *config.Config, result *doctorResult, isProject bool) map[ result.addWarning() } - targetIssues := checkTargetIssues(target, cfg.EffectiveSkillsSource()) + targetIssues := checkTargetIssues(target, cfg.EffectiveSkillsSource(), mode) // Target name header fmt.Printf("%s%s%s\n", ui.Bold, name, ui.Reset) @@ -519,7 +519,7 @@ func checkTargets(cfg *config.Config, result *doctorResult, isProject bool) map[ return cache } -func checkTargetIssues(target config.TargetConfig, source string) []string { +func checkTargetIssues(target config.TargetConfig, source, mode string) []string { sc := target.SkillsConfig() var targetIssues []string @@ -539,7 +539,7 @@ func checkTargetIssues(target config.TargetConfig, source string) []string { // Check if it's a symlink. Relative links must resolve against the link's // parent directory, not the current working directory. - if info.Mode()&os.ModeSymlink != 0 { + if mode == "symlink" && info.Mode()&os.ModeSymlink != 0 { link, _ := os.Readlink(sc.Path) absLink, err := utils.ResolveLinkTarget(sc.Path) absSource, _ := filepath.Abs(source) @@ -1017,7 +1017,7 @@ func checkDuplicateSkills(cfg *config.Config, result *doctorResult, discovered [ // The target dir is itself a link (symlink mode after sync), so its // entries are the source itself, not target-local copies. - if utils.IsSymlinkOrJunction(sc.Path) { + if mode == "symlink" && utils.IsSymlinkOrJunction(sc.Path) { continue } diff --git a/cmd/skillshare/list.go b/cmd/skillshare/list.go index d52c6cd01..9e0a29d51 100644 --- a/cmd/skillshare/list.go +++ b/cmd/skillshare/list.go @@ -28,7 +28,7 @@ type listOptions struct { Pattern string // positional search pattern (case-insensitive) TypeFilter string // --type: "tracked", "local", "github" SortBy string // --sort: "name" (default), "newest", "oldest" - Status string // --status: "" (all), "enabled", "disabled" + Status listStatusFilter } // validTypeFilters lists accepted values for --type. @@ -45,25 +45,21 @@ var validSortOptions = map[string]bool{ "oldest": true, } -// validStatusFilters lists accepted values for --status. -var validStatusFilters = map[string]bool{ - "all": true, - "enabled": true, - "disabled": true, +// validStatusFilters maps accepted --status values to their typed filter. +var validStatusFilters = map[string]listStatusFilter{ + "all": statusFilterAll, + "enabled": statusFilterEnabled, + "disabled": statusFilterDisabled, } // parseStatusFilter validates a --status value and normalizes it. -// "all" normalizes to "" so it stays equivalent to omitting the flag — -// no filter applied, tracked-repo summary and footer unchanged. -func parseStatusFilter(raw string) (string, error) { +func parseStatusFilter(raw string) (listStatusFilter, error) { v := strings.ToLower(raw) - if !validStatusFilters[v] { - return "", fmt.Errorf("invalid status %q: must be all, enabled, or disabled", raw) + status, ok := validStatusFilters[v] + if !ok { + return statusFilterAll, fmt.Errorf("invalid status %q: must be all, enabled, or disabled", raw) } - if v == "all" { - return "", nil - } - return v, nil + return status, nil } // parseListArgs parses list command arguments into listOptions. @@ -157,9 +153,9 @@ func parseListArgs(args []string) (listOptions, error) { // filterSkillEntries filters skills by pattern, type, and status. // Pattern matches case-insensitively against Name, RelPath, and Source. -// Status is "" (no filter), "enabled", or "disabled"; filters combine with AND. -func filterSkillEntries(skills []skillEntry, pattern, typeFilter, status string) []skillEntry { - if pattern == "" && typeFilter == "" && status == "" { +// Status uses statusFilterAll for no filter; filters combine with AND. +func filterSkillEntries(skills []skillEntry, pattern, typeFilter string, status listStatusFilter) []skillEntry { + if pattern == "" && typeFilter == "" && status == statusFilterAll { return skills } @@ -167,7 +163,7 @@ func filterSkillEntries(skills []skillEntry, pattern, typeFilter, status string) var result []skillEntry for _, s := range skills { // Status filter - if status != "" && s.Disabled != (status == "disabled") { + if status != statusFilterAll && s.Disabled != (status == statusFilterDisabled) { continue } @@ -208,11 +204,11 @@ func filterSkillEntries(skills []skillEntry, pattern, typeFilter, status string) // statusNote returns a " (status: enabled)" suffix for footers and messages, // or "" when no status filter is active. -func statusNote(status string) string { - if status == "" { +func statusNote(status listStatusFilter) string { + if status == statusFilterAll { return "" } - return fmt.Sprintf(" (status: %s)", status) + return fmt.Sprintf(" (status: %s)", status.String()) } // noMatchMessage builds the "no results" message for the active filter set. @@ -225,7 +221,7 @@ func noMatchMessage(resourceLabel string, opts listOptions) string { case opts.TypeFilter != "": return fmt.Sprintf("No %s matching type %q%s", resourceLabel, opts.TypeFilter, statusNote(opts.Status)) default: - return fmt.Sprintf("No %s matching status %q", resourceLabel, opts.Status) + return fmt.Sprintf("No %s matching status %q", resourceLabel, opts.Status.String()) } } @@ -677,14 +673,14 @@ func cmdList(args []string) error { total := len(allEntries) // Status is NOT filtered here — the TUI needs both enabled and // disabled entries loaded so the `s` key can restore them. - allEntries = filterSkillEntries(allEntries, opts.Pattern, opts.TypeFilter, "") + allEntries = filterSkillEntries(allEntries, opts.Pattern, opts.TypeFilter, statusFilterAll) // Always sort: buildGroupedItems relies on contiguous top-group // blocks, which the default sort guarantees (tracked → named // locals → standalone). sortSkillEntries(allEntries, opts.SortBy) return listLoadResult{skills: toSkillItems(allEntries), totalCount: total} } - action, skillName, skillKind, err := runListTUI(loadFn, "global", cfg.EffectiveSkillsSource(), cfg.EffectiveAgentsSource(), cfg.Targets, kind, statusFilterFrom(opts.Status)) + action, skillName, skillKind, err := runListTUI(loadFn, "global", cfg.EffectiveSkillsSource(), cfg.EffectiveAgentsSource(), cfg.Targets, kind, opts.Status) if err != nil { return err } @@ -757,7 +753,7 @@ func cmdList(args []string) error { sp.Success(fmt.Sprintf("Loaded %d %s", len(allEntries), resourceLabel)) } totalCount := len(allEntries) - hasFilter := opts.Pattern != "" || opts.TypeFilter != "" || opts.Status != "" + hasFilter := opts.Pattern != "" || opts.TypeFilter != "" || opts.Status != statusFilterAll // Apply filter and sort allEntries = filterSkillEntries(allEntries, opts.Pattern, opts.TypeFilter, opts.Status) diff --git a/cmd/skillshare/list_project.go b/cmd/skillshare/list_project.go index af3bd6424..d4914a8a9 100644 --- a/cmd/skillshare/list_project.go +++ b/cmd/skillshare/list_project.go @@ -54,11 +54,11 @@ func cmdListProject(root string, opts listOptions, kind resourceKindFilter) erro total := len(allEntries) // Status is NOT filtered here — the TUI needs both enabled and // disabled entries loaded so the `s` key can restore them. - allEntries = filterSkillEntries(allEntries, opts.Pattern, opts.TypeFilter, "") + allEntries = filterSkillEntries(allEntries, opts.Pattern, opts.TypeFilter, statusFilterAll) sortSkillEntries(allEntries, sortBy) return listLoadResult{skills: toSkillItems(allEntries), totalCount: total} } - action, skillName, skillKind, err := runListTUI(loadFn, "project", skillsSource, agentsSource, targets, kind, statusFilterFrom(opts.Status)) + action, skillName, skillKind, err := runListTUI(loadFn, "project", skillsSource, agentsSource, targets, kind, opts.Status) if err != nil { return err } @@ -124,7 +124,7 @@ func cmdListProject(root string, opts listOptions, kind resourceKindFilter) erro sp.Success(fmt.Sprintf("Loaded %d %s", len(allEntries), resourceLabel)) } totalCount := len(allEntries) - hasFilter := opts.Pattern != "" || opts.TypeFilter != "" || opts.Status != "" + hasFilter := opts.Pattern != "" || opts.TypeFilter != "" || opts.Status != statusFilterAll // Apply filter and sort allEntries = filterSkillEntries(allEntries, opts.Pattern, opts.TypeFilter, opts.Status) diff --git a/cmd/skillshare/list_test.go b/cmd/skillshare/list_test.go index 3b11d514a..50aad4f19 100644 --- a/cmd/skillshare/list_test.go +++ b/cmd/skillshare/list_test.go @@ -6,14 +6,14 @@ func TestParseListArgs_Status(t *testing.T) { tests := []struct { name string args []string - want string + want listStatusFilter }{ - {"space form", []string{"--status", "enabled"}, "enabled"}, - {"equals form", []string{"--status=disabled"}, "disabled"}, - {"case insensitive", []string{"--status", "DISABLED"}, "disabled"}, - {"all normalizes to empty", []string{"--status", "all"}, ""}, - {"all equals form", []string{"--status=ALL"}, ""}, - {"absent", []string{}, ""}, + {"space form", []string{"--status", "enabled"}, statusFilterEnabled}, + {"equals form", []string{"--status=disabled"}, statusFilterDisabled}, + {"case insensitive", []string{"--status", "DISABLED"}, statusFilterDisabled}, + {"all", []string{"--status", "all"}, statusFilterAll}, + {"all equals form", []string{"--status=ALL"}, statusFilterAll}, + {"absent", []string{}, statusFilterAll}, } for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { @@ -46,7 +46,7 @@ func TestParseListArgs_StatusCombinesWithOtherFilters(t *testing.T) { if err != nil { t.Fatalf("parseListArgs error = %v", err) } - if opts.Pattern != "react" || opts.TypeFilter != "local" || opts.Status != "disabled" || opts.SortBy != "newest" { + if opts.Pattern != "react" || opts.TypeFilter != "local" || opts.Status != statusFilterDisabled || opts.SortBy != "newest" { t.Errorf("got %+v, want pattern=react type=local status=disabled sort=newest", opts) } } @@ -59,12 +59,12 @@ func TestFilterSkillEntries_Status(t *testing.T) { } tests := []struct { - status string + status listStatusFilter want []string }{ - {"", []string{"on-a", "off-a", "on-b"}}, - {"enabled", []string{"on-a", "on-b"}}, - {"disabled", []string{"off-a"}}, + {statusFilterAll, []string{"on-a", "off-a", "on-b"}}, + {statusFilterEnabled, []string{"on-a", "on-b"}}, + {statusFilterDisabled, []string{"off-a"}}, } for _, tc := range tests { got := filterSkillEntries(entries, "", "", tc.status) @@ -86,14 +86,14 @@ func TestFilterSkillEntries_StatusAndPatternAreAND(t *testing.T) { {Name: "vue-off", RelPath: "vue-off", Disabled: true}, } - got := filterSkillEntries(entries, "react", "", "disabled") + got := filterSkillEntries(entries, "react", "", statusFilterDisabled) if len(got) != 1 || got[0].Name != "react-off" { t.Fatalf("got %+v, want only react-off", got) } } func TestNoMatchMessage_StatusOnly(t *testing.T) { - got := noMatchMessage("skills", listOptions{Status: "disabled"}) + got := noMatchMessage("skills", listOptions{Status: statusFilterDisabled}) want := `No skills matching status "disabled"` if got != want { t.Errorf("got %q, want %q", got, want) @@ -101,25 +101,25 @@ func TestNoMatchMessage_StatusOnly(t *testing.T) { } func TestNoMatchMessage_StatusWithOtherFilters(t *testing.T) { - got := noMatchMessage("agents", listOptions{Pattern: "react", Status: "enabled"}) + got := noMatchMessage("agents", listOptions{Pattern: "react", Status: statusFilterEnabled}) want := `No agents matching "react" (status: enabled)` if got != want { t.Errorf("got %q, want %q", got, want) } } -func TestStatusFilterFrom(t *testing.T) { +func TestListStatusFilterString(t *testing.T) { tests := []struct { - status string - want listStatusFilter + status listStatusFilter + want string }{ - {"", statusFilterAll}, - {"enabled", statusFilterEnabled}, - {"disabled", statusFilterDisabled}, + {statusFilterAll, "all"}, + {statusFilterEnabled, "enabled"}, + {statusFilterDisabled, "disabled"}, } for _, tc := range tests { - if got := statusFilterFrom(tc.status); got != tc.want { - t.Errorf("statusFilterFrom(%q) = %v, want %v", tc.status, got, tc.want) + if got := tc.status.String(); got != tc.want { + t.Errorf("%v.String() = %q, want %q", tc.status, got, tc.want) } } } @@ -127,7 +127,7 @@ func TestStatusFilterFrom(t *testing.T) { // The `s` key cycles All → Enabled → Disabled → All from whatever --status // seeded, so an initial filter never traps the user. func TestStatusFilterCyclesBackToAll(t *testing.T) { - s := statusFilterFrom("disabled") + s := statusFilterDisabled if next := (s + 1) % 3; next != statusFilterAll { t.Errorf("cycling from Disabled = %v, want All", next) } diff --git a/cmd/skillshare/list_tui.go b/cmd/skillshare/list_tui.go index ee26b8a28..53a5ae822 100644 --- a/cmd/skillshare/list_tui.go +++ b/cmd/skillshare/list_tui.go @@ -43,16 +43,15 @@ const ( statusFilterDisabled // show only disabled ) -// statusFilterFrom maps a --status option value to the TUI's initial filter. -// An empty value (or "all") starts on statusFilterAll. -func statusFilterFrom(status string) listStatusFilter { - switch status { - case "enabled": - return statusFilterEnabled - case "disabled": - return statusFilterDisabled +// String returns the CLI representation of the status filter. +func (s listStatusFilter) String() string { + switch s { + case statusFilterEnabled: + return "enabled" + case statusFilterDisabled: + return "disabled" default: - return statusFilterAll + return "all" } } diff --git a/cmd/skillshare/sync.go b/cmd/skillshare/sync.go index a7e5c6c5c..29ba6ead0 100644 --- a/cmd/skillshare/sync.go +++ b/cmd/skillshare/sync.go @@ -449,7 +449,11 @@ func syncOutputJSON(results []syncTargetResult, dryRun bool, start time.Time, iS func backupTargetsBeforeSync(cfg *config.Config) { // Pre-sync backups are automatic, so retention must be too — otherwise // every sync adds a snapshot that nothing ever removes. - defer backup.Cleanup(backup.DefaultCleanupConfig()) + defer func() { + if _, err := backup.Cleanup(backup.DefaultCleanupConfig()); err != nil { + ui.Warning("Failed to clean up old backups: %v", err) + } + }() backedUp := false for name, target := range cfg.Targets { @@ -467,7 +471,11 @@ func backupTargetsBeforeSync(cfg *config.Config) { // Also backup agent targets if any exist. backupDir, agentTargets, err := resolveGlobalAgentBackupContextFromCfg(cfg) - if err != nil || len(agentTargets) == 0 { + if err != nil { + ui.Warning("Failed to resolve agent backup targets: %v", err) + return + } + if len(agentTargets) == 0 { return } for _, at := range agentTargets { diff --git a/cmd/skillshare/sync_agents.go b/cmd/skillshare/sync_agents.go index 5923e6d7c..0c5480b11 100644 --- a/cmd/skillshare/sync_agents.go +++ b/cmd/skillshare/sync_agents.go @@ -55,8 +55,17 @@ func syncAgentsGlobal(cfg *config.Config, dryRun, force, jsonOutput bool, start // Backup agent targets before sync (non-dry-run only). if !dryRun && !jsonOutput { - backupDir, agentTargets, _ := resolveGlobalAgentBackupContextFromCfg(cfg) - defer backup.CleanupInDir(backupDir, backup.DefaultCleanupConfig()) + backupDir, agentTargets, backupErr := resolveGlobalAgentBackupContextFromCfg(cfg) + if backupErr != nil { + ui.Warning("Failed to resolve agent backup targets: %v", backupErr) + agentTargets = nil + } else { + defer func() { + if _, err := backup.CleanupInDir(backupDir, backup.DefaultCleanupConfig()); err != nil { + ui.Warning("Failed to clean up old agent backups: %v", err) + } + }() + } backedUp := false for _, at := range agentTargets { entryName := at.name + "-agents" @@ -184,7 +193,11 @@ func syncAgentsProject(projectRoot string, dryRun, force, jsonOutput bool, start // Backup agent targets before sync (non-dry-run only). if !dryRun && !jsonOutput { backupDir := filepath.Join(projectRoot, ".skillshare", "backups") - defer backup.CleanupInDir(backupDir, backup.DefaultCleanupConfig()) + defer func() { + if _, err := backup.CleanupInDir(backupDir, backup.DefaultCleanupConfig()); err != nil { + ui.Warning("Failed to clean up old project agent backups: %v", err) + } + }() backedUp := false for _, entry := range projCfg.Targets { agentPath := resolveProjectAgentTargetPath(entry, builtinAgents, projectRoot) diff --git a/docker/sandbox/Dockerfile b/docker/sandbox/Dockerfile index cd016f153..1bcc07978 100644 --- a/docker/sandbox/Dockerfile +++ b/docker/sandbox/Dockerfile @@ -26,8 +26,8 @@ RUN apt-get update \ && rm -rf /var/lib/apt/lists/* # Install Go development tools -# air pinned: v1.67.3+ requires go >= 1.26, image runs GO_VERSION with GOTOOLCHAIN=local -RUN go install github.com/air-verse/air@v1.67.0 \ +# air pinned: v1.67.2+ requires go >= 1.26, image runs GO_VERSION with GOTOOLCHAIN=local +RUN go install github.com/air-verse/air@v1.67.1 \ && go install github.com/go-delve/delve/cmd/dlv@latest # Copy node runtime from ui-builder stage (for devcontainer / interactive use) diff --git a/internal/backup/backup.go b/internal/backup/backup.go index b9d7351c9..2409125ee 100644 --- a/internal/backup/backup.go +++ b/internal/backup/backup.go @@ -1,16 +1,20 @@ package backup import ( + "errors" "fmt" "io" "os" "path/filepath" "sort" + "strings" "time" "skillshare/internal/config" ) +const stagingDirPrefix = ".snapshot-" + // BackupDir returns the global backup directory path. func BackupDir() string { return filepath.Join(config.DataDir(), "backups") @@ -29,6 +33,10 @@ func Create(targetName, targetPath string) (string, error) { // CreateInDir creates a backup of the target directory in the specified backup dir. // Returns the backup path, or ("", nil) when there is nothing to back up. func CreateInDir(backupDir, targetName, targetPath string) (string, error) { + return createInDir(backupDir, targetName, targetPath, copyDir) +} + +func createInDir(backupDir, targetName, targetPath string, copyDirectory func(string, string) error) (backupPath string, retErr error) { if backupDir == "" { return "", fmt.Errorf("cannot determine backup directory: home directory not found") } @@ -49,17 +57,47 @@ func CreateInDir(backupDir, targetName, targetPath string) (string, error) { // Check if directory has any content entries, err := os.ReadDir(targetPath) - if err != nil || len(entries) == 0 { + if err != nil { + return "", fmt.Errorf("failed to inspect backup target: %w", err) + } + if len(entries) == 0 { return "", nil // Empty, nothing to backup } - // Create backup directory with timestamp + // Copy into a hidden staging directory so a failed copy can never be + // discovered or restored as a valid snapshot. timestamp := time.Now().Format("2006-01-02_15-04-05") - backupPath := filepath.Join(backupDir, timestamp, targetName) - - if err := os.MkdirAll(backupPath, 0755); err != nil { + timestampDir := filepath.Join(backupDir, timestamp) + if err := os.MkdirAll(backupDir, 0755); err != nil { return "", fmt.Errorf("failed to create backup directory: %w", err) } + stagingPath := "" + cleanupStaging := false + defer func() { + var cleanupErrs []error + if cleanupStaging { + if err := os.RemoveAll(stagingPath); err != nil { + cleanupErrs = append(cleanupErrs, fmt.Errorf("remove incomplete backup: %w", err)) + } + } + if backupPath == "" { + if err := removeDirIfEmpty(timestampDir); err != nil { + cleanupErrs = append(cleanupErrs, fmt.Errorf("remove empty backup timestamp: %w", err)) + } + } + if cleanupErr := errors.Join(cleanupErrs...); cleanupErr != nil { + retErr = errors.Join(retErr, cleanupErr) + } + }() + + stagingPath, err = os.MkdirTemp(backupDir, stagingDirPrefix) + if err != nil { + return "", fmt.Errorf("failed to create backup staging directory: %w", err) + } + cleanupStaging = true + if err := os.Chmod(stagingPath, 0755); err != nil { + return "", fmt.Errorf("failed to set backup staging permissions: %w", err) + } // Copy target contents to backup. copyDir skips symlinks: a merge-mode // skill symlink points into the source, which is the single source of @@ -67,22 +105,57 @@ func CreateInDir(backupDir, targetName, targetPath string) (string, error) { // content (weights, .venv, browser profiles) into every snapshot. // Only local, non-symlinked content is at risk from sync, so only that // is worth backing up. Symlinks are recreated by `skillshare sync`. - if err := copyDir(targetPath, backupPath); err != nil { + if err := copyDirectory(targetPath, stagingPath); err != nil { return "", fmt.Errorf("failed to backup: %w", err) } // A target holding nothing but symlinks yields an empty backup. Discard it: // an empty restore point is useless and would consume a MaxCount slot, // evicting older snapshots that do have content. - if copied, _ := os.ReadDir(backupPath); len(copied) == 0 { - os.Remove(backupPath) - os.Remove(filepath.Dir(backupPath)) // only succeeds if no other target wrote here + copied, err := os.ReadDir(stagingPath) + if err != nil { + return "", fmt.Errorf("failed to inspect staged backup: %w", err) + } + if len(copied) == 0 { return "", nil } + if err := os.MkdirAll(timestampDir, 0755); err != nil { + return "", fmt.Errorf("failed to create backup timestamp directory: %w", err) + } + backupPath = filepath.Join(timestampDir, targetName) + if _, err := os.Lstat(backupPath); err == nil { + // Timestamp precision is one second. If the same target is backed up + // twice within that window, preserve the already completed snapshot. + return backupPath, nil + } else if !os.IsNotExist(err) { + return "", fmt.Errorf("failed to inspect backup path: %w", err) + } + if err := os.Rename(stagingPath, backupPath); err != nil { + backupPath = "" + return "", fmt.Errorf("failed to finalize backup: %w", err) + } + cleanupStaging = false return backupPath, nil } +func removeDirIfEmpty(path string) error { + entries, err := os.ReadDir(path) + if err != nil { + if os.IsNotExist(err) { + return nil + } + return err + } + if len(entries) != 0 { + return nil + } + if err := os.Remove(path); err != nil && !os.IsNotExist(err) { + return err + } + return nil +} + // List returns all backups from the global backup dir, sorted by date (newest first). func List() ([]BackupInfo, error) { return ListInDir(BackupDir()) @@ -104,7 +177,7 @@ func ListInDir(backupDir string) ([]BackupInfo, error) { var backups []BackupInfo for _, entry := range entries { - if !entry.IsDir() { + if !entry.IsDir() || strings.HasPrefix(entry.Name(), stagingDirPrefix) { continue } diff --git a/internal/backup/backup_test.go b/internal/backup/backup_test.go index 7ef7e9ec4..815adbd93 100644 --- a/internal/backup/backup_test.go +++ b/internal/backup/backup_test.go @@ -1,6 +1,7 @@ package backup import ( + "errors" "os" "path/filepath" "testing" @@ -168,6 +169,47 @@ func TestCopyDir_MergeMode_BacksUpOnlyLocalSkills(t *testing.T) { } } +func TestCreateInDir_CopyFailureRemovesIncompleteSnapshot(t *testing.T) { + backupDir := t.TempDir() + targetDir := t.TempDir() + if err := os.MkdirAll(filepath.Join(targetDir, "local-skill"), 0755); err != nil { + t.Fatal(err) + } + writeTestFile(t, filepath.Join(targetDir, "local-skill", "SKILL.md"), "# Local") + copyErr := errors.New("copy failed") + listedDuringCopy := false + + backupPath, err := createInDir(backupDir, "claude", targetDir, func(_, dst string) error { + if err := os.MkdirAll(filepath.Join(dst, "local-skill"), 0755); err != nil { + t.Fatal(err) + } + writeTestFile(t, filepath.Join(dst, "local-skill", "partial.txt"), "partial") + backups, err := ListInDir(backupDir) + if err != nil { + t.Fatal(err) + } + listedDuringCopy = len(backups) != 0 + return copyErr + }) + if !errors.Is(err, copyErr) { + t.Fatalf("createInDir error = %v, want %v", err, copyErr) + } + if backupPath != "" { + t.Errorf("backupPath = %q, want empty", backupPath) + } + if listedDuringCopy { + t.Error("staging snapshot was listed as a completed backup") + } + + backups, err := ListInDir(backupDir) + if err != nil { + t.Fatal(err) + } + if len(backups) != 0 { + t.Fatalf("incomplete snapshot was retained: %+v", backups) + } +} + func TestCleanupInDir_OverSizeCap_KeepsNewestBackup(t *testing.T) { backupDir := t.TempDir() payload := make([]byte, 2<<20) // 2 MB — each snapshot alone exceeds the 1 MB cap @@ -203,6 +245,69 @@ func TestCleanupInDir_OverSizeCap_KeepsNewestBackup(t *testing.T) { } } +func TestCleanupInDir_SizeCapCountsOnlyRetainedBackups(t *testing.T) { + backupDir := t.TempDir() + base := time.Now().Add(-3 * time.Hour) + snapshots := []struct { + name string + size int + }{ + {"2026-01-01_00-00-00", 400 << 10}, + {"2026-01-02_00-00-00", 700 << 10}, + {"2026-01-03_00-00-00", 400 << 10}, + } + + for i, snapshot := range snapshots { + dir := filepath.Join(backupDir, snapshot.name, "claude") + if err := os.MkdirAll(dir, 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "payload.bin"), make([]byte, snapshot.size), 0644); err != nil { + t.Fatal(err) + } + stamp := base.Add(time.Duration(i) * time.Hour) + if err := os.Chtimes(filepath.Join(backupDir, snapshot.name), stamp, stamp); err != nil { + t.Fatal(err) + } + } + + removed, err := CleanupInDir(backupDir, CleanupConfig{MaxSizeMB: 1}) + if err != nil { + t.Fatalf("CleanupInDir failed: %v", err) + } + if removed != 1 { + t.Fatalf("removed = %d, want 1", removed) + } + + for _, name := range []string{"2026-01-01_00-00-00", "2026-01-03_00-00-00"} { + if _, err := os.Stat(filepath.Join(backupDir, name, "claude", "payload.bin")); err != nil { + t.Errorf("retained backup %s is missing: %v", name, err) + } + } + if _, err := os.Stat(filepath.Join(backupDir, "2026-01-02_00-00-00")); !os.IsNotExist(err) { + t.Errorf("over-cap backup should be removed, stat error = %v", err) + } +} + +func TestCleanupInDir_IgnoresActiveStagingDirectory(t *testing.T) { + backupDir := t.TempDir() + stagingPath, err := os.MkdirTemp(backupDir, stagingDirPrefix) + if err != nil { + t.Fatal(err) + } + + removed, err := CleanupInDir(backupDir, DefaultCleanupConfig()) + if err != nil { + t.Fatalf("CleanupInDir failed: %v", err) + } + if removed != 0 { + t.Errorf("removed = %d, want 0", removed) + } + if _, err := os.Stat(stagingPath); err != nil { + t.Errorf("active staging directory was removed: %v", err) + } +} + func TestBackupDir_RespectsXDGDataHome(t *testing.T) { t.Setenv("XDG_DATA_HOME", "/custom/data") diff --git a/internal/backup/cleanup.go b/internal/backup/cleanup.go index 672141c89..896674af4 100644 --- a/internal/backup/cleanup.go +++ b/internal/backup/cleanup.go @@ -1,8 +1,11 @@ package backup import ( + "errors" + "fmt" "os" "path/filepath" + "strings" "time" ) @@ -43,6 +46,7 @@ func CleanupInDir(backupDir string, cfg CleanupConfig) (int, error) { removed := 0 now := time.Now() var totalSize int64 + var cleanupErrs []error // Backups are sorted by date (newest first) for i, backup := range backups { @@ -62,24 +66,29 @@ func CleanupInDir(backupDir string, cfg CleanupConfig) (int, error) { // i > 0 always keeps the newest backup: a single snapshot larger than // the cap must not leave the user with no restore point at all. size := dirSize(backup.Path) - totalSize += size - if cfg.MaxSizeMB > 0 && i > 0 && totalSize > cfg.MaxSizeMB*1024*1024 { + if !shouldRemove && cfg.MaxSizeMB > 0 && i > 0 && + totalSize+size > cfg.MaxSizeMB*1024*1024 { shouldRemove = true } if shouldRemove { if err := os.RemoveAll(backup.Path); err != nil { - // Log but continue with other backups + cleanupErrs = append(cleanupErrs, fmt.Errorf("remove backup %s: %w", backup.Timestamp, err)) + totalSize += size continue } removed++ + continue } + totalSize += size } // Clean up empty timestamp directories - cleanEmptyDirs(backupDir) + if err := cleanEmptyDirs(backupDir); err != nil { + cleanupErrs = append(cleanupErrs, err) + } - return removed, nil + return removed, errors.Join(cleanupErrs...) } // CleanupByAge removes backups older than the specified duration. @@ -109,26 +118,40 @@ func dirSize(path string) int64 { return size } -// cleanEmptyDirs removes empty directories in the backup directory -func cleanEmptyDirs(path string) { +// cleanEmptyDirs removes empty directories in the backup directory. +func cleanEmptyDirs(path string) error { if path == "" { - return + return nil } entries, err := os.ReadDir(path) if err != nil { - return + if os.IsNotExist(err) { + return nil + } + return fmt.Errorf("read backup directory: %w", err) } + var cleanupErrs []error for _, entry := range entries { + if strings.HasPrefix(entry.Name(), stagingDirPrefix) { + continue + } if entry.IsDir() { subPath := filepath.Join(path, entry.Name()) - subEntries, _ := os.ReadDir(subPath) + subEntries, err := os.ReadDir(subPath) + if err != nil { + cleanupErrs = append(cleanupErrs, fmt.Errorf("read backup timestamp %s: %w", entry.Name(), err)) + continue + } if len(subEntries) == 0 { - os.Remove(subPath) + if err := os.Remove(subPath); err != nil && !os.IsNotExist(err) { + cleanupErrs = append(cleanupErrs, fmt.Errorf("remove empty backup timestamp %s: %w", entry.Name(), err)) + } } } } + return errors.Join(cleanupErrs...) } // Size returns the total size of a backup directory in bytes diff --git a/tests/integration/agent_backup_test.go b/tests/integration/agent_backup_test.go index da855e9a0..3453c6802 100644 --- a/tests/integration/agent_backup_test.go +++ b/tests/integration/agent_backup_test.go @@ -83,7 +83,7 @@ targets: // protects. Synced agents are symlinks into the source and are recreated // by `sync`, so they are deliberately not backed up (issue #252). localPath := filepath.Join(claudeAgents, "local-helper.md") - os.WriteFile(localPath, []byte("# Local helper"), 0644) + sb.WriteFile(localPath, "# Local helper") // Sync then backup sb.RunCLI("sync", "agents") @@ -96,7 +96,9 @@ targets: } // Delete the local agent from target - os.Remove(localPath) + if err := os.Remove(localPath); err != nil { + t.Fatalf("remove local agent: %v", err) + } // Restore result := sb.RunCLI("restore", "agents", "claude", "--force") @@ -138,8 +140,10 @@ func TestBackup_Agents_ProjectMode_CreatesBackup(t *testing.T) { // Local agent — synced agents are symlinks and are not backed up (#252), // so without local content there is nothing to snapshot. - os.WriteFile(filepath.Join(projectDir, ".claude", "agents", "local-helper.md"), - []byte("# Local helper"), 0644) + sb.WriteFile( + filepath.Join(projectDir, ".claude", "agents", "local-helper.md"), + "# Local helper", + ) // Sync agents first result := sb.RunCLIInDir(projectDir, "sync", "-p", "agents") @@ -190,7 +194,7 @@ func TestBackup_Agents_ProjectMode_RestoreRoundTrip(t *testing.T) { // by `sync`, so they are deliberately not backed up (issue #252). claudeAgents := filepath.Join(projectDir, ".claude", "agents") localPath := filepath.Join(claudeAgents, "local-helper.md") - os.WriteFile(localPath, []byte("# Local helper"), 0644) + sb.WriteFile(localPath, "# Local helper") // Sync → backup sb.RunCLIInDir(projectDir, "sync", "-p", "agents") @@ -203,7 +207,9 @@ func TestBackup_Agents_ProjectMode_RestoreRoundTrip(t *testing.T) { } // Delete the local agent from target - os.Remove(localPath) + if err := os.Remove(localPath); err != nil { + t.Fatalf("remove local agent: %v", err) + } // Restore result := sb.RunCLIInDir(projectDir, "restore", "-p", "agents", "claude", "--force") diff --git a/tests/integration/doctor_test.go b/tests/integration/doctor_test.go index ee6b86899..9dd70ec7e 100644 --- a/tests/integration/doctor_test.go +++ b/tests/integration/doctor_test.go @@ -933,3 +933,34 @@ func TestDoctorProject_RelativeSymlink_NoFalsePositives(t *testing.T) { t.Errorf("doctor -p misreported valid relative symlinks:\n%s", out) } } + +func TestDoctor_CopyModeExternalSymlink_ChecksDuplicateSkills(t *testing.T) { + sb := testutil.NewSandbox(t) + defer sb.Cleanup() + + sb.CreateSkill("duplicate-skill", map[string]string{"SKILL.md": "# Source"}) + + realTarget := sb.CreateTarget("real-copy-target") + localSkill := filepath.Join(realTarget, "duplicate-skill") + if err := os.MkdirAll(localSkill, 0755); err != nil { + t.Fatal(err) + } + sb.WriteFile(filepath.Join(localSkill, "SKILL.md"), "# Local") + + linkedTarget := filepath.Join(sb.Home, "linked-copy-target") + if err := os.Symlink(realTarget, linkedTarget); err != nil { + t.Skipf("symlink not supported: %v", err) + } + + sb.WriteConfig(`source: ` + sb.SourcePath + ` +targets: + copilot: + path: ` + linkedTarget + ` + mode: copy +`) + + result := sb.RunCLI("doctor", "-g") + result.AssertSuccess(t) + result.AssertOutputContains(t, "Duplicate skills") + result.AssertOutputContains(t, "duplicate-skill") +} diff --git a/tests/integration/list_project_test.go b/tests/integration/list_project_test.go index 2b3e8e048..825e9f3d1 100644 --- a/tests/integration/list_project_test.go +++ b/tests/integration/list_project_test.go @@ -115,7 +115,7 @@ func TestListProject_FilterByStatus(t *testing.T) { sb.CreateProjectSkill(projectRoot, "on-skill", map[string]string{"SKILL.md": "# On"}) sb.CreateProjectSkill(projectRoot, "off-skill", map[string]string{"SKILL.md": "# Off"}) skillsDir := filepath.Join(projectRoot, ".skillshare", "skills") - os.WriteFile(filepath.Join(skillsDir, ".skillignore"), []byte("off-skill\n"), 0644) + sb.WriteFile(filepath.Join(skillsDir, ".skillignore"), "off-skill\n") enabled := sb.RunCLIInDir(projectRoot, "list", "-p", "--no-tui", "--status", "enabled") enabled.AssertSuccess(t)