claude-nomad 0.66.0 → 0.67.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [0.67.0](https://github.com/funkadelic/claude-nomad/compare/v0.66.0...v0.67.0) (2026-08-18)
+
+### What's new
+
+**On all supported platforms, i.e. \*nix, Mac, WSL2, and native Windows.**
+
+- **Your backup cache no longer collects empty folders.** Every sync saves a copy of anything it is
+  about to overwrite into a dated folder under `~/.cache/claude-nomad/backup/`, and it creates that
+  folder before it touches your files so a full disk or a permissions problem stops the sync before
+  it has changed anything. A sync that turns out to have nothing to save now clears its own folder
+  instead of leaving an empty one behind, and so does one that stops early.
+- **`nomad clean --backups` removes empty backup folders whatever their age.** They hold nothing to
+  recover, so neither the 14-day default nor `--keep <N>` keeps one alive, and they no longer use up
+  the slots `--keep <N>` reserves: ask for the five newest and you get the five newest that actually
+  hold something. Backups holding anything at all, a file or even a link, are left exactly as
+  before. `nomad clean --backups --dry-run` always prints its preview, since it changes nothing and
+  never waits on another command.
+- **`nomad adopt` no longer runs at the same time as a pull, push, or sync.** It waits its turn the
+  way those commands already wait for each other, so a cleanup or a sync running in another terminal
+  cannot remove or overwrite a backup that adopt is still writing. If another one is already
+  running, adopt says so and does nothing rather than starting a move it cannot finish safely.
+  Previewing with `nomad adopt <name> --dry-run` never waits, since it only reads and prints.
+
+
+### Added
+
+* clean up the empty folders in your backup cache ([#525](https://github.com/funkadelic/claude-nomad/issues/525)) ([3f5ae92](https://github.com/funkadelic/claude-nomad/commit/3f5ae92e46173364f5e9c66e4963bcc716c813e6))
+
+
+### Fixed
+
+* **ci:** base the drift branch on main on a dispatch run ([#524](https://github.com/funkadelic/claude-nomad/issues/524)) ([3e94c1e](https://github.com/funkadelic/claude-nomad/commit/3e94c1e2df9296a539c71eac873058cb69225d78))
+
 ## [0.66.0](https://github.com/funkadelic/claude-nomad/compare/v0.65.0...v0.66.0) (2026-08-17)
 
 ### What's new

package/dist/nomad.mjs

@@ -807,6 +807,7 @@ import {
   mkdirSync,
   openSync,
   renameSync,
+  rmdirSync,
   statSync,
   symlinkSync,
   writeFileSync
@@ -867,6 +868,12 @@ function freshBackupTs(backupRoot) {
   while (existsSync3(join5(backupRoot, `${base}-${n}`))) n++;
   return `${base}-${n}`;
 }
+function discardEmptyBackupDir(backupRoot) {
+  try {
+    rmdirSync(backupRoot);
+  } catch {
+  }
+}
 function ensureSymlink(linkPath, target) {
   if (existsSync3(linkPath)) {
     if (lstatSync4(linkPath).isSymbolicLink()) return;
@@ -1549,7 +1556,7 @@ var init_push_leak_verdict = __esm({
 
 // src/commands.adopt.ts
 import { existsSync as existsSync5, lstatSync as lstatSync7 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/commands.adopt.recover.ts
 import { lstatSync as lstatSync6, rmSync as rmSync4 } from "node:fs";
@@ -2460,10 +2467,125 @@ init_config_sharedDirs_guard();
 init_exit_codes();
 init_utils();
 init_utils_fs();
+
+// src/utils.lockfile.ts
+init_config();
+init_utils();
+import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join8 } from "node:path";
+function lockFilePath() {
+  return join8(home(), ".cache", "claude-nomad", "nomad.lock");
+}
+function acquireLock(verb) {
+  const lp = lockFilePath();
+  mkdirSync2(dirname3(lp), { recursive: true });
+  try {
+    const fd = openSync2(lp, "wx");
+    try {
+      writeFileSync2(fd, String(process.pid));
+    } catch (writeErr) {
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+      try {
+        unlinkSync(lp);
+      } catch {
+      }
+      throw writeErr;
+    }
+    return { fd, path: lp };
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EEXIST") throw err;
+    return checkStaleAndRetry(verb, lp);
+  }
+}
+function releaseLock(handle) {
+  if (handle === null) return;
+  const lp = handle.path;
+  try {
+    closeSync2(handle.fd);
+  } catch {
+  }
+  try {
+    unlinkSync(lp);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+function unlinkIfSamePid(expectedPidStr, lp) {
+  let current;
+  try {
+    current = readFileSync3(lp, "utf8").trim();
+  } catch {
+    return false;
+  }
+  if (current !== expectedPidStr) return false;
+  try {
+    unlinkSync(lp);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkStaleAndRetry(verb, lp) {
+  let pidStr;
+  try {
+    pidStr = readFileSync3(lp, "utf8").trim();
+  } catch {
+    pidStr = "";
+  }
+  const pid = Number.parseInt(pidStr, 10);
+  if (!Number.isFinite(pid) || pid <= 0) {
+    if (unlinkIfSamePid(pidStr, lp)) return retryOnce(verb, lp);
+    warn(`another nomad ${verb} running, skipping`);
+    return null;
+  }
+  try {
+    process.kill(pid, 0);
+    warn(`another nomad ${verb} running, skipping`);
+    return null;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") {
+      if (unlinkIfSamePid(pidStr, lp)) return retryOnce(verb, lp);
+      warn(`another nomad ${verb} running, skipping`);
+      return null;
+    }
+    warn(`another nomad ${verb} running, skipping`);
+    return null;
+  }
+}
+function retryOnce(verb, lp) {
+  try {
+    const fd = openSync2(lp, "wx");
+    try {
+      writeFileSync2(fd, String(process.pid));
+    } catch {
+      try {
+        closeSync2(fd);
+      } catch {
+      }
+      try {
+        unlinkSync(lp);
+      } catch {
+      }
+      warn(`another nomad ${verb} running, skipping`);
+      return null;
+    }
+    return { fd, path: lp };
+  } catch {
+    warn(`another nomad ${verb} running, skipping`);
+    return null;
+  }
+}
+
+// src/commands.adopt.ts
 init_utils_json();
 var ADOPT_PUSH_HINT = "run `nomad push` to share with other hosts";
 function readMapIfPresent(repoHome2) {
-  const mapPath = join8(repoHome2, "path-map.json");
+  const mapPath = join9(repoHome2, "path-map.json");
   return existsSync5(mapPath) ? readPathMap(mapPath) : { projects: {} };
 }
 function isConfiguredTarget(name, map) {
@@ -2498,7 +2620,7 @@ function adoptStopsEarly(name, linkPath, sharedTarget) {
 function performAdoptMove(name, linkPath, sharedTarget, repo, backup) {
   const ts = freshBackupTs(backup);
   const snapshotted = backupBeforeWrite(linkPath, ts);
-  const rel = join8("shared", name);
+  const rel = join9("shared", name);
   const stage = () => gitOrFatal(["add", "--", rel], `git add shared/${name}`, repo);
   copyIntoSharedOrFatal(name, linkPath, sharedTarget, repo);
   refuseLateDeniedEntries(name, linkPath, sharedTarget, repo, { snapshotted, ts });
@@ -2538,8 +2660,21 @@ function cmdAdopt(name, opts = {}) {
     );
     process.exit(1);
   }
-  const linkPath = join8(claude, name);
-  const sharedTarget = join8(repo, "shared", name);
+  const linkPath = join9(claude, name);
+  const sharedTarget = join9(repo, "shared", name);
+  if (dryRun) {
+    adoptPreflightAndMove(name, linkPath, sharedTarget, repo, backup, true);
+    return;
+  }
+  const handle = acquireLock("adopt");
+  if (handle === null) process.exit(EXIT.SUCCESS);
+  try {
+    adoptPreflightAndMove(name, linkPath, sharedTarget, repo, backup, false);
+  } finally {
+    releaseLock(handle);
+  }
+}
+function adoptPreflightAndMove(name, linkPath, sharedTarget, repo, backup, dryRun) {
   if (adoptStopsEarly(name, linkPath, sharedTarget)) return;
   refuseDeniedEntries(name, linkPath);
   if (dryRun) {
@@ -2566,8 +2701,8 @@ init_config();
 import { existsSync as existsSync6 } from "node:fs";
 
 // src/commands.redact.core.ts
-import { appendFileSync, readFileSync as readFileSync3 } from "node:fs";
-import { join as join9 } from "node:path";
+import { appendFileSync, readFileSync as readFileSync4 } from "node:fs";
+import { join as join10 } from "node:path";
 function collectMatchIntervals(content, findings) {
   const intervals = [];
   for (const f of findings) {
@@ -2625,10 +2760,10 @@ function isAlreadyPresent(line, lines) {
 function appendGitleaksIgnore(fingerprint, repo) {
   const sanitized = fingerprint.replace(/[\r\n]/g, "").trim();
   if (sanitized.length === 0) return;
-  const ignPath = join9(repo, ".gitleaksignore");
+  const ignPath = join10(repo, ".gitleaksignore");
   let raw;
   try {
-    raw = readFileSync3(ignPath, "utf8");
+    raw = readFileSync4(ignPath, "utf8");
   } catch {
     raw = "";
   }
@@ -2666,121 +2801,6 @@ import { join as join11 } from "node:path";
 import { createInterface } from "node:readline/promises";
 init_utils_fs();
 init_utils_json();
-
-// src/utils.lockfile.ts
-init_config();
-init_utils();
-import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname3, join as join10 } from "node:path";
-function lockFilePath() {
-  return join10(home(), ".cache", "claude-nomad", "nomad.lock");
-}
-function acquireLock(verb) {
-  const lp = lockFilePath();
-  mkdirSync2(dirname3(lp), { recursive: true });
-  try {
-    const fd = openSync2(lp, "wx");
-    try {
-      writeFileSync2(fd, String(process.pid));
-    } catch (writeErr) {
-      try {
-        closeSync2(fd);
-      } catch {
-      }
-      try {
-        unlinkSync(lp);
-      } catch {
-      }
-      throw writeErr;
-    }
-    return { fd, path: lp };
-  } catch (err) {
-    const code = err.code;
-    if (code !== "EEXIST") throw err;
-    return checkStaleAndRetry(verb, lp);
-  }
-}
-function releaseLock(handle) {
-  if (handle === null) return;
-  const lp = handle.path;
-  try {
-    closeSync2(handle.fd);
-  } catch {
-  }
-  try {
-    unlinkSync(lp);
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-function unlinkIfSamePid(expectedPidStr, lp) {
-  let current;
-  try {
-    current = readFileSync4(lp, "utf8").trim();
-  } catch {
-    return false;
-  }
-  if (current !== expectedPidStr) return false;
-  try {
-    unlinkSync(lp);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function checkStaleAndRetry(verb, lp) {
-  let pidStr;
-  try {
-    pidStr = readFileSync4(lp, "utf8").trim();
-  } catch {
-    pidStr = "";
-  }
-  const pid = Number.parseInt(pidStr, 10);
-  if (!Number.isFinite(pid) || pid <= 0) {
-    if (unlinkIfSamePid(pidStr, lp)) return retryOnce(verb, lp);
-    warn(`another nomad ${verb} running, skipping`);
-    return null;
-  }
-  try {
-    process.kill(pid, 0);
-    warn(`another nomad ${verb} running, skipping`);
-    return null;
-  } catch (err) {
-    const code = err.code;
-    if (code === "ESRCH") {
-      if (unlinkIfSamePid(pidStr, lp)) return retryOnce(verb, lp);
-      warn(`another nomad ${verb} running, skipping`);
-      return null;
-    }
-    warn(`another nomad ${verb} running, skipping`);
-    return null;
-  }
-}
-function retryOnce(verb, lp) {
-  try {
-    const fd = openSync2(lp, "wx");
-    try {
-      writeFileSync2(fd, String(process.pid));
-    } catch {
-      try {
-        closeSync2(fd);
-      } catch {
-      }
-      try {
-        unlinkSync(lp);
-      } catch {
-      }
-      warn(`another nomad ${verb} running, skipping`);
-      return null;
-    }
-    return { fd, path: lp };
-  } catch {
-    warn(`another nomad ${verb} running, skipping`);
-    return null;
-  }
-}
-
-// src/commands.capture-settings.ts
 init_utils();
 async function confirmCapture(destLabel, keys) {
   if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
@@ -2866,6 +2886,9 @@ var TS_SHAPE = /^\d{8}-\d{6}(-\d+)?$/;
 var DURATION_RE = /^(\d+)([dhm])$/;
 var UNIT_MS = { d: 864e5, h: 36e5, m: 6e4 };
 var CLEAN_DEFAULT_OLDER_THAN_MS = 14 * 24 * 60 * 60 * 1e3;
+function nameOf(d) {
+  return d.name;
+}
 function isTsDir(name) {
   return TS_SHAPE.test(name);
 }
@@ -2878,6 +2901,19 @@ function listBackupDirs(backupBase2) {
   if (!existsSync8(backupBase2)) return [];
   return readdirSync4(backupBase2).filter(isTsDir).map((name) => ({ name, mtimeMs: statSync2(join12(backupBase2, name)).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
+function holdsNoContent(dir) {
+  let entries;
+  try {
+    entries = readdirSync4(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) return false;
+    if (!holdsNoContent(join12(dir, entry.name))) return false;
+  }
+  return true;
+}
 function prunableByAge(dirs, olderThanMs, nowMs) {
   return dirs.filter((d) => nowMs - d.mtimeMs > olderThanMs).map((d) => d.name);
 }
@@ -2910,8 +2946,30 @@ function cmdClean(opts, backupBase2 = backupBase()) {
     }
     olderThanMs = parsed;
   }
+  if (dryRun) {
+    pruneBackups({ dryRun, olderThanMs, keep }, backupBase2);
+    return;
+  }
+  const handle = acquireLock("clean");
+  if (handle === null) process.exit(EXIT.SUCCESS);
+  try {
+    pruneBackups({ dryRun, olderThanMs, keep }, backupBase2);
+  } finally {
+    releaseLock(handle);
+  }
+}
+function pruneBackups(opts, backupBase2) {
+  const { dryRun, olderThanMs, keep } = opts;
   const dirs = listBackupDirs(backupBase2);
-  const targets = resolveTargets(dirs, olderThanMs, keep);
+  const empty = new Set(dirs.filter((d) => holdsNoContent(join12(backupBase2, d.name))).map(nameOf));
+  const aged = new Set(
+    resolveTargets(
+      dirs.filter((d) => !empty.has(d.name)),
+      olderThanMs,
+      keep
+    )
+  );
+  const targets = dirs.filter((d) => empty.has(d.name) || aged.has(d.name)).map(nameOf);
   if (dryRun) {
     for (const name of targets) item(name);
     log(`dry-run: ${targets.length} backup(s) would be removed`);
@@ -3964,7 +4022,7 @@ function reportBackupsCheck(section2, backupBase2 = backupBase()) {
   if (count > DOCTOR_BACKUP_COUNT_WARN || sizeMb > DOCTOR_BACKUP_SIZE_WARN_MB) {
     addItem(
       section2,
-      `${yellow(warnGlyph)} backups: ${count} dirs / ${sizeMb.toFixed(1)} MB (run 'nomad clean --backups --keep <N>'; bare --backups only prunes dirs older than 14d)`
+      `${yellow(warnGlyph)} backups: ${count} dirs / ${sizeMb.toFixed(1)} MB (run 'nomad clean --backups --keep <N>'; bare --backups prunes empty dirs plus those older than 14d)`
     );
   }
 }
@@ -9001,12 +9059,20 @@ function handleWedge(repo, forceRemote) {
   return die(wedgeMarkerRunbookText(state), { code: EXIT.CONFLICT });
 }
 function runPullCore(opts = {}) {
+  const backup = backupBase();
+  const ts = freshBackupTs(backup);
+  try {
+    return runPullWithBackupTs(ts, opts);
+  } finally {
+    discardEmptyBackupDir(join61(backup, ts));
+  }
+}
+function runPullWithBackupTs(ts, opts) {
   const dryRun = opts.dryRun === true;
   const forceRemote = opts.forceRemote === true;
   const compose = opts.compose === true;
   const repo = repoHome();
   const backup = backupBase();
-  const ts = freshBackupTs(backup);
   const recovered = handleWedge(repo, forceRemote);
   if (!dryRun) {
     const backupRoot = join61(backup, ts);
@@ -10638,7 +10704,7 @@ function parseSyncArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.66.0",
+  version: "0.67.0",
   type: "module",
   description: "Sync Claude Code config (~/.claude/) across machines via a private Git repo, with path remapping and per-host settings overrides.",
   keywords: [
@@ -10867,7 +10933,9 @@ var DEFAULT_HELP = [
   row("       --backups", "Required: confirm backup pruning is the intended target."),
   row("       --dry-run", "List the snapshots that would be removed without deleting."),
   row("       --older-than <dur>", "Delete snapshots older than a duration (e.g. 14d, 24h, 30m)."),
-  cont("Default when no retention flag is given: 14d."),
+  cont("Default when no retention flag is given: 14d. A snapshot holding"),
+  cont("nothing is removed in every mode, whatever its age, and never"),
+  cont("uses up one of the --keep slots."),
   row("       --keep <N>", "Keep the N most-recent snapshots, delete the rest. Mutually"),
   cont("exclusive with --older-than."),
   "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-nomad",
-  "version": "0.66.0",
+  "version": "0.67.0",
   "type": "module",
   "description": "Sync Claude Code config (~/.claude/) across machines via a private Git repo, with path remapping and per-host settings overrides.",
   "keywords": [