claude-nomad 0.25.1 → 0.25.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.25.2](https://github.com/funkadelic/claude-nomad/compare/v0.25.1...v0.25.2) (2026-05-26)
+
+
+### Fixed
+
+* pre-existing robustness fixes from PR [#136](https://github.com/funkadelic/claude-nomad/issues/136) review ([#140](https://github.com/funkadelic/claude-nomad/issues/140)) ([bf4f443](https://github.com/funkadelic/claude-nomad/commit/bf4f443c50a47efafbb350d45d0e5d6883374f8d))
+
 ## [0.25.1](https://github.com/funkadelic/claude-nomad/compare/v0.25.0...v0.25.1) (2026-05-26)
 
 

package/package.json

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

package/src/commands.doctor.checks.repo.ts

@@ -1,4 +1,4 @@
-import { existsSync, lstatSync } from 'node:fs';
+import { existsSync, lstatSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 
 import {
@@ -83,16 +83,48 @@ export function reportRepoState(section: DoctorSection): void {
   }
 }
 
-/** Emits a per-entry status line for each name in SHARED_LINKS (okGlyph/warnGlyph/failGlyph). A non-symlink blocks sync and FAILs via process.exitCode. */
+/**
+ * Emits a per-entry status line for each name in SHARED_LINKS
+ * (okGlyph/warnGlyph/failGlyph). A non-symlink blocks sync and FAILs via
+ * process.exitCode. TOCTOU-safe: lstatSync is wrapped in try/catch so a path
+ * that vanishes or becomes unreadable between the probe and the stat yields a
+ * row instead of an unhandled throw that aborts the whole doctor run. A symlink
+ * whose target cannot be resolved is a WARN (broken-symlink for a missing
+ * target, target-unreadable otherwise), never a healthy OK, so a dangling or
+ * unreadable link is not masked.
+ */
 export function reportSharedLinks(section: DoctorSection): void {
   for (const name of SHARED_LINKS) {
     const p = join(CLAUDE_HOME, name);
-    if (!existsSync(p)) {
-      addItem(section, `${yellow(warnGlyph)} ${name}: missing`);
+    let stat;
+    try {
+      stat = lstatSync(p);
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT') {
+        addItem(section, `${yellow(warnGlyph)} ${name}: missing`);
+      } else {
+        addItem(section, `${red(failGlyph)} ${name}: could not stat (${String(code)})`);
+        process.exitCode = 1;
+      }
       continue;
     }
-    if (lstatSync(p).isSymbolicLink()) {
-      addItem(section, `${green(okGlyph)} ${name}: symlink`);
+    if (stat.isSymbolicLink()) {
+      try {
+        // statSync follows the link; a throw means the target does not resolve.
+        statSync(p);
+        addItem(section, `${green(okGlyph)} ${name}: symlink`);
+      } catch (err) {
+        const code = (err as NodeJS.ErrnoException).code;
+        if (code === 'ENOENT') {
+          addItem(section, `${yellow(warnGlyph)} ${name}: broken symlink (target missing)`);
+        } else {
+          addItem(
+            section,
+            `${yellow(warnGlyph)} ${name}: symlink target unreadable (${String(code)})`,
+          );
+        }
+      }
     } else {
       addItem(section, `${red(failGlyph)} ${name}: NOT a symlink (blocks sync)`);
       process.exitCode = 1;

package/src/utils.lockfile.ts

@@ -22,7 +22,26 @@ export function acquireLock(verb: string): LockHandle | null {
   mkdirSync(dirname(LOCK_PATH), { recursive: true });
   try {
     const fd = openSync(LOCK_PATH, 'wx');
-    writeFileSync(fd, String(process.pid));
+    try {
+      writeFileSync(fd, String(process.pid));
+    } catch (writeErr) {
+      // PID-write failed after the lock file was created. Best-effort cleanup:
+      // close the fd (ignore errors), then unlink the orphaned lock file
+      // (ignore ANY unlink failure). The original write error is rethrown
+      // unconditionally, so a cleanup failure can never mask it and non-EEXIST
+      // throw semantics are preserved.
+      try {
+        closeSync(fd);
+      } catch {
+        /* already closed; ignore */
+      }
+      try {
+        unlinkSync(LOCK_PATH);
+      } catch {
+        /* best-effort cleanup; the original write failure takes precedence */
+      }
+      throw writeErr;
+    }
     return { fd };
   } catch (err) {
     const code = (err as NodeJS.ErrnoException).code;
@@ -122,7 +141,25 @@ function checkStaleAndRetry(verb: string): LockHandle | null {
 function retryOnce(verb: string): LockHandle | null {
   try {
     const fd = openSync(LOCK_PATH, 'wx');
-    writeFileSync(fd, String(process.pid));
+    try {
+      writeFileSync(fd, String(process.pid));
+    } catch {
+      // Twin of the acquireLock write-failure guard. Best-effort cleanup: close
+      // the fd (ignore errors) and unlink the orphaned lock file (ignore ANY
+      // unlink failure). retryOnce's null-on-failure contract is preserved.
+      try {
+        closeSync(fd);
+      } catch {
+        /* already closed; ignore */
+      }
+      try {
+        unlinkSync(LOCK_PATH);
+      } catch {
+        /* best-effort cleanup; the null return below is the contract */
+      }
+      warn(`another nomad ${verb} running, skipping`);
+      return null;
+    }
     return { fd };
   } catch {
     warn(`another nomad ${verb} running, skipping`);