gsd-pi 2.32.0 → 2.33.0-dev.69bff0f

package/src/resources/extensions/gsd/repo-identity.ts

@@ -10,7 +10,7 @@ import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
 
 // ─── Repo Identity ──────────────────────────────────────────────────────────
 
@@ -37,6 +37,27 @@ function getRemoteUrl(basePath: string): string {
  */
 function resolveGitRoot(basePath: string): string {
   try {
+    // In a worktree, --show-toplevel returns the worktree path, not the main
+    // repo root. Use --git-common-dir to find the shared .git directory,
+    // then derive the main repo root from it (#1288).
+    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd: basePath,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5_000,
+    }).trim();
+
+    // If commonDir ends with .git/worktrees/<name>, the main repo is two
+    // levels up from the worktrees dir. If it's just .git, resolve normally.
+    if (commonDir.includes(`${sep}worktrees${sep}`) || commonDir.includes("/worktrees/")) {
+      // e.g., /path/to/project/.gsd/worktrees/M001/.git → /path/to/project
+      // or /path/to/project/.git/worktrees/M001 → /path/to/project
+      const gitDir = commonDir.replace(/[/\\]worktrees[/\\][^/\\]+$/, "");
+      const mainRoot = resolve(gitDir, "..");
+      return mainRoot;
+    }
+
+    // Not in a worktree — use --show-toplevel as usual
     return execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: basePath,
       encoding: "utf-8",

package/src/resources/extensions/gsd/session-lock.ts

@@ -17,7 +17,7 @@
  */
 
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -54,12 +54,81 @@ let _lockPid: number = 0;
 /** Set to true when proper-lockfile fires onCompromised (mtime drift, sleep, etc.). */
 let _lockCompromised: boolean = false;
 
+/** Whether we've already registered a process.on('exit') handler. */
+let _exitHandlerRegistered: boolean = false;
+
 const LOCK_FILE = "auto.lock";
 
 function lockPath(basePath: string): string {
   return join(gsdRoot(basePath), LOCK_FILE);
 }
 
+// ─── Stray Lock Cleanup ─────────────────────────────────────────────────────
+
+/**
+ * Remove numbered lock file variants (e.g. "auto 2.lock", "auto 3.lock")
+ * that accumulate from macOS file conflict resolution (iCloud/Dropbox/OneDrive)
+ * or other filesystem-level copy-on-conflict behavior (#1315).
+ *
+ * Also removes stray proper-lockfile directories beyond the canonical `.gsd.lock/`.
+ */
+export function cleanupStrayLockFiles(basePath: string): void {
+  const gsdDir = gsdRoot(basePath);
+
+  // Clean numbered auto lock files inside .gsd/
+  try {
+    if (existsSync(gsdDir)) {
+      for (const entry of readdirSync(gsdDir)) {
+        // Match "auto <N>.lock" or "auto (<N>).lock" variants but NOT the canonical "auto.lock"
+        if (entry !== LOCK_FILE && /^auto\s.+\.lock$/i.test(entry)) {
+          try { unlinkSync(join(gsdDir, entry)); } catch { /* best-effort */ }
+        }
+      }
+    }
+  } catch { /* non-fatal: directory read failure */ }
+
+  // Clean stray proper-lockfile directories (e.g. ".gsd 2.lock/")
+  // The canonical one is ".gsd.lock/" — anything else is stray.
+  try {
+    const parentDir = dirname(gsdDir);
+    const gsdDirName = gsdDir.split("/").pop() || ".gsd";
+    if (existsSync(parentDir)) {
+      for (const entry of readdirSync(parentDir)) {
+        // Match ".gsd <N>.lock" or ".gsd (<N>).lock" directories but NOT ".gsd.lock"
+        if (entry !== `${gsdDirName}.lock` && entry.startsWith(gsdDirName) && entry.endsWith(".lock")) {
+          const fullPath = join(parentDir, entry);
+          try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+              rmSync(fullPath, { recursive: true, force: true });
+            }
+          } catch { /* best-effort */ }
+        }
+      }
+    }
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Register a single process exit handler that cleans up lock state.
+ * Uses module-level references so it always operates on current state.
+ * Only registers once — subsequent calls are no-ops.
+ */
+function ensureExitHandler(gsdDir: string): void {
+  if (_exitHandlerRegistered) return;
+  _exitHandlerRegistered = true;
+
+  process.once("exit", () => {
+    try {
+      if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
+    } catch { /* best-effort */ }
+    try {
+      const lockDir = join(gsdDir + ".lock");
+      if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
+    } catch { /* best-effort */ }
+  });
+}
+
 // ─── Public API ─────────────────────────────────────────────────────────────
 
 /**
@@ -77,6 +146,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   // Ensure the directory exists
   mkdirSync(dirname(lp), { recursive: true });
 
+  // Clean up numbered lock file variants from cloud sync conflicts (#1315)
+  cleanupStrayLockFiles(basePath);
+
   // Write our lock data first (the content is informational; the OS lock is the real guard)
   const lockData: SessionLockData = {
     pid: process.pid,
@@ -124,15 +196,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
 
     // Safety net: clean up lock dir on process exit if _releaseFunction
     // wasn't called (e.g., normal exit after clean completion) (#1245).
-    const lockDirForCleanup = join(gsdDir + ".lock");
-    process.once("exit", () => {
-      try {
-        if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
-      } catch { /* best-effort */ }
-      try {
-        if (existsSync(lockDirForCleanup)) rmSync(lockDirForCleanup, { recursive: true, force: true });
-      } catch { /* best-effort */ }
-    });
+    ensureExitHandler(gsdDir);
 
     // Write the informational lock data
     atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
@@ -154,12 +218,20 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
         // Retry acquisition after cleanup
         const release = lockfile.lockSync(gsdDir, {
           realpath: false,
-          stale: 300_000,
+          stale: 1_800_000, // 30 minutes — match primary lock settings
           update: 10_000,
+          onCompromised: () => {
+            _lockCompromised = true;
+            _releaseFunction = null;
+          },
         });
         _releaseFunction = release;
         _lockedPath = basePath;
         _lockPid = process.pid;
+
+        // Safety net — uses centralized handler to avoid double-registration
+        ensureExitHandler(gsdDir);
+
         atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
         return { acquired: true };
       } catch {
@@ -299,6 +371,9 @@ export function releaseSessionLock(basePath: string): void {
     // Non-fatal
   }
 
+  // Clean up numbered lock file variants from cloud sync conflicts (#1315)
+  cleanupStrayLockFiles(basePath);
+
   _lockedPath = null;
   _lockPid = 0;
   _lockCompromised = false;

package/src/resources/extensions/gsd/tests/all-milestones-complete-merge.test.ts

@@ -70,31 +70,34 @@ test("auto.ts 'all milestones complete' path merges before stopping (#962)", ()
   const incompleteIdx = autoSrc.indexOf("incomplete.length === 0");
   assert.ok(incompleteIdx > -1, "auto.ts should have 'incomplete.length === 0' check");
 
-  // The merge call must appear BETWEEN the incomplete check and the stopAuto call
-  // in that same block
+  // The merge call must appear BETWEEN the incomplete check and the stopAuto call.
+  // After the #1308 refactor, the merge is delegated to tryMergeMilestone.
   const blockAfterIncomplete = autoSrc.slice(incompleteIdx, incompleteIdx + 3000);
 
   assert.ok(
-    blockAfterIncomplete.includes("mergeMilestoneToMain"),
-    "auto.ts should call mergeMilestoneToMain in the 'all milestones complete' path",
+    blockAfterIncomplete.includes("tryMergeMilestone"),
+    "auto.ts should call tryMergeMilestone in the 'all milestones complete' path",
   );
 
   // The merge should come before stopAuto in this block
-  const mergePos = blockAfterIncomplete.indexOf("mergeMilestoneToMain");
+  const mergePos = blockAfterIncomplete.indexOf("tryMergeMilestone");
   const stopPos = blockAfterIncomplete.indexOf("stopAuto");
   assert.ok(
     mergePos < stopPos,
-    "mergeMilestoneToMain should be called before stopAuto in the 'all complete' path",
+    "tryMergeMilestone should be called before stopAuto in the 'all complete' path",
   );
 
-  // Should handle both worktree and branch isolation modes
+  // Verify tryMergeMilestone handles both worktree and branch isolation
+  const helperIdx = autoSrc.indexOf("function tryMergeMilestone");
+  assert.ok(helperIdx > -1, "tryMergeMilestone helper should exist");
+  const helperBlock = autoSrc.slice(helperIdx, helperIdx + 2000);
   assert.ok(
-    blockAfterIncomplete.includes("isInAutoWorktree"),
-    "should check isInAutoWorktree for worktree mode",
+    helperBlock.includes("isInAutoWorktree"),
+    "tryMergeMilestone should check isInAutoWorktree for worktree mode",
   );
   assert.ok(
-    blockAfterIncomplete.includes("getIsolationMode"),
-    "should check getIsolationMode for branch isolation mode",
+    helperBlock.includes("getIsolationMode") || helperBlock.includes("isolationMode"),
+    "tryMergeMilestone should check isolation mode for branch mode",
   );
 });