@buildautomaton/cli 0.1.32 → 0.1.33

package/dist/index.js

@@ -23962,7 +23962,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.32".length > 0 ? "0.1.32" : "0.0.0-dev";
+var CLI_VERSION = "0.1.33".length > 0 ? "0.1.33" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -25022,6 +25022,30 @@ function runPendingAuth(options) {
   };
 }
 
+// src/dev-servers/manager/dev-server-constants.ts
+var BRIDGE_CLOSE_DEV_SERVER_GRACE_MS = 0;
+var BRIDGE_SHUTDOWN_GRACE_MS = 8e3;
+
+// src/runtime/cli-process-interrupt.ts
+var cliImmediateShutdownRequested = false;
+function requestCliImmediateShutdown() {
+  cliImmediateShutdownRequested = true;
+}
+function isCliImmediateShutdownRequested() {
+  return cliImmediateShutdownRequested;
+}
+async function delayMsUnlessShutdownRequested(ms) {
+  if (ms <= 0) return true;
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    if (isCliImmediateShutdownRequested()) return false;
+    const chunk = Math.min(50, end - Date.now());
+    if (chunk <= 0) break;
+    await new Promise((r) => setTimeout(r, chunk));
+  }
+  return !isCliImmediateShutdownRequested();
+}
+
 // src/sqlite/cli-database.ts
 import sqliteWasm from "node-sqlite3-wasm";
 
@@ -25325,6 +25349,12 @@ var { Database: SqliteDatabase } = sqliteWasm;
 var CLI_SQLITE_SYNC_RETRY_MAX = 40;
 var CLI_SQLITE_ASYNC_RETRY_MAX = 60;
 var CLI_SQLITE_ASYNC_BASE_DELAY_MS = 20;
+var CliSqliteInterrupted = class extends Error {
+  name = "CliSqliteInterrupted";
+  constructor() {
+    super("CLI SQLite interrupted (shutdown)");
+  }
+};
 function applyCliSqliteConcurrencyPragmas(db) {
   try {
     db.exec("PRAGMA journal_mode = WAL");
@@ -25335,7 +25365,7 @@ function applyCliSqliteConcurrencyPragmas(db) {
   } catch {
   }
   try {
-    db.run("PRAGMA busy_timeout = 8000");
+    db.run("PRAGMA busy_timeout = 500");
   } catch {
   }
 }
@@ -25356,26 +25386,42 @@ function safeCloseCliSqliteDatabase(db) {
 function closeAllCliSqliteConnections() {
 }
 function isCliSqliteLockError(e) {
+  if (e instanceof CliSqliteInterrupted) return false;
   const msg = e instanceof Error ? e.message : String(e);
   const lower = msg.toLowerCase();
   return lower.includes("database is locked") || lower.includes("sqlite_busy") || lower.includes("sqlite3_busy") || lower.includes("database") && lower.includes("locked");
 }
 function syncSleepMs(ms) {
   if (ms <= 0) return;
-  try {
-    const sab = new SharedArrayBuffer(4);
-    const ia = new Int32Array(sab);
-    Atomics.wait(ia, 0, 0, Math.min(ms, 1e4));
-  } catch {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const chunk = Math.min(80, deadline - Date.now());
+    if (chunk <= 0) break;
+    try {
+      const sab = new SharedArrayBuffer(4);
+      const ia = new Int32Array(sab);
+      Atomics.wait(ia, 0, 0, chunk);
+    } catch {
+      const end = Date.now() + chunk;
+      while (Date.now() < end) {
+        if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      }
     }
   }
 }
-function asyncDelayMs(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+async function asyncDelayMsInterruptible(ms) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const chunk = Math.min(50, end - Date.now());
+    if (chunk <= 0) break;
+    await new Promise((r) => setTimeout(r, chunk));
+    await yieldToEventLoop();
+  }
 }
 function openCliSqliteConnection(options) {
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
   const sqlitePath = getCliSqlitePath();
   ensureCliSqliteParentDir(sqlitePath);
   const db = new SqliteDatabase(sqlitePath);
@@ -25392,6 +25438,7 @@ function openCliSqliteConnection(options) {
 }
 function withCliSqliteSync(fn, options) {
   for (let attempt = 1; attempt <= CLI_SQLITE_SYNC_RETRY_MAX; attempt++) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     let db;
     try {
       db = openCliSqliteConnection(options);
@@ -25402,6 +25449,7 @@ function withCliSqliteSync(fn, options) {
       }
     } catch (e) {
       safeCloseCliSqliteDatabase(db);
+      if (e instanceof CliSqliteInterrupted) throw e;
       if (!isCliSqliteLockError(e) || attempt === CLI_SQLITE_SYNC_RETRY_MAX) throw e;
       syncSleepMs(Math.min(500, 12 * attempt));
     }
@@ -25411,6 +25459,7 @@ function withCliSqliteSync(fn, options) {
 async function withCliSqlite(fn, options) {
   let lastError;
   for (let attempt = 1; attempt <= CLI_SQLITE_ASYNC_RETRY_MAX; attempt++) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     let db;
     try {
       db = openCliSqliteConnection(options);
@@ -25422,9 +25471,10 @@ async function withCliSqlite(fn, options) {
     } catch (e) {
       lastError = e;
       safeCloseCliSqliteDatabase(db);
+      if (e instanceof CliSqliteInterrupted) throw e;
       if (!isCliSqliteLockError(e) || attempt === CLI_SQLITE_ASYNC_RETRY_MAX) throw e;
       const delayMs = Math.min(600, CLI_SQLITE_ASYNC_BASE_DELAY_MS * attempt);
-      await asyncDelayMs(delayMs);
+      await asyncDelayMsInterruptible(delayMs);
       await yieldToEventLoop();
     }
   }
@@ -25437,9 +25487,9 @@ async function ensureCliSqliteInitialized(options) {
 
 // src/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
+  requestCliImmediateShutdown();
   const say = log2 ?? logImmediate;
   say("Cleaning up connections\u2026");
-  await new Promise((resolve18) => setImmediate(resolve18));
   state.closedByUser = true;
   clearReconnectQuietTimer(state.mainQuiet);
   clearReconnectQuietTimer(state.firehoseQuiet);
@@ -25476,7 +25526,7 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
   }
   if (devServerManager) {
     say("Stopping local dev server processes\u2026");
-    await devServerManager.shutdownAllGraceful();
+    await devServerManager.shutdownAllGraceful({ graceMs: BRIDGE_CLOSE_DEV_SERVER_GRACE_MS });
   }
   try {
     closeAllCliSqliteConnections();
@@ -30722,34 +30772,50 @@ __export(claude_code_acp_client_exports, {
   createClaudeCodeAcpClient: () => createClaudeCodeAcpClient,
   detectLocalAgentPresence: () => detectLocalAgentPresence
 });
-import { execFile as execFile9 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
 
 // src/agents/acp/clients/detect-command-on-path.ts
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify8 } from "node:util";
 var execFileAsync7 = promisify8(execFile8);
-async function isCommandOnPath(command, timeoutMs = 4e3) {
+var COMMAND_ON_PATH_PROBE_TIMEOUT_MS = 750;
+async function execFileShutdownAware(file2, args, timeoutMs) {
+  if (isCliImmediateShutdownRequested()) throw new Error("shutdown");
+  const ac = new AbortController();
+  const shutdownPoll = setInterval(() => {
+    if (isCliImmediateShutdownRequested()) ac.abort();
+  }, 50);
+  shutdownPoll.unref?.();
   try {
-    await execFileAsync7("which", [command], { timeout: timeoutMs });
+    await execFileAsync7(file2, args, { timeout: timeoutMs, signal: ac.signal });
+  } finally {
+    clearInterval(shutdownPoll);
+  }
+}
+async function isCommandOnPath(command, timeoutMs = COMMAND_ON_PATH_PROBE_TIMEOUT_MS) {
+  if (isCliImmediateShutdownRequested()) return false;
+  try {
+    await execFileShutdownAware("which", [command], timeoutMs);
     return true;
   } catch {
     return false;
   }
 }
-
-// src/agents/acp/clients/claude-code-acp-client.ts
-var execFileAsync8 = promisify9(execFile9);
-var BACKEND_LOCAL_AGENT_TYPE = "claude-code";
-async function detectLocalAgentPresence() {
-  if (await isCommandOnPath("claude")) return true;
+async function execProbeShutdownAware(file2, args, timeoutMs) {
+  if (isCliImmediateShutdownRequested()) return false;
   try {
-    await execFileAsync8("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], { timeout: 25e3 });
+    await execFileShutdownAware(file2, args, timeoutMs);
     return true;
   } catch {
     return false;
   }
 }
+
+// src/agents/acp/clients/claude-code-acp-client.ts
+var BACKEND_LOCAL_AGENT_TYPE = "claude-code";
+async function detectLocalAgentPresence() {
+  if (await isCommandOnPath("claude")) return true;
+  return execProbeShutdownAware("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], 3e3);
+}
 function buildClaudeCodeAcpSpawnCommand(base, _sessionMode) {
   return [...base];
 }
@@ -33577,30 +33643,39 @@ import path27 from "node:path";
 function shouldSkipWorkspaceWalkEntry(name) {
   return name.startsWith(".");
 }
-function walkWorkspaceTreeSync(dir, baseDir, onFile) {
+async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
   let names;
   try {
-    names = fs24.readdirSync(dir);
+    names = await fs24.promises.readdir(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (shouldSkipWorkspaceWalkEntry(name)) continue;
+    if (state.n > 0 && state.n % INDEX_WORK_YIELD_EVERY === 0) {
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      await yieldToEventLoop();
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    }
+    state.n++;
     const full = path27.join(dir, name);
     let stat2;
     try {
-      stat2 = fs24.statSync(full);
+      stat2 = await fs24.promises.stat(full);
     } catch {
       continue;
     }
     const relative5 = path27.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
-      walkWorkspaceTreeSync(full, baseDir, onFile);
+      await walkWorkspaceTreeAsync(full, baseDir, onFile, state);
     } else if (stat2.isFile()) {
       onFile(relative5);
     }
   }
 }
+function createWalkYieldState() {
+  return { n: 0 };
+}
 
 // src/files/index/file-index-sqlite-lock.ts
 import fs25 from "node:fs";
@@ -33633,29 +33708,28 @@ function withFileIndexSqliteLock(fn) {
 }
 
 // src/files/index/build-file-index.ts
-var FILE_INDEX_INSERT_BUFFER = 2048;
-function persistFileIndexForResolvedCwd(resolved) {
+var FILE_INDEX_INTERRUPT_CHECK_EVERY = 256;
+function assertNotShutdown() {
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+}
+function persistFileIndexPaths(resolved, paths) {
   return withCliSqliteSync((db) => {
     const h = getCwdHashForFileIndex(resolved);
-    const buf = [];
     let pathCount = 0;
     db.run("BEGIN IMMEDIATE");
     try {
       db.run("DELETE FROM file_index_path WHERE cwd_hash = ?", [h]);
       const ins = db.prepare("INSERT INTO file_index_path (cwd_hash, path) VALUES (?, ?)");
       try {
-        const flushBuf = () => {
-          for (const rel of buf) {
-            ins.run([h, rel]);
+        let batch = 0;
+        for (const rel of paths) {
+          if (++batch >= FILE_INDEX_INTERRUPT_CHECK_EVERY) {
+            batch = 0;
+            assertNotShutdown();
           }
-          pathCount += buf.length;
-          buf.length = 0;
-        };
-        walkWorkspaceTreeSync(resolved, resolved, (rel) => {
-          buf.push(rel);
-          if (buf.length >= FILE_INDEX_INSERT_BUFFER) flushBuf();
-        });
-        flushBuf();
+          ins.run([h, rel]);
+          pathCount += 1;
+        }
       } finally {
         ins.finalize();
       }
@@ -33670,12 +33744,24 @@ function persistFileIndexForResolvedCwd(resolved) {
     return pathCount;
   });
 }
+async function collectWorkspacePathsAsync(resolved) {
+  const paths = [];
+  const state = createWalkYieldState();
+  await walkWorkspaceTreeAsync(resolved, resolved, (rel) => {
+    assertNotShutdown();
+    paths.push(rel);
+  }, state);
+  return paths;
+}
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
     const resolved = path28.resolve(cwd);
     await yieldToEventLoop();
-    const pathCount = persistFileIndexForResolvedCwd(resolved);
+    assertNotShutdown();
+    const paths = await collectWorkspacePathsAsync(resolved);
     await yieldToEventLoop();
+    assertNotShutdown();
+    const pathCount = persistFileIndexPaths(resolved, paths);
     return { pathCount };
   });
 }
@@ -33779,11 +33865,13 @@ function createFsWatcher(resolved, schedule) {
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
   const resolved = path30.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
+    if (e instanceof CliSqliteInterrupted) return;
     console.error("[file-index] Initial index build failed:", e);
   });
   let timer = null;
   const runRebuild = () => {
     void buildFileIndexAsync(resolved).catch((e) => {
+      if (e instanceof CliSqliteInterrupted) return;
       console.error("[file-index] Watch rebuild failed:", e);
     });
   };
@@ -34317,9 +34405,6 @@ var StreamTail = class {
   }
 };
 
-// src/dev-servers/manager/dev-server-constants.ts
-var BRIDGE_SHUTDOWN_GRACE_MS = 8e3;
-
 // src/dev-servers/manager/dev-server-firehose-messages.ts
 function buildFirehoseSnapshotMessage(params) {
   const payload = {
@@ -34605,22 +34690,23 @@ var DevServerManager = class {
     }
     this.start(serverId);
   }
-  async shutdownAllGraceful() {
+  async shutdownAllGraceful(opts) {
+    const graceMs = opts?.graceMs ?? BRIDGE_SHUTDOWN_GRACE_MS;
     const pairs = [...this.processes.entries()];
     if (pairs.length === 0) return;
     this.log(
       `[dev-server] Stopping ${pairs.length} local dev server process${pairs.length === 1 ? "" : "es"}\u2026`
     );
-    await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc)));
+    await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc, graceMs)));
   }
-  async gracefulTerminateOrUnknown(serverId, proc) {
+  async gracefulTerminateOrUnknown(serverId, proc, graceMs) {
     const shortId = `${serverId.slice(0, 8)}\u2026`;
-    await sigtermAndWaitForExit(proc, BRIDGE_SHUTDOWN_GRACE_MS, this.log, shortId);
+    await sigtermAndWaitForExit(proc, graceMs, this.log, shortId);
     if (!this.processes.has(serverId) || this.processes.get(serverId) !== proc) {
       return;
     }
     this.bumpGeneration(serverId);
-    forceKillChild(proc, this.log, shortId, BRIDGE_SHUTDOWN_GRACE_MS);
+    forceKillChild(proc, this.log, shortId, graceMs);
     this.processes.delete(serverId);
     this.clearPoll(serverId);
     this.pipedCaptureByServerId.delete(serverId);
@@ -35047,10 +35133,13 @@ var LOCAL_AGENT_ACP_MODULES = [
 ];
 async function detectLocalAgentTypes() {
   try {
+    if (isCliImmediateShutdownRequested()) return [];
     const out = [];
     for (let i = 0; i < LOCAL_AGENT_ACP_MODULES.length; i++) {
+      if (isCliImmediateShutdownRequested()) return out;
       if (i > 0) {
         await yieldToEventLoop();
+        if (isCliImmediateShutdownRequested()) return out;
       }
       const mod = LOCAL_AGENT_ACP_MODULES[i];
       try {
@@ -35083,6 +35172,7 @@ function createSendLocalSkillsReport(getWs, logFn) {
 }
 function createReportAutoDetectedAgents(getWs, logFn) {
   return async () => {
+    if (isCliImmediateShutdownRequested()) return;
     try {
       const types = await detectLocalAgentTypes();
       const socket = getWs();
@@ -35182,6 +35272,7 @@ var handleBridgeIdentified = (msg, deps) => {
   });
   setImmediate(() => {
     void (async () => {
+      if (isCliImmediateShutdownRequested()) return;
       try {
         await deps.reportAutoDetectedAgents?.();
       } catch (e) {
@@ -35189,6 +35280,7 @@ var handleBridgeIdentified = (msg, deps) => {
           `[Bridge service] Auto-detect agents failed: ${e instanceof Error ? e.message : String(e)}`
         );
       }
+      if (isCliImmediateShutdownRequested()) return;
       try {
         await deps.warmupAgentCapabilitiesOnConnect?.();
       } catch (e) {
@@ -35199,6 +35291,7 @@ var handleBridgeIdentified = (msg, deps) => {
     })();
   });
   setImmediate(() => {
+    if (isCliImmediateShutdownRequested()) return;
     try {
       deps.sendLocalSkillsReport?.();
     } catch (e) {
@@ -35500,12 +35593,12 @@ function createBridgePromptSenders(deps, getWs) {
 }
 
 // src/agents/acp/from-bridge/bridge-prompt-preamble.ts
-import { execFile as execFile10 } from "node:child_process";
-import { promisify as promisify10 } from "node:util";
-var execFileAsync9 = promisify10(execFile10);
+import { execFile as execFile9 } from "node:child_process";
+import { promisify as promisify9 } from "node:util";
+var execFileAsync8 = promisify9(execFile9);
 async function readGitBranch(cwd) {
   try {
-    const { stdout } = await execFileAsync9("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
+    const { stdout } = await execFileAsync8("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
     const b = stdout.trim();
     return b || null;
   } catch {
@@ -36876,6 +36969,7 @@ import * as path39 from "node:path";
 import * as path38 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true } = params;
+  if (isCliImmediateShutdownRequested()) return false;
   const resolved = resolveAgentCommand(agentType);
   if (!resolved) return false;
   let sqliteChanged = false;
@@ -36909,6 +37003,7 @@ async function probeOneAgentTypeForCapabilities(params) {
   }, 28e3);
   killTimer.unref?.();
   try {
+    if (isCliImmediateShutdownRequested()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
       cwd: path38.resolve(cwd),
@@ -36928,7 +37023,7 @@ async function probeOneAgentTypeForCapabilities(params) {
       onSessionUpdate: () => {
       }
     });
-    await new Promise((r) => setTimeout(r, 1200));
+    if (!await delayMsUnlessShutdownRequested(1200)) return false;
   } catch (e) {
     log2(
       `[Bridge service] Agent capability probe (${agentType}): ${e instanceof Error ? e.message : String(e)}`
@@ -36956,6 +37051,7 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
   } = params;
   let changedCount = 0;
   for (let i = 0; i < agentTypes.length; i++) {
+    if (isCliImmediateShutdownRequested()) return changedCount;
     if (i > 0) await yieldToEventLoop();
     const agentType = agentTypes[i];
     if (!agentType.trim()) continue;
@@ -36983,6 +37079,7 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
 async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
+  if (isCliImmediateShutdownRequested()) return;
   const cwd = path39.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     const socket = getWs();
@@ -36995,18 +37092,21 @@ async function warmupAgentCapabilitiesOnConnect(params) {
         items: rows.map((r) => ({ agentType: r.agentType, configOptions: r.configOptions }))
       });
     } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
       log2(
         `[Bridge service] Agent capability batch to bridge failed: ${e instanceof Error ? e.message : String(e)}`
       );
     }
   }
   await sendBatchFromCache();
+  if (isCliImmediateShutdownRequested()) return;
   let types = [];
   try {
     types = [...await detectLocalAgentTypes()];
   } catch (e) {
     log2(`[Bridge service] detectLocalAgentTypes failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  if (isCliImmediateShutdownRequested()) return;
   try {
     const n = await probeAgentCapabilitiesForDetectedTypes({
       agentTypes: types,
@@ -37018,11 +37118,13 @@ async function warmupAgentCapabilitiesOnConnect(params) {
     });
     if (n > 0) await sendBatchFromCache();
   } catch (e) {
+    if (e instanceof CliSqliteInterrupted) return;
     log2(`[Bridge service] Agent capability probe (missing cache) failed: ${e instanceof Error ? e.message : String(e)}`);
   }
   void (async () => {
     try {
       await yieldToEventLoop();
+      if (isCliImmediateShutdownRequested()) return;
       const n = await probeAgentCapabilitiesForDetectedTypes({
         agentTypes: types,
         cwd,
@@ -37033,6 +37135,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
       });
       if (n > 0) await sendBatchFromCache();
     } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
       log2(`[Bridge service] Agent capability lazy refresh failed: ${e instanceof Error ? e.message : String(e)}`);
     }
   })();
@@ -37080,7 +37183,8 @@ async function createBridgeConnection(options) {
           configOptions: info.configOptions
         })
       );
-    } catch {
+    } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
     }
     if (!changed) return;
     const socket = getWs();
@@ -37163,6 +37267,7 @@ async function createBridgeConnection(options) {
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   return {
     close: async () => {
+      requestCliImmediateShutdown();
       stopFileIndexWatcher();
       bridgeHeartbeat.stop();
       await closeBridgeConnection(state, acpManager, devServerManager, logFn);
@@ -37236,47 +37341,60 @@ async function runConnectedBridge(options, restartWithoutAuth) {
   } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   let cleanupKeyCommand;
-  const handle = await createBridgeConnection({
-    apiUrl,
-    workspaceId,
-    authToken,
-    refreshToken,
-    firehoseServerUrl,
-    justAuthenticated,
-    worktreesRootPath,
-    e2eCertificate,
-    log,
-    persistTokens: (t) => {
-      writeConfigForApi(apiUrl, {
-        workspaceId,
-        token: t.token,
-        refreshToken: t.refreshToken
-      });
-    },
-    onAuthInvalid: () => {
-      cleanupKeyCommand?.();
-      log("[Bridge service] Access token invalid or revoked; re-authenticating\u2026");
-      clearConfigForApi(apiUrl);
-      void handle.close().then(() => {
-        void restartWithoutAuth({ apiUrl, firehoseServerUrl, worktreesRootPath, e2eCertificate });
-      });
-    }
-  });
+  let bridgeClose = null;
   const onSignal = (kind) => {
+    requestCliImmediateShutdown();
     cleanupKeyCommand?.();
     logImmediate(
       kind === "interrupt" ? "Keyboard interrupt (Ctrl+C) \u2014 stopping\u2026" : "Stop requested \u2014 shutting down\u2026"
     );
-    setImmediate(() => {
-      void handle.close().then(() => {
-        process.exit(0);
-      });
-    });
+    if (bridgeClose) {
+      void bridgeClose().then(() => process.exit(0));
+      return;
+    }
+    process.exit(0);
   };
   const onSigInt = () => onSignal("interrupt");
   const onSigTerm = () => onSignal("stop");
   process.on("SIGINT", onSigInt);
   process.on("SIGTERM", onSigTerm);
+  let handle;
+  try {
+    handle = await createBridgeConnection({
+      apiUrl,
+      workspaceId,
+      authToken,
+      refreshToken,
+      firehoseServerUrl,
+      justAuthenticated,
+      worktreesRootPath,
+      e2eCertificate,
+      log,
+      persistTokens: (t) => {
+        writeConfigForApi(apiUrl, {
+          workspaceId,
+          token: t.token,
+          refreshToken: t.refreshToken
+        });
+      },
+      onAuthInvalid: () => {
+        cleanupKeyCommand?.();
+        log("[Bridge service] Access token invalid or revoked; re-authenticating\u2026");
+        clearConfigForApi(apiUrl);
+        void handle.close().then(() => {
+          void restartWithoutAuth({ apiUrl, firehoseServerUrl, worktreesRootPath, e2eCertificate });
+        });
+      }
+    });
+  } catch (e) {
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
+    if (e instanceof CliSqliteInterrupted) {
+      process.exit(0);
+    }
+    throw e;
+  }
+  bridgeClose = () => handle.close();
   if (e2eCertificate) {
     let openingCertificate = false;
     cleanupKeyCommand = installE2eCertificateKeyCommand({
@@ -37321,6 +37439,7 @@ async function runBridge(options) {
       }
     });
     const onSignal = (kind) => {
+      requestCliImmediateShutdown();
       logImmediate(
         kind === "interrupt" ? "Keyboard interrupt (Ctrl+C) \u2014 stopping\u2026" : "Stop requested \u2014 shutting down\u2026"
       );