bitfab-cli 0.2.128 → 0.2.130

package/dist/index.js

@@ -5152,8 +5152,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path19) {
-      let input = path19;
+    function removeDotSegments(path20) {
+      let input = path20;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -5352,8 +5352,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path19, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path19 && path19 !== "/" ? path19 : void 0;
+        const [path20, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path20 && path20 !== "/" ? path20 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -8715,12 +8715,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs21, exportName) {
+    function addFormats(ajv, list, fs23, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs21[f]);
+        ajv.addFormat(f, fs23[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -8924,18 +8924,18 @@ async function closeStudio(client, message) {
     data: message ? { message } : {}
   });
 }
-async function navigateStudio(client, path19) {
-  if (!isValidStudioRoute(path19)) {
-    throw new Error(`Studio route not allowed: ${path19}`);
+async function navigateStudio(client, path20) {
+  if (!isValidStudioRoute(path20)) {
+    throw new Error(`Studio route not allowed: ${path20}`);
   }
   return pushAgentSessionEvent(client, {
     type: "agent:navigate",
-    data: { path: path19 }
+    data: { path: path20 }
   });
 }
 var STUDIO_NAVIGATE_ACK_TIMEOUT_MS = 12e3;
 var PING_PONG_TIMEOUT_MS = 5e3;
-function awaitNavigateAck(client, path19, ackTimeoutMs, startCursor) {
+function awaitNavigateAck(client, path20, ackTimeoutMs, startCursor) {
   const abortController = new AbortController();
   let timer = null;
   const result = new Promise((resolve2) => {
@@ -8943,7 +8943,7 @@ function awaitNavigateAck(client, path19, ackTimeoutMs, startCursor) {
       resolve2({ acked: false, reason: "timeout" });
       abortController.abort();
     }, ackTimeoutMs);
-    const pathOnly = path19.split("?")[0];
+    const pathOnly = path20.split("?")[0];
     pollAgentSessionEvents({
       serviceUrl: client.serviceUrl,
       apiKey: client.apiKey,
@@ -9029,18 +9029,18 @@ function awaitPong(client, pingTs) {
     });
   });
 }
-async function navigateStudioAndAwaitAck(client, path19, opts = {}) {
+async function navigateStudioAndAwaitAck(client, path20, opts = {}) {
   const ackTimeoutMs = opts.ackTimeoutMs ?? STUDIO_NAVIGATE_ACK_TIMEOUT_MS;
-  if (!isValidStudioRoute(path19)) {
+  if (!isValidStudioRoute(path20)) {
     return { acked: false, reason: "invalid-route" };
   }
   const startCursor = await fetchStreamTip(client);
   try {
-    await navigateStudio(client, path19);
+    await navigateStudio(client, path20);
   } catch {
     return { acked: false, reason: "push-failed" };
   }
-  const result = await awaitNavigateAck(client, path19, ackTimeoutMs, startCursor);
+  const result = await awaitNavigateAck(client, path20, ackTimeoutMs, startCursor);
   if (result.acked || result.reason !== "timeout") {
     return result;
   }
@@ -9397,7 +9397,8 @@ function readLegacySession() {
       browserConnected: false,
       lastEventAt: null,
       lastEventCursor: null,
-      agentSessionKey: null
+      agentSessionKey: null,
+      worktreeRoot: null
     };
   } catch {
     return null;
@@ -9419,7 +9420,8 @@ function writeActiveStudioSession(init) {
     browserConnected: false,
     lastEventAt: null,
     lastEventCursor: null,
-    agentSessionKey: null
+    agentSessionKey: null,
+    worktreeRoot: null
   };
   writeStateFile(sessionFilePath(), state);
 }
@@ -9935,7 +9937,7 @@ function extractCommandName(argv) {
 }
 
 // ../bitfab-plugin-lib/dist/studioChannel.js
-import crypto7 from "crypto";
+import crypto8 from "crypto";
 
 // ../bitfab-plugin-lib/dist/commands/createStudioSession.js
 function ensureStudioPath(p5) {
@@ -9974,19 +9976,39 @@ async function createStudioSession({ serviceUrl, apiKey, sessionId, initialPath
 import net2 from "net";
 
 // ../bitfab-plugin-lib/dist/daemon/ensure.js
-import { execFileSync as execFileSync4, fork } from "child_process";
-import crypto5 from "crypto";
-import fs9 from "fs";
+import { execFileSync as execFileSync5, fork } from "child_process";
+import crypto6 from "crypto";
+import fs10 from "fs";
 import net from "net";
-import path8 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // ../bitfab-plugin-lib/dist/daemon/protocol.js
+import crypto5 from "crypto";
 import os9 from "os";
 import path7 from "path";
 var BITFAB_CONFIG_DIR = path7.join(os9.homedir(), ".config", "bitfab");
 var SOCKET_PATH = path7.join(BITFAB_CONFIG_DIR, "studio-daemon.sock");
 var PID_FILE_PATH = path7.join(BITFAB_CONFIG_DIR, "studio-daemon.pid");
+var DAEMON_DIR = path7.join(BITFAB_CONFIG_DIR, "daemon");
+var SINGLETON_DAEMON_PATHS = {
+  socketPath: SOCKET_PATH,
+  pidPath: PID_FILE_PATH,
+  metaPath: null,
+  worktreeRoot: null
+};
+function hashWorktreeRoot(worktreeRoot) {
+  return crypto5.createHash("sha256").update(worktreeRoot).digest("hex").slice(0, 12);
+}
+function devDaemonPaths(worktreeRoot) {
+  const base = path7.join(DAEMON_DIR, `dev-${hashWorktreeRoot(worktreeRoot)}`);
+  return {
+    socketPath: `${base}.sock`,
+    pidPath: `${base}.pid`,
+    metaPath: `${base}.meta.json`,
+    worktreeRoot
+  };
+}
 var BROWSER_HEALTH_INTERVAL_MS = 10 * 1e3;
 var ENSURE_POLL_INTERVAL_MS = 200;
 var ENSURE_TIMEOUT_MS = 5e3;
@@ -10002,9 +10024,108 @@ function isPush(msg) {
   return typeof msg === "object" && msg !== null && "event" in msg;
 }
 
+// ../bitfab-plugin-lib/dist/daemon/scope.js
+import { execFileSync as execFileSync4 } from "child_process";
+import fs9 from "fs";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function resolveWorktreeRoot(fromDir) {
+  try {
+    const out = execFileSync4("git", ["rev-parse", "--show-toplevel"], {
+      cwd: fromDir,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+function moduleDir() {
+  return path8.dirname(fileURLToPath2(import.meta.url));
+}
+var PROD_INSTALL_MARKERS = [
+  `${path8.sep}.claude${path8.sep}plugins${path8.sep}`,
+  `${path8.sep}.codex${path8.sep}plugins${path8.sep}`,
+  `${path8.sep}.cursor${path8.sep}plugins${path8.sep}`,
+  `${path8.sep}.npm${path8.sep}`
+];
+function isProdInstallPath(dir) {
+  return PROD_INSTALL_MARKERS.some((marker) => dir.includes(marker));
+}
+function resolveDevWorktreeRoot() {
+  const dir = moduleDir();
+  if (isProdInstallPath(dir)) {
+    return null;
+  }
+  return resolveWorktreeRoot(dir);
+}
+function resolveDaemonPaths() {
+  const worktreeRoot = resolveDevWorktreeRoot();
+  return worktreeRoot ? devDaemonPaths(worktreeRoot) : SINGLETON_DAEMON_PATHS;
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function unlinkQuietly(...paths) {
+  for (const p5 of paths) {
+    try {
+      fs9.unlinkSync(p5);
+    } catch {
+    }
+  }
+}
+function readMeta(metaPath) {
+  try {
+    const parsed = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
+    if (typeof parsed.pid === "number" && typeof parsed.worktreeRoot === "string" && typeof parsed.socketPath === "string" && typeof parsed.pidPath === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function sweepZombieDaemons(dir = DAEMON_DIR) {
+  let entries;
+  try {
+    entries = fs9.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (!name.startsWith("dev-") || !name.endsWith(".meta.json")) {
+      continue;
+    }
+    const metaPath = path8.join(dir, name);
+    const meta3 = readMeta(metaPath);
+    if (!meta3) {
+      unlinkQuietly(metaPath);
+      continue;
+    }
+    const pidAlive = processIsAlive(meta3.pid);
+    const worktreeExists = fs9.existsSync(meta3.worktreeRoot);
+    if (pidAlive && worktreeExists) {
+      continue;
+    }
+    if (!pidAlive) {
+      unlinkQuietly(meta3.socketPath, meta3.pidPath, `${meta3.socketPath}.lock`, metaPath);
+      continue;
+    }
+    try {
+      process.kill(meta3.pid, "SIGHUP");
+    } catch {
+    }
+  }
+}
+
 // ../bitfab-plugin-lib/dist/daemon/ensure.js
 var LOCK_STALE_MS = 1e4;
-function processIsAlive(pid) {
+function processIsAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -10014,7 +10135,7 @@ function processIsAlive(pid) {
 }
 function readPid(pidPath) {
   try {
-    const raw = fs9.readFileSync(pidPath, "utf-8").trim();
+    const raw = fs10.readFileSync(pidPath, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isNaN(pid) ? null : pid;
   } catch {
@@ -10078,10 +10199,10 @@ async function waitForLockHolderDaemon(socketPath, timeoutMs, localBuild = local
 }
 function localBuildFingerprint() {
   try {
-    const thisDir = path8.dirname(fileURLToPath2(import.meta.url));
-    const serverPath = path8.join(thisDir, "server.js");
-    const content = fs9.readFileSync(serverPath);
-    return crypto5.createHash("sha256").update(content).digest("hex").slice(0, 16);
+    const thisDir = path9.dirname(fileURLToPath3(import.meta.url));
+    const serverPath = path9.join(thisDir, "server.js");
+    const content = fs10.readFileSync(serverPath);
+    return crypto6.createHash("sha256").update(content).digest("hex").slice(0, 16);
   } catch {
     return "unknown";
   }
@@ -10089,7 +10210,7 @@ function localBuildFingerprint() {
 function findDaemonPids(socketPath) {
   let out;
   try {
-    out = execFileSync4("ps", ["-axww", "-o", "pid=,command="], {
+    out = execFileSync5("ps", ["-axww", "-o", "pid=,command="], {
       encoding: "utf-8"
     });
   } catch {
@@ -10123,9 +10244,9 @@ function commandTargetsSocket(command, socketPath) {
   }
   return false;
 }
-async function reapAllDaemons(socketPath, pidPath) {
-  const pids = new Set(findDaemonPids(socketPath));
-  const pidfilePid = readPid(pidPath);
+async function reapAllDaemons(paths) {
+  const pids = new Set(findDaemonPids(paths.socketPath));
+  const pidfilePid = readPid(paths.pidPath);
   if (pidfilePid !== null) {
     pids.add(pidfilePid);
   }
@@ -10137,43 +10258,54 @@ async function reapAllDaemons(socketPath, pidPath) {
   }
   const deadline = Date.now() + 5e3;
   while (Date.now() < deadline) {
-    if (![...pids].some(processIsAlive)) {
+    if (![...pids].some(processIsAlive2)) {
       break;
     }
     await new Promise((r) => setTimeout(r, 50));
   }
   for (const pid of pids) {
-    if (processIsAlive(pid)) {
+    if (processIsAlive2(pid)) {
       try {
         process.kill(pid, "SIGKILL");
       } catch {
       }
     }
   }
-  cleanupStaleFiles(socketPath, pidPath);
+  cleanupStaleFiles(paths);
 }
-function spawnDaemon(socketPath, pidPath) {
-  const thisDir = path8.dirname(fileURLToPath2(import.meta.url));
-  const mainPath = path8.join(thisDir, "main.js");
-  if (!fs9.existsSync(mainPath)) {
+function spawnDaemon(paths) {
+  const thisDir = path9.dirname(fileURLToPath3(import.meta.url));
+  const mainPath = path9.join(thisDir, "main.js");
+  if (!fs10.existsSync(mainPath)) {
     throw new DaemonUnavailableError(`daemon entry point not found: ${mainPath}`);
   }
-  const child = fork(mainPath, [socketPath, pidPath], {
+  const child = fork(mainPath, [
+    paths.socketPath,
+    paths.pidPath,
+    paths.metaPath ?? "",
+    paths.worktreeRoot ?? ""
+  ], {
     detached: true,
     stdio: "ignore",
     execArgv: []
   });
   child.unref();
 }
-function cleanupStaleFiles(socketPath, pidPath) {
+function cleanupStaleFiles(paths) {
   try {
-    fs9.unlinkSync(socketPath);
+    fs10.unlinkSync(paths.socketPath);
   } catch {
   }
   try {
-    fs9.unlinkSync(pidPath);
+    fs10.unlinkSync(paths.pidPath);
   } catch {
   }
+  if (paths.metaPath) {
+    try {
+      fs10.unlinkSync(paths.metaPath);
+    } catch {
+    }
+  }
 }
 function lockPath(socketPath) {
   return `${socketPath}.lock`;
@@ -10181,8 +10313,8 @@ function lockPath(socketPath) {
 function acquireLock(socketPath) {
   const lock = lockPath(socketPath);
   try {
-    fs9.mkdirSync(path8.dirname(lock), { recursive: true });
-    fs9.writeFileSync(lock, `${process.pid}
+    fs10.mkdirSync(path9.dirname(lock), { recursive: true });
+    fs10.writeFileSync(lock, `${process.pid}
 `, { flag: "wx" });
     return true;
   } catch (err) {
@@ -10190,10 +10322,10 @@ function acquireLock(socketPath) {
       return true;
     }
     try {
-      const stat = fs9.statSync(lock);
+      const stat = fs10.statSync(lock);
       if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-        fs9.unlinkSync(lock);
-        fs9.writeFileSync(lock, `${process.pid}
+        fs10.unlinkSync(lock);
+        fs10.writeFileSync(lock, `${process.pid}
 `, { flag: "wx" });
         return true;
       }
@@ -10204,13 +10336,15 @@ function acquireLock(socketPath) {
 }
 function releaseLock(socketPath) {
   try {
-    fs9.unlinkSync(lockPath(socketPath));
+    fs10.unlinkSync(lockPath(socketPath));
   } catch {
   }
 }
-async function ensureDaemon(socketPath = SOCKET_PATH, pidPath = PID_FILE_PATH) {
+async function ensureDaemon(paths = SINGLETON_DAEMON_PATHS) {
+  const { socketPath, pidPath } = paths;
+  sweepZombieDaemons();
   const pid = readPid(pidPath);
-  if (pid !== null && processIsAlive(pid)) {
+  if (pid !== null && processIsAlive2(pid)) {
     const ping = await pingSocket(socketPath);
     if (ping.alive) {
       const localBuild = localBuildFingerprint();
@@ -10226,8 +10360,8 @@ async function ensureDaemon(socketPath = SOCKET_PATH, pidPath = PID_FILE_PATH) {
     return;
   }
   try {
-    await reapAllDaemons(socketPath, pidPath);
-    spawnDaemon(socketPath, pidPath);
+    await reapAllDaemons(paths);
+    spawnDaemon(paths);
     await waitForSocket(socketPath, ENSURE_TIMEOUT_MS);
   } finally {
     releaseLock(socketPath);
@@ -10241,12 +10375,14 @@ var DaemonClient = class {
   responseQueue = [];
   eventHandler = null;
   disconnectHandler = null;
+  paths;
   socketPath;
-  constructor(socketPath) {
-    this.socketPath = socketPath ?? SOCKET_PATH;
+  constructor(paths = SINGLETON_DAEMON_PATHS) {
+    this.paths = paths;
+    this.socketPath = paths.socketPath;
   }
   async connect() {
-    await ensureDaemon(this.socketPath);
+    await ensureDaemon(this.paths);
     return new Promise((resolve2, reject) => {
       const socket = net2.createConnection(this.socketPath, () => {
         this.socket = socket;
@@ -10379,16 +10515,16 @@ var DaemonClient = class {
 };
 
 // ../bitfab-plugin-lib/dist/studioEventLog.js
-import crypto6 from "crypto";
-import fs10 from "fs";
+import crypto7 from "crypto";
+import fs11 from "fs";
 import os10 from "os";
-import path9 from "path";
-var SESSIONS_DIR2 = path9.join(os10.homedir(), ".config", "bitfab", "sessions");
+import path10 from "path";
+var SESSIONS_DIR2 = path10.join(os10.homedir(), ".config", "bitfab", "sessions");
 function shortHash2(input) {
-  return crypto6.createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return crypto7.createHash("sha256").update(input).digest("hex").slice(0, 16);
 }
 function eventLogPathForKey(key) {
-  return path9.join(SESSIONS_DIR2, `${shortHash2(key)}.events.jsonl`);
+  return path10.join(SESSIONS_DIR2, `${shortHash2(key)}.events.jsonl`);
 }
 function studioEventToLogLine(event, sessionId) {
   const data = event.data ?? {};
@@ -10403,21 +10539,21 @@ function studioEventToLogLine(event, sessionId) {
 function appendStudioEvent(key, line) {
   try {
     const target = eventLogPathForKey(key);
-    fs10.mkdirSync(path9.dirname(target), { recursive: true });
-    fs10.appendFileSync(target, `${JSON.stringify(line)}
+    fs11.mkdirSync(path10.dirname(target), { recursive: true });
+    fs11.appendFileSync(target, `${JSON.stringify(line)}
 `);
   } catch {
   }
 }
 function truncateStudioEventLog(key) {
   try {
-    fs10.rmSync(eventLogPathForKey(key), { force: true });
+    fs11.rmSync(eventLogPathForKey(key), { force: true });
   } catch {
   }
 }
 function readStudioEventLogTail(key, fromLine = 1) {
   try {
-    const raw = fs10.readFileSync(eventLogPathForKey(key), "utf-8");
+    const raw = fs11.readFileSync(eventLogPathForKey(key), "utf-8");
     const all = raw.split("\n").filter((l) => l.length > 0);
     const start = Math.max(0, fromLine - 1);
     const slice = all.slice(start);
@@ -10473,17 +10609,17 @@ function resolveStudioInitialPath(input) {
   return DEFAULT_STUDIO_PATH;
 }
 function buildStudioSessionUrl(args) {
-  const { serviceUrl, path: path19, sessionId } = args;
-  if (path19.includes("session=")) {
-    return `${serviceUrl}${path19}`;
+  const { serviceUrl, path: path20, sessionId } = args;
+  if (path20.includes("session=")) {
+    return `${serviceUrl}${path20}`;
   }
-  const separator = path19.includes("?") ? "&" : "?";
-  return `${serviceUrl}${path19}${separator}session=${encodeURIComponent(sessionId)}`;
+  const separator = path20.includes("?") ? "&" : "?";
+  return `${serviceUrl}${path20}${separator}session=${encodeURIComponent(sessionId)}`;
 }
 
 // ../bitfab-plugin-lib/dist/studioChannel.js
-function stripSessionId(path19, sessionId) {
-  return sessionId ? path19.split(sessionId).join("__SID__") : path19;
+function stripSessionId(path20, sessionId) {
+  return sessionId ? path20.split(sessionId).join("__SID__") : path20;
 }
 var DirectChannel = class {
   apiKey;
@@ -10498,10 +10634,10 @@ var DirectChannel = class {
   isPersistent() {
     return false;
   }
-  async openOrNavigate(path19, opts) {
+  async openOrNavigate(path20, opts) {
     if (!this.apiKey) {
-      const sessionId2 = opts?.sessionId ?? crypto7.randomUUID();
-      const initialPath = resolveStudioInitialPath(path19);
+      const sessionId2 = opts?.sessionId ?? crypto8.randomUUID();
+      const initialPath = resolveStudioInitialPath(path20);
       const live = readActiveStudioSession();
       if (live && live.source === "direct" && !live.authenticated && live.windowState !== "closed" && live.serviceUrl === this.serviceUrl && live.currentPath != null && stripSessionId(live.currentPath, live.sessionId) === stripSessionId(initialPath, sessionId2)) {
         return { sessionId: live.sessionId, opened: false };
@@ -10532,20 +10668,20 @@ var DirectChannel = class {
         serviceUrl: existing.serviceUrl,
         apiKey: this.apiKey,
         sessionId: existing.sessionId
-      }, path19);
+      }, path20);
       if (!ack.acked) {
         throw new StudioNavigationError(ack.reason ?? "unknown", ack.blockedReason, existing.sessionId);
       }
-      updateActiveStudioSession({ currentPath: path19 });
+      updateActiveStudioSession({ currentPath: path20 });
       return { sessionId: existing.sessionId, opened: false };
     }
     truncateStudioEventLog(resolveAgentSessionKey());
-    const sessionId = opts?.sessionId ?? crypto7.randomUUID();
+    const sessionId = opts?.sessionId ?? crypto8.randomUUID();
     const session = await createStudioSession({
       serviceUrl: this.serviceUrl,
       apiKey: this.apiKey,
       sessionId,
-      initialPath: path19,
+      initialPath: path20,
       clientHeaders: opts?.clientHeaders
     });
     return { sessionId: session.sessionId, opened: true };
@@ -10601,7 +10737,7 @@ var DaemonChannel = class _DaemonChannel {
     this.serviceUrl = serviceUrl;
   }
   static async connect(apiKey, serviceUrl) {
-    const client = new DaemonClient();
+    const client = new DaemonClient(resolveDaemonPaths());
     await client.connect();
     const key = resolveAgentSessionKey();
     return new _DaemonChannel(client, key, apiKey, serviceUrl);
@@ -10612,18 +10748,18 @@ var DaemonChannel = class _DaemonChannel {
   isPersistent() {
     return true;
   }
-  async openOrNavigate(path19, opts) {
+  async openOrNavigate(path20, opts) {
     const openRes = await this.client.open({
       key: this.key,
       serviceUrl: this.serviceUrl,
       apiKey: this.apiKey,
       sessionId: opts?.sessionId,
-      initialPath: path19,
+      initialPath: path20,
       clientHeaders: opts?.clientHeaders,
       focusTarget: opts?.focusTarget
     });
     if (openRes.reconnected) {
-      const navRes = await this.client.navigate(this.key, path19);
+      const navRes = await this.client.navigate(this.key, path20);
       if (!navRes.acked) {
         this.client.destroy();
         throw new StudioNavigationError(navRes.reason ?? "unknown", void 0, openRes.sessionId);
@@ -10632,7 +10768,7 @@ var DaemonChannel = class _DaemonChannel {
         sessionId: openRes.sessionId,
         serviceUrl: this.serviceUrl,
         source: "daemon",
-        currentPath: path19
+        currentPath: path20
       });
       return { sessionId: openRes.sessionId, opened: false };
     }
@@ -10640,7 +10776,7 @@ var DaemonChannel = class _DaemonChannel {
       sessionId: openRes.sessionId,
       serviceUrl: this.serviceUrl,
       source: "daemon",
-      currentPath: path19
+      currentPath: path20
     });
     return { sessionId: openRes.sessionId, opened: true };
   }
@@ -10693,9 +10829,9 @@ function isDaemonEnabled() {
 function withDirectFallback(primary, apiKey, serviceUrl) {
   let active = primary;
   return {
-    async openOrNavigate(path19, opts) {
+    async openOrNavigate(path20, opts) {
       try {
-        return await active.openOrNavigate(path19, opts);
+        return await active.openOrNavigate(path20, opts);
       } catch (err) {
         if (err instanceof StudioNavigationError || active !== primary) {
           throw err;
@@ -10703,7 +10839,7 @@ function withDirectFallback(primary, apiKey, serviceUrl) {
         console.error(`daemon failed, falling back to direct: ${err instanceof Error ? err.message : String(err)}`);
         active.destroy();
         active = new DirectChannel(apiKey, serviceUrl);
-        return active.openOrNavigate(path19, opts);
+        return active.openOrNavigate(path20, opts);
       }
     },
     async close(sessionId, message) {
@@ -10754,12 +10890,12 @@ var semver3 = __toESM(require_semver2(), 1);
 
 // ../bitfab-plugin-lib/dist/installedSdk.js
 var semver2 = __toESM(require_semver2(), 1);
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 
 // ../bitfab-plugin-lib/dist/workspaces.js
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 
 // ../bitfab-plugin-lib/dist/analytics.js
 async function reportHandoff(apiKey, pluginVersion, platform2, body) {
@@ -10783,16 +10919,16 @@ async function reportHandoff(apiKey, pluginVersion, platform2, body) {
 }
 
 // ../bitfab-plugin-lib/dist/commands/openStudioTo.js
-import crypto8 from "crypto";
+import crypto9 from "crypto";
 
 // ../bitfab-plugin-lib/dist/frontmostApp.js
-import { execFileSync as execFileSync5, spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync6, spawn as spawn2 } from "child_process";
 import os11 from "os";
 function findAncestorApp() {
   try {
     let pid = process.ppid;
     while (pid > 1) {
-      const output = execFileSync5("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { stdio: "pipe", encoding: "utf-8" }).trim();
+      const output = execFileSync6("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { stdio: "pipe", encoding: "utf-8" }).trim();
       const match = output.match(/^\s*(\d+)\s+(.+)$/);
       if (!match) {
         break;
@@ -10851,19 +10987,19 @@ function getFrontmostApp() {
   const platform2 = os11.platform();
   try {
     if (platform2 === "darwin") {
-      return execFileSync5("osascript", [
+      return execFileSync6("osascript", [
         "-e",
         'tell application "System Events" to get name of first process whose frontmost is true'
       ], { stdio: "pipe", encoding: "utf-8" }).trim();
     }
     if (platform2 === "linux") {
-      return execFileSync5("xdotool", ["getactivewindow"], {
+      return execFileSync6("xdotool", ["getactivewindow"], {
         stdio: "pipe",
         encoding: "utf-8"
       }).trim();
     }
     if (platform2 === "win32") {
-      return execFileSync5("powershell.exe", [
+      return execFileSync6("powershell.exe", [
         "-NoProfile",
         "-Command",
         `Add-Type -MemberDefinition '[DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();' -Name WinFocus -Namespace Bitfab; [Bitfab.WinFocus]::GetForegroundWindow().ToInt64()`
@@ -11025,7 +11161,7 @@ function createEventSubscription(channel, sessionId, onEvent, restoreFocus) {
     done: sub.done
   };
 }
-async function openStudioTo(path19, opts = {}) {
+async function openStudioTo(path20, opts = {}) {
   const config2 = getConfig();
   const serviceUrl = config2.serviceUrl;
   const apiKey = !opts.forceLogin && hasCredentials() ? config2.apiKey : null;
@@ -11102,13 +11238,13 @@ async function openStudioTo(path19, opts = {}) {
     };
   };
   if (!apiKey) {
-    const destination = opts.freshWindowPath ?? path19;
+    const destination = opts.freshWindowPath ?? path20;
     const destSeparator = destination.includes("?") ? "&" : "?";
     const buildSignInPath = (sid) => {
       const redirectPath = `${destination}${destSeparator}session=${encodeURIComponent(sid)}&pluginLogin=true`;
       return `/studio/sign-in?redirect_url=${encodeURIComponent(redirectPath)}&session=${encodeURIComponent(sid)}`;
     };
-    const requestedSessionId = crypto8.randomUUID();
+    const requestedSessionId = crypto9.randomUUID();
     const openResult = await channel.openOrNavigate(buildSignInPath(requestedSessionId), {
       clientHeaders: opts.clientHeaders,
       sessionId: requestedSessionId,
@@ -11144,7 +11280,7 @@ async function openStudioTo(path19, opts = {}) {
     channel.setApiKey(loginApiKey);
     return finish(sessionId2, openResult.opened, loginApiKey);
   }
-  const { sessionId, opened } = await channel.openOrNavigate(path19, {
+  const { sessionId, opened } = await channel.openOrNavigate(path20, {
     clientHeaders: opts.clientHeaders,
     focusTarget: focusTarget ?? void 0
   });
@@ -12011,10 +12147,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path19) {
-  if (!path19)
+function getElementAtPath(obj, path20) {
+  if (!path20)
     return obj;
-  return path19.reduce((acc, key) => acc?.[key], obj);
+  return path20.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12397,11 +12533,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path19, issues) {
+function prefixIssues(path20, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path19);
+    iss.path.unshift(path20);
     return iss;
   });
 }
@@ -12584,7 +12720,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path19 = []) => {
+  const processError = (error49, path20 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12594,7 +12730,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path19, ...issue2.path];
+        const fullpath = [...path20, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12626,8 +12762,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path19) {
+  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path20) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24604,13 +24740,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path19 = ref.slice(1).split("/").filter(Boolean);
-  if (path19.length === 0) {
+  const path20 = ref.slice(1).split("/").filter(Boolean);
+  if (path20.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path19[0] === defsKey) {
-    const key = path19[1];
+  if (path20[0] === defsKey) {
+    const key = path20[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -25046,6 +25182,10 @@ import { writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 
+// ../bitfab-plugin-lib/dist/commands/reapDaemon.js
+import fs14 from "fs";
+import net3 from "net";
+
 // ../bitfab-plugin-lib/dist/commands/replayProgress.js
 import { spawn as spawn4 } from "child_process";
 import { createWriteStream, existsSync, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
@@ -25054,18 +25194,18 @@ import { createInterface } from "readline";
 var HEARTBEAT_MS = Number(process.env.BITFAB_REPLAY_HEARTBEAT_MS) || 12e3;
 
 // ../bitfab-plugin-lib/dist/activePreviewSession.js
-import fs13 from "fs";
+import fs15 from "fs";
 import os12 from "os";
-import path12 from "path";
-var FILE_PATH = path12.join(os12.homedir(), ".config", "bitfab", "active-preview-session.json");
+import path13 from "path";
+var FILE_PATH = path13.join(os12.homedir(), ".config", "bitfab", "active-preview-session.json");
 
 // ../bitfab-plugin-lib/dist/commands/status.js
-import path14 from "path";
+import path15 from "path";
 
 // ../bitfab-plugin-lib/dist/updates.js
-import fs14 from "fs";
+import fs16 from "fs";
 import os13 from "os";
-import path13 from "path";
+import path14 from "path";
 
 // ../bitfab-plugin-lib/dist/commands/update.js
 import { execSync as execSync2 } from "child_process";
@@ -25074,15 +25214,15 @@ import { execSync as execSync2 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // ../bitfab-plugin-lib/dist/hooks/captureHook.js
-import fs15 from "fs";
+import fs17 from "fs";
 
 // ../bitfab-plugin-lib/dist/hooks/userPromptSubmit.js
-import fs16 from "fs";
+import fs18 from "fs";
 
 // ../bitfab-plugin-lib/dist/installScope.js
-import fs17 from "fs";
+import fs19 from "fs";
 import os14 from "os";
-import path15 from "path";
+import path16 from "path";
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/util.js
 var util;
@@ -25443,8 +25583,8 @@ function getErrorMap2() {
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path19, errorMaps, issueData } = params;
-  const fullPath = [...path19, ...issueData.path || []];
+  const { data, path: path20, errorMaps, issueData } = params;
+  const fullPath = [...path20, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -25559,11 +25699,11 @@ var errorUtil;
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path19, key) {
+  constructor(parent, value, path20, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path19;
+    this._path = path20;
     this._key = key;
   }
   get path() {
@@ -30459,9 +30599,9 @@ import process3 from "process";
 
 // src/claude.ts
 import { spawnSync } from "child_process";
-import fs18 from "fs";
+import fs20 from "fs";
 import os15 from "os";
-import path16 from "path";
+import path17 from "path";
 import * as p from "@clack/prompts";
 var REPO = "Project-White-Rabbit/bitfab-claude-plugin";
 var MARKETPLACE = "bitfab";
@@ -30481,7 +30621,7 @@ function runClaudeInstall() {
   }
   s.start("Enabling auto-updates");
   const changed = enableAutoUpdate(
-    path16.join(os15.homedir(), ".claude", "settings.json")
+    path17.join(os15.homedir(), ".claude", "settings.json")
   );
   if (changed) {
     s.stop("Auto-updates enabled");
@@ -30572,8 +30712,8 @@ function runClaude(args) {
 }
 function enableAutoUpdate(settingsPath) {
   let settings = {};
-  if (fs18.existsSync(settingsPath)) {
-    const raw = fs18.readFileSync(settingsPath, "utf-8");
+  if (fs20.existsSync(settingsPath)) {
+    const raw = fs20.readFileSync(settingsPath, "utf-8");
     settings = raw.trim() === "" ? {} : JSON.parse(raw);
   }
   const marketplaces = settings.extraKnownMarketplaces ?? {};
@@ -30587,17 +30727,17 @@ function enableAutoUpdate(settingsPath) {
     autoUpdate: true
   };
   settings.extraKnownMarketplaces = marketplaces;
-  fs18.mkdirSync(path16.dirname(settingsPath), { recursive: true });
-  fs18.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs20.mkdirSync(path17.dirname(settingsPath), { recursive: true });
+  fs20.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
   return true;
 }
 
 // src/codex.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs19 from "fs";
+import fs21 from "fs";
 import os16 from "os";
-import path17 from "path";
+import path18 from "path";
 import * as p2 from "@clack/prompts";
 var REPO2 = "Project-White-Rabbit/bitfab-codex-plugin";
 var PLUGIN_KEY2 = "bitfab@bitfab";
@@ -30625,7 +30765,7 @@ function runCodexInstall() {
   }
   s.start("Enabling bitfab plugin in config");
   const changed = enableCodexPlugin(
-    path17.join(os16.homedir(), ".codex", "config.toml")
+    path18.join(os16.homedir(), ".codex", "config.toml")
   );
   if (changed) {
     s.stop("Plugin enabled");
@@ -30688,8 +30828,8 @@ function runCodexUpdate(args, skipPermissions) {
 }
 function enableCodexPlugin(configPath) {
   let content = "";
-  if (fs19.existsSync(configPath)) {
-    content = fs19.readFileSync(configPath, "utf-8");
+  if (fs21.existsSync(configPath)) {
+    content = fs21.readFileSync(configPath, "utf-8");
   }
   const header = `[plugins."${PLUGIN_KEY2}"]`;
   const desiredSection = `${header}
@@ -30712,8 +30852,8 @@ enabled = true
 
 ${desiredSection}`;
   }
-  fs19.mkdirSync(path17.dirname(configPath), { recursive: true });
-  fs19.writeFileSync(configPath, next);
+  fs21.mkdirSync(path18.dirname(configPath), { recursive: true });
+  fs21.writeFileSync(configPath, next);
   return true;
 }
 function escapeRegex2(s) {
@@ -30824,12 +30964,12 @@ var platform = {
 };
 
 // src/version.ts
-import fs20 from "fs";
-import path18 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import fs22 from "fs";
+import path19 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 var CLI_VERSION = JSON.parse(
-  fs20.readFileSync(
-    path18.join(path18.dirname(fileURLToPath3(import.meta.url)), "../package.json"),
+  fs22.readFileSync(
+    path19.join(path19.dirname(fileURLToPath4(import.meta.url)), "../package.json"),
     "utf-8"
   )
 ).version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitfab-cli",
-  "version": "0.2.128",
+  "version": "0.2.130",
   "description": "Install and configure the Bitfab plugin in Claude Code, Codex, or Cursor.",
   "type": "module",
   "main": "dist/index.js",