@botbuddy/cli 1.4.1 → 1.5.0

package/src/profile-bootstrap.test.mjs

@@ -13,7 +13,7 @@ test("BOT-1353: the published CLI identifies this profile-bootstrap release", as
     cwd: new URL("..", import.meta.url),
   });
 
-  assert.equal(stdout.trim(), "botbuddy v1.4.1");
+  assert.equal(stdout.trim(), "botbuddy v1.5.0");
 });
 
 test("BOT-1382: profile --help succeeds and documents the subcommands", async () => {

package/src/stack-file-lock.mjs

@@ -0,0 +1,180 @@
+// BOT-904 / BOT-1405 — canonical cross-worktree local Supabase mutex.
+//
+// This module lives in the published CLI so both repository test wrappers and
+// `botbuddy docker hygiene --apply` use the exact same lock path and protocol.
+// macOS has no flock(1), so acquisition uses an atomically linked lockfile with
+// dead/stale-holder recovery.
+import { randomUUID } from "node:crypto";
+import { linkSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { hostname, tmpdir } from "node:os";
+import { join } from "node:path";
+
+let tmpCounter = 0;
+
+export function projectIdFromConfig(configText) {
+  const match = String(configText).match(/^\s*project_id\s*=\s*"([^"]+)"/m);
+  return match ? match[1] : null;
+}
+
+export function dbPortFromConfig(configText) {
+  const lines = String(configText).split(/\r?\n/);
+  let inDb = false;
+  for (const line of lines) {
+    const section = /^\s*\[([^\]]+)\]/.exec(line);
+    if (section) {
+      inDb = section[1].trim() === "db";
+      continue;
+    }
+    if (!inDb) continue;
+    const match = /^\s*port\s*=\s*(\d+)/.exec(line);
+    if (match) return match[1];
+  }
+  return null;
+}
+
+export function lockPathForProject(projectId) {
+  return join(tmpdir(), `botbuddy-stack-${projectId}.lock`);
+}
+
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function reclaimPathForLock(path) {
+  return `${path}.reclaim`;
+}
+
+/** Serialize stale replacement. An abandoned guard fails closed; recursively
+ * stale-stealing a reclaim guard would recreate the race this guard prevents. */
+export async function acquireReclaimGuard(
+  path,
+  { timeoutMs = 300_000, pollMs = 500, now = () => Date.now(), sleep = defaultSleep } = {},
+) {
+  const deadline = now() + timeoutMs;
+  const ownerToken = randomUUID();
+  const tmp = `${path}.${process.pid}.${tmpCounter++}.tmp`;
+  const payload = JSON.stringify({ pid: process.pid, host: hostname(), owner_token: ownerToken });
+  for (;;) {
+    try {
+      writeFileSync(tmp, payload);
+      linkSync(tmp, path);
+      try { unlinkSync(tmp); } catch { /* best-effort temp cleanup */ }
+      let released = false;
+      return {
+        path,
+        release() {
+          if (released) return;
+          released = true;
+          try {
+            const current = JSON.parse(readFileSync(path, "utf8"));
+            if (current.owner_token !== ownerToken) return;
+            unlinkSync(path);
+          } catch { /* already gone, corrupt, or superseded */ }
+        },
+      };
+    } catch (error) {
+      try { unlinkSync(tmp); } catch { /* temp may not exist */ }
+      if (error.code !== "EEXIST") throw error;
+      if (now() >= deadline) {
+        throw new Error(`stack-lock: timed out after ${timeoutMs}ms waiting for stale-reclaim guard ${path}`);
+      }
+      await sleep(pollMs);
+    }
+  }
+}
+
+function inspectExistingLock(path, now, staleMs) {
+  let raw;
+  try { raw = readFileSync(path, "utf8"); } catch { return { exists: false }; }
+  let holder = null;
+  try { holder = JSON.parse(raw); } catch { /* corrupt: use mtime */ }
+  const sameHost = holder && holder.host === hostname();
+  const sameHostDead = sameHost && !isAlive(holder.pid);
+  let tooOld;
+  if (holder) {
+    tooOld = now() - (holder.startedAt ?? 0) > staleMs;
+  } else {
+    let mtimeMs;
+    try { mtimeMs = statSync(path).mtimeMs; } catch { return { exists: false }; }
+    tooOld = now() - mtimeMs > staleMs;
+  }
+  return { exists: true, raw, holder, stealable: sameHost ? sameHostDead : tooOld };
+}
+
+export async function acquireStackLock(
+  path,
+  {
+    timeoutMs = 300_000,
+    staleMs = 900_000,
+    pollMs = 500,
+    now = () => Date.now(),
+    sleep = defaultSleep,
+    acquireReclaim = acquireReclaimGuard,
+  } = {},
+) {
+  const deadline = now() + timeoutMs;
+  const tmp = `${path}.${process.pid}.${tmpCounter++}.tmp`;
+  const ownerToken = randomUUID();
+  const payload = JSON.stringify({
+    pid: process.pid,
+    host: hostname(),
+    startedAt: now(),
+    owner_token: ownerToken,
+  });
+  for (;;) {
+    try {
+      writeFileSync(tmp, payload);
+      linkSync(tmp, path);
+      try { unlinkSync(tmp); } catch { /* best-effort temp cleanup */ }
+      let released = false;
+      return {
+        path,
+        release() {
+          if (released) return;
+          released = true;
+          try {
+            const current = JSON.parse(readFileSync(path, "utf8"));
+            if (current.owner_token !== ownerToken) return;
+            unlinkSync(path);
+          } catch { /* already gone, corrupt, or superseded: never unlink blindly */ }
+        },
+      };
+    } catch (error) {
+      try { unlinkSync(tmp); } catch { /* temp may not exist */ }
+      if (error.code !== "EEXIST") throw error;
+
+      const observed = inspectExistingLock(path, now, staleMs);
+      if (!observed.exists) continue;
+      if (observed.stealable) {
+        const guard = await acquireReclaim(reclaimPathForLock(path), {
+          timeoutMs: Math.max(1, deadline - now()), pollMs, now, sleep,
+        });
+        try {
+          const current = inspectExistingLock(path, now, staleMs);
+          if (current.exists && current.raw === observed.raw && current.stealable) {
+            try { unlinkSync(path); } catch { /* vanished: retry */ }
+          }
+        } finally {
+          guard.release();
+        }
+        continue;
+      }
+      if (now() >= deadline) {
+        throw new Error(
+          `stack-lock: timed out after ${timeoutMs}ms waiting for ${path} ` +
+          `(held by pid ${observed.holder?.pid} on ${observed.holder?.host}). Another worktree ` +
+          "is using the shared local Supabase stack.",
+        );
+      }
+      await sleep(pollMs);
+    }
+  }
+}