bitfab-cli 0.2.97 → 0.2.99

package/dist/index.js

@@ -9834,7 +9834,7 @@ async function createStudioSession({ serviceUrl, apiKey, sessionId, initialPath
 import net2 from "net";
 
 // ../bitfab-plugin-lib/dist/daemon/ensure.js
-import { fork } from "child_process";
+import { execFileSync as execFileSync4, fork } from "child_process";
 import crypto5 from "crypto";
 import fs9 from "fs";
 import net from "net";
@@ -9921,6 +9921,21 @@ async function waitForSocket(socketPath, timeoutMs) {
   }
   throw new Error(`daemon did not become ready within ${timeoutMs}ms`);
 }
+async function waitForLockHolderDaemon(socketPath, timeoutMs, localBuild = localBuildFingerprint()) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const ping = await pingSocket(socketPath);
+    if (ping.alive && (localBuild === "unknown" || !ping.build || ping.build === localBuild)) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, ENSURE_POLL_INTERVAL_MS));
+  }
+  const finalPing = await pingSocket(socketPath);
+  if (finalPing.alive) {
+    return;
+  }
+  throw new Error(`daemon did not become ready within ${timeoutMs}ms`);
+}
 function localBuildFingerprint() {
   try {
     const thisDir = path8.dirname(fileURLToPath2(import.meta.url));
@@ -9931,17 +9946,63 @@ function localBuildFingerprint() {
     return "unknown";
   }
 }
-async function killDaemon(pidPath, socketPath) {
-  const pid = readPid(pidPath);
-  if (pid !== null) {
+function findDaemonPids(socketPath) {
+  let out;
+  try {
+    out = execFileSync4("ps", ["-axww", "-o", "pid=,command="], {
+      encoding: "utf-8"
+    });
+  } catch {
+    return [];
+  }
+  const pids = [];
+  for (const line of out.split("\n")) {
+    const match = line.trim().match(/^(\d+)\s+(.*)$/);
+    if (!match) {
+      continue;
+    }
+    const pid = Number.parseInt(match[1], 10);
+    const command = match[2];
+    if (pid === process.pid || Number.isNaN(pid)) {
+      continue;
+    }
+    if (command.includes("daemon/main.js") && commandTargetsSocket(command, socketPath)) {
+      pids.push(pid);
+    }
+  }
+  return pids;
+}
+function commandTargetsSocket(command, socketPath) {
+  let idx = command.indexOf(socketPath);
+  while (idx !== -1) {
+    const after = command[idx + socketPath.length];
+    if (after === void 0 || after === " ") {
+      return true;
+    }
+    idx = command.indexOf(socketPath, idx + 1);
+  }
+  return false;
+}
+async function reapAllDaemons(socketPath, pidPath) {
+  const pids = new Set(findDaemonPids(socketPath));
+  const pidfilePid = readPid(pidPath);
+  if (pidfilePid !== null) {
+    pids.add(pidfilePid);
+  }
+  for (const pid of pids) {
     try {
       process.kill(pid, "SIGTERM");
     } catch {
     }
-    const deadline = Date.now() + 5e3;
-    while (processIsAlive(pid) && Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, 50));
+  }
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (![...pids].some(processIsAlive)) {
+      break;
     }
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  for (const pid of pids) {
     if (processIsAlive(pid)) {
       try {
         process.kill(pid, "SIGKILL");
@@ -10015,18 +10076,17 @@ async function ensureDaemon(socketPath = SOCKET_PATH, pidPath = PID_FILE_PATH) {
       const localBuild = localBuildFingerprint();
       if (ping.build && ping.build !== localBuild && localBuild !== "unknown") {
         console.error(`[daemon] build mismatch (running: ${ping.build}, local: ${localBuild}), restarting`);
-        await killDaemon(pidPath, socketPath);
       } else {
         return;
       }
     }
   }
   if (!acquireLock(socketPath)) {
-    await waitForSocket(socketPath, ENSURE_TIMEOUT_MS);
+    await waitForLockHolderDaemon(socketPath, ENSURE_TIMEOUT_MS);
     return;
   }
   try {
-    cleanupStaleFiles(socketPath, pidPath);
+    await reapAllDaemons(socketPath, pidPath);
     spawnDaemon(socketPath, pidPath);
     await waitForSocket(socketPath, ENSURE_TIMEOUT_MS);
   } finally {
@@ -10128,6 +10188,19 @@ var DaemonClient = class {
       throw new Error(res.error);
     }
   }
+  /**
+   * Forget a session from the daemon's in-memory map (the recovery path after
+   * a `not-responding` gate). Matched daemon-side on the studio sessionId, so a
+   * session re-bound under the same key is never touched. Returns how many
+   * entries were dropped (0 or 1).
+   */
+  async clear(sessionId) {
+    const res = await this.sendCommand({ cmd: "clear", sessionId });
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+    return res.cleared;
+  }
   async detach(key) {
     const res = await this.sendCommand({ cmd: "detach", key });
     if (!res.ok) {
@@ -10239,6 +10312,8 @@ var DirectChannel = class {
   forceCloseWindow(sessionId) {
     closeStudioWindowsBySession(sessionId);
   }
+  async clearSession(_sessionId) {
+  }
   subscribe(sessionId, onEvent, onError) {
     const abortController = new AbortController();
     const done = (async () => {
@@ -10330,6 +10405,10 @@ var DaemonChannel = class _DaemonChannel {
   }
   forceCloseWindow(_sessionId) {
   }
+  async clearSession(sessionId) {
+    await this.client.clear(sessionId).catch(() => {
+    });
+  }
   subscribe(_sessionId, onEvent, onError) {
     const done = new Promise((resolve) => {
       this.doneResolve = resolve;
@@ -10385,6 +10464,9 @@ function withDirectFallback(primary, apiKey, serviceUrl) {
     forceCloseWindow(sessionId) {
       active.forceCloseWindow(sessionId);
     },
+    async clearSession(sessionId) {
+      await active.clearSession(sessionId);
+    },
     subscribe(sessionId, onEvent, onError) {
       return active.subscribe(sessionId, onEvent, onError);
     },
@@ -10453,13 +10535,13 @@ async function reportHandoff(apiKey, pluginVersion, platform2, body) {
 import crypto7 from "crypto";
 
 // ../bitfab-plugin-lib/dist/frontmostApp.js
-import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync5, spawn as spawn2 } from "child_process";
 import os10 from "os";
 function findAncestorApp() {
   try {
     let pid = process.ppid;
     while (pid > 1) {
-      const output = execFileSync4("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { stdio: "pipe", encoding: "utf-8" }).trim();
+      const output = execFileSync5("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { stdio: "pipe", encoding: "utf-8" }).trim();
       const match = output.match(/^\s*(\d+)\s+(.+)$/);
       if (!match) {
         break;
@@ -10518,19 +10600,19 @@ function getFrontmostApp() {
   const platform2 = os10.platform();
   try {
     if (platform2 === "darwin") {
-      return execFileSync4("osascript", [
+      return execFileSync5("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 execFileSync4("xdotool", ["getactivewindow"], {
+      return execFileSync5("xdotool", ["getactivewindow"], {
         stdio: "pipe",
         encoding: "utf-8"
       }).trim();
     }
     if (platform2 === "win32") {
-      return execFileSync4("powershell.exe", [
+      return execFileSync5("powershell.exe", [
         "-NoProfile",
         "-Command",
         `Add-Type -MemberDefinition '[DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();' -Name WinFocus -Namespace Bitfab; [Bitfab.WinFocus]::GetForegroundWindow().ToInt64()`

package/package.json

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