ghost-bridge 0.9.0 → 0.9.1

package/README.md

@@ -147,18 +147,26 @@ Read the next case from target cases, operate target app, then mark the case pas
 ```mermaid
 flowchart LR
     A["AI Client<br/>Claude / Codex / Cursor"]
-    B["Ghost Bridge MCP Server<br/>server.js"]
+    S["Session Process<br/>dist/server.js (stdio)"]
+    B["Ghost Bridge Daemon<br/>resident WebSocket service"]
     C["Chrome Extension<br/>background.js"]
     D["Browser Tabs<br/>Target Sessions"]
 
-    A <-->|"stdio"| B
-    B <-->|"WebSocket"| C
+    A <-->|"stdio"| S
+    S <-->|"WebSocket (mcp-client)"| B
+    C <-->|"WebSocket"| B
     C <-->|"CDP"| D
 ```
 
+The WebSocket service runs as a detached daemon, independent of any MCP session:
+
+- The first session process spawns the daemon automatically; it keeps running after that session exits
+- If the daemon crashes, any live session detects it and respawns it automatically
+- Stop it manually with `ghost-bridge stop` (close live MCP sessions first, otherwise they will bring it back on their next reconnect)
+
 ## Troubleshooting
 
-If the popup shows `No Bridge` / `Not Found`, it means the Chrome extension could not find a Ghost Bridge WebSocket service on the configured port. It does not necessarily mean your AI client is closed.
+If the popup shows `No Bridge` / `Not Found`, it means the Chrome extension could not find a Ghost Bridge WebSocket service on the configured port. With the resident daemon this normally only happens before the first MCP session of the day starts, or after `ghost-bridge stop`. Starting any MCP session (or reconnecting the extension) brings the service back within seconds.
 
 Run `ghost-bridge status` and check:
 

package/dist/cli.js

@@ -6010,6 +6010,7 @@ init_source();
 import { fileURLToPath as fileURLToPath2 } from "url";
 import path5 from "path";
 import fs5 from "fs";
+import os7 from "os";
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = path5.dirname(__filename);
 var packageJsonParams = JSON.parse(
@@ -6062,4 +6063,62 @@ program2.command("status").description("Check Ghost Bridge configuration status"
     console.error(source_default.red("Error checking status:"), error);
   }
 });
+var sleepMs = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function readPortInfoFile() {
+  const portInfoFile = process.env.GHOST_BRIDGE_PORT_INFO || path5.join(os7.tmpdir(), "ghost-bridge-port.json");
+  if (!fs5.existsSync(portInfoFile)) return null;
+  try {
+    const info = JSON.parse(fs5.readFileSync(portInfoFile, "utf-8"));
+    return info && info.pid ? { file: portInfoFile, ...info } : null;
+  } catch {
+    return null;
+  }
+}
+function removePortInfoFile(entry) {
+  try {
+    const current = JSON.parse(fs5.readFileSync(entry.file, "utf-8"));
+    if (current.pid === entry.pid) fs5.unlinkSync(entry.file);
+  } catch {
+  }
+}
+program2.command("stop").description("Stop the resident ghost-bridge daemon").action(async () => {
+  try {
+    const entry = readPortInfoFile();
+    if (!entry) {
+      console.log(source_default.yellow("\u672A\u53D1\u73B0\u8FD0\u884C\u4E2D\u7684 ghost-bridge \u5E38\u9A7B\u670D\u52A1"));
+      return;
+    }
+    if (!isProcessAlive(entry.pid)) {
+      removePortInfoFile(entry);
+      console.log(source_default.yellow(`\u7AEF\u53E3\u4FE1\u606F\u5DF2\u8FC7\u671F\uFF08PID ${entry.pid} \u4E0D\u5B58\u5728\uFF09\uFF0C\u5DF2\u6E05\u7406`));
+      return;
+    }
+    console.log(source_default.blue(`\u6B63\u5728\u505C\u6B62 ghost-bridge \u5E38\u9A7B\u670D\u52A1 (PID: ${entry.pid})...`));
+    process.kill(entry.pid, "SIGTERM");
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline && isProcessAlive(entry.pid)) {
+      await sleepMs(200);
+    }
+    if (isProcessAlive(entry.pid)) {
+      console.error(source_default.red("\u670D\u52A1\u672A\u80FD\u5728\u9884\u671F\u65F6\u95F4\u5185\u9000\u51FA\uFF0C\u8BF7\u624B\u52A8\u68C0\u67E5\u8BE5\u8FDB\u7A0B"));
+      process.exit(1);
+    }
+    removePortInfoFile(entry);
+    console.log(source_default.green("\u2705 ghost-bridge \u5E38\u9A7B\u670D\u52A1\u5DF2\u505C\u6B62"));
+    console.log(
+      source_default.dim("\u6CE8\u610F\uFF1A\u82E5\u4ECD\u6709\u6D3B\u8DC3\u7684 MCP \u4F1A\u8BDD\uFF0C\u4F1A\u8BDD\u4F1A\u5728\u4E0B\u6B21\u91CD\u8FDE\u65F6\u81EA\u52A8\u91CD\u65B0\u62C9\u8D77\u670D\u52A1\uFF1B\u5982\u9700\u5F7B\u5E95\u505C\u6B62\uFF0C\u8BF7\u5148\u5173\u95ED\u4F7F\u7528\u4E2D\u7684\u4F1A\u8BDD\u3002")
+    );
+  } catch (error) {
+    console.error(source_default.red("Error stopping ghost-bridge:"), error);
+    process.exit(1);
+  }
+});
 program2.parse();

package/dist/server.js

@@ -27102,8 +27102,8 @@ var Protocol = class {
    *
    * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
    */
-  async connect(transport2) {
-    this._transport = transport2;
+  async connect(transport) {
+    this._transport = transport;
     const _onclose = this.transport?.onclose;
     this._transport.onclose = () => {
       _onclose?.();
@@ -28523,6 +28523,7 @@ import net from "net";
 import fs2 from "fs";
 import os from "os";
 import path2 from "path";
+import { spawn } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // lib/version.js
@@ -28540,9 +28541,10 @@ var BASE_PORT = Number(process.env.GHOST_BRIDGE_PORT || 33333);
 var DEFAULT_WS_TOKEN = "ghost-bridge-local";
 var WS_TOKEN = process.env.GHOST_BRIDGE_TOKEN || DEFAULT_WS_TOKEN;
 var RESPONSE_TIMEOUT = 8e3;
-var PORT_INFO_FILE = path2.join(os.tmpdir(), "ghost-bridge-port.json");
+var PORT_INFO_FILE = process.env.GHOST_BRIDGE_PORT_INFO || path2.join(os.tmpdir(), "ghost-bridge-port.json");
 var SERVER_STARTED_AT = (/* @__PURE__ */ new Date()).toISOString();
 var SERVER_ENTRY_PATH = fileURLToPath2(import.meta.url);
+var IS_DAEMON = process.env.GHOST_BRIDGE_DAEMON === "1";
 var chromeConnection = null;
 var activeConnection = null;
 var actualPort = BASE_PORT;
@@ -28698,17 +28700,24 @@ function isPortAvailable(port) {
     server2.listen(port);
   });
 }
-async function startWebSocketServer() {
-  const available = await isPortAvailable(BASE_PORT);
-  if (!available) {
-    throw new Error(`\u56FA\u5B9A\u7AEF\u53E3 ${BASE_PORT} \u4E0D\u53EF\u7528\uFF0C\u8BF7\u91CA\u653E\u8BE5\u7AEF\u53E3\u6216\u901A\u8FC7 GHOST_BRIDGE_PORT \u6307\u5B9A\u5176\u4ED6\u7AEF\u53E3`);
-  }
-  actualPort = BASE_PORT;
-  const wss2 = new import_websocket_server.default({ port: BASE_PORT });
-  log(`\u{1F680} WebSocket \u670D\u52A1\u5DF2\u542F\u52A8\uFF0C\u7AEF\u53E3 ${BASE_PORT}${WS_TOKEN ? "\uFF08\u542F\u7528 token \u6821\u9A8C\uFF09" : ""}`);
-  return wss2;
+function startWebSocketServer(port) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const wss2 = new import_websocket_server.default({ port }, () => {
+      if (settled) return;
+      settled = true;
+      wss2.removeListener("error", onError);
+      resolve(wss2);
+    });
+    const onError = (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    };
+    wss2.on("error", onError);
+  });
 }
-async function initWebSocketService() {
+async function acquirePortForDaemon() {
   const existing = getExistingService();
   if (existing) {
     log(`\u68C0\u6D4B\u5230\u73B0\u6709\u670D\u52A1 (PID: ${existing.pid}, \u7AEF\u53E3: ${existing.port})\uFF0C\u9A8C\u8BC1\u4E2D...`);
@@ -28718,17 +28727,15 @@ async function initWebSocketService() {
         const mismatch = getServiceMismatch(probe);
         if (!mismatch) {
           actualPort = existing.port;
-          isMainInstance = false;
-          log(`\u2705 \u590D\u7528\u73B0\u6709\u670D\u52A1\uFF0C\u7AEF\u53E3 ${actualPort}`);
-          return null;
+          log(`\u2705 \u5DF2\u6709\u5E38\u9A7B\u670D\u52A1\u5728\u8FD0\u884C\uFF0C\u65E0\u9700\u91CD\u590D\u542F\u52A8`);
+          return { alreadyRunning: true };
         }
         await stopExistingService(Number(probe.pid) || existing.pid, existing.port, mismatch);
       } else {
-        const oldPid = Number(probe.pid) || existing.pid;
-        await stopExistingService(oldPid, existing.port, "token \u4E0D\u4E00\u81F4");
+        await stopExistingService(Number(probe.pid) || existing.pid, existing.port, "token \u4E0D\u4E00\u81F4");
       }
     } else {
-      log(`\u274C \u73B0\u6709\u670D\u52A1\u9A8C\u8BC1\u5931\u8D25\uFF0C\u542F\u52A8\u65B0\u670D\u52A1...`);
+      log(`\u274C \u73B0\u6709\u670D\u52A1\u9A8C\u8BC1\u5931\u8D25\uFF0C\u51C6\u5907\u63A5\u7BA1...`);
       try {
         fs2.unlinkSync(PORT_INFO_FILE);
       } catch {
@@ -28742,9 +28749,8 @@ async function initWebSocketService() {
         const mismatch = getServiceMismatch(probe);
         if (!mismatch) {
           actualPort = BASE_PORT;
-          isMainInstance = false;
-          log(`\u2705 \u590D\u7528\u56FA\u5B9A\u7AEF\u53E3\u4E0A\u7684\u73B0\u6709\u670D\u52A1\uFF0C\u7AEF\u53E3 ${actualPort}`);
-          return null;
+          log(`\u2705 \u56FA\u5B9A\u7AEF\u53E3\u4E0A\u5DF2\u6709\u5E38\u9A7B\u670D\u52A1\u5728\u8FD0\u884C\uFF0C\u65E0\u9700\u91CD\u590D\u542F\u52A8`);
+          return { alreadyRunning: true };
         }
         await stopExistingService(Number(probe.pid), BASE_PORT, mismatch);
       } else {
@@ -28755,8 +28761,34 @@ async function initWebSocketService() {
       throw new Error(`\u56FA\u5B9A\u7AEF\u53E3 ${BASE_PORT} \u5DF2\u88AB\u5176\u4ED6\u8FDB\u7A0B\u5360\u7528\uFF0C\u8BF7\u91CA\u653E\u8BE5\u7AEF\u53E3\u6216\u901A\u8FC7 GHOST_BRIDGE_PORT \u6307\u5B9A\u5176\u4ED6\u7AEF\u53E3`);
     }
   }
-  const wss2 = await startWebSocketServer();
+  let wss2;
+  try {
+    wss2 = await startWebSocketServer(BASE_PORT);
+  } catch (err) {
+    const probe = await probeExistingService(BASE_PORT);
+    if (probe?.service === "ghost-bridge" && probe.token === WS_TOKEN && !getServiceMismatch(probe)) {
+      actualPort = BASE_PORT;
+      log(`\u2705 \u53E6\u4E00\u4E2A\u5E38\u9A7B\u670D\u52A1\u5DF2\u62A2\u5148\u542F\u52A8\uFF0C\u672C\u8FDB\u7A0B\u9000\u51FA`);
+      return { alreadyRunning: true };
+    }
+    throw err;
+  }
+  log(`\u{1F680} WebSocket \u670D\u52A1\u5DF2\u542F\u52A8\uFF0C\u7AEF\u53E3 ${BASE_PORT}${WS_TOKEN ? "\uFF08\u542F\u7528 token \u6821\u9A8C\uFF09" : ""}`);
+  actualPort = BASE_PORT;
   isMainInstance = true;
+  return { wss: wss2 };
+}
+async function runDaemon() {
+  let acquired;
+  try {
+    acquired = await acquirePortForDaemon();
+  } catch (e) {
+    log(`\u274C daemon \u542F\u52A8\u5931\u8D25\uFF1A${e.message}`);
+    process.exit(1);
+  }
+  if (acquired.alreadyRunning) {
+    process.exit(0);
+  }
   fs2.writeFileSync(
     PORT_INFO_FILE,
     JSON.stringify({
@@ -28769,9 +28801,47 @@ async function initWebSocketService() {
     }, null, 2)
   );
   log(`\u{1F4DD} \u7AEF\u53E3\u4FE1\u606F\u5DF2\u5199\u5165: ${PORT_INFO_FILE}`);
-  return wss2;
+  return acquired.wss;
+}
+async function ensureDaemonRunning() {
+  const existing = getExistingService();
+  if (existing) {
+    const probe = await probeExistingService(existing.port);
+    if (probe?.service === "ghost-bridge" && probe.token === WS_TOKEN && !getServiceMismatch(probe)) {
+      actualPort = Number(probe.port) || existing.port;
+      return true;
+    }
+  } else {
+    const probe = await probeExistingService(BASE_PORT);
+    if (probe?.service === "ghost-bridge" && probe.token === WS_TOKEN && !getServiceMismatch(probe)) {
+      actualPort = BASE_PORT;
+      return true;
+    }
+  }
+  return spawnDaemonAndWait();
+}
+async function spawnDaemonAndWait(timeoutMs = 15e3) {
+  log("\u{1F6E0} \u5E38\u9A7B\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u6B63\u5728\u542F\u52A8 daemon...");
+  const child = spawn(process.execPath, [SERVER_ENTRY_PATH], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, GHOST_BRIDGE_DAEMON: "1" }
+  });
+  child.unref();
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const probe = await probeExistingService(BASE_PORT);
+    if (probe?.service === "ghost-bridge" && probe.token === WS_TOKEN && !getServiceMismatch(probe)) {
+      actualPort = Number(probe.port) || BASE_PORT;
+      log(`\u2705 daemon \u5DF2\u5C31\u7EEA (PID: ${probe.pid}, \u7AEF\u53E3: ${actualPort})`);
+      return true;
+    }
+    await sleep(250);
+  }
+  log(`\u274C daemon \u672A\u80FD\u5728 ${timeoutMs}ms \u5185\u5C31\u7EEA\uFF0C\u7A0D\u540E\u5C06\u91CD\u8BD5`);
+  return false;
 }
-var wss = await initWebSocketService();
+var wss = IS_DAEMON ? await runDaemon() : null;
 var wsPingInterval = null;
 var WS_PING_INTERVAL_MS = 3e4;
 if (wss) {
@@ -28913,22 +28983,22 @@ if (wss) {
     }
   }, WS_PING_INTERVAL_MS);
 } else {
-  log(`\u{1F4E1} \u4F5C\u4E3A\u5BA2\u6237\u7AEF\u8FDE\u63A5\u5230\u4E3B\u5B9E\u4F8B (\u7AEF\u53E3 ${actualPort})...`);
+  const ready = await ensureDaemonRunning();
+  if (!ready) log("\u26A0\uFE0F \u5E38\u9A7B\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528\uFF0C\u5C06\u4FDD\u6301\u540E\u53F0\u91CD\u8BD5\u5E76\u81EA\u52A8\u62C9\u8D77");
+  log(`\u{1F4E1} \u4F5C\u4E3A\u5BA2\u6237\u7AEF\u8FDE\u63A5\u5230\u5E38\u9A7B\u670D\u52A1 (\u7AEF\u53E3: ${actualPort})...`);
   connectToMainInstance();
 }
-var MAX_RECONNECT_ATTEMPTS = 10;
 var RECONNECT_INTERVAL = 3e3;
-var reconnectAttempts = 0;
-var wasEverConnected = false;
+var DAEMON_CHECK_EVERY = 5;
+var consecutiveFailures = 0;
 function connectToMainInstance() {
   const url2 = new URL(`ws://localhost:${actualPort}`);
   url2.searchParams.set("token", WS_TOKEN);
   url2.searchParams.set("role", "mcp-client");
   const ws = new import_websocket.default(url2.toString());
   ws.on("open", () => {
-    log(`\u2705 \u5DF2\u8FDE\u63A5\u5230\u4E3B\u5B9E\u4F8B (\u7AEF\u53E3 ${actualPort})`);
-    reconnectAttempts = 0;
-    wasEverConnected = true;
+    log(`\u2705 \u5DF2\u8FDE\u63A5\u5230\u5E38\u9A7B\u670D\u52A1 (\u7AEF\u53E3: ${actualPort})`);
+    consecutiveFailures = 0;
   });
   ws.on("message", (data) => {
     try {
@@ -28943,30 +29013,25 @@ function connectToMainInstance() {
     }
   });
   ws.on("close", () => {
-    log("\u26A0\uFE0F \u4E0E\u4E3B\u5B9E\u4F8B\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00");
+    log("\u26A0\uFE0F \u4E0E\u5E38\u9A7B\u670D\u52A1\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00");
     activeConnection = null;
-    failAllPending("\u4E0E\u4E3B\u5B9E\u4F8B\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00");
-    reconnectAttempts++;
-    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-      log(`\u274C \u91CD\u8FDE\u5931\u8D25\u6B21\u6570\u8FC7\u591A (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})\uFF0C\u5BA2\u6237\u7AEF\u8FDB\u7A0B\u9000\u51FA`);
-      process.exit(0);
-    }
-    setTimeout(() => {
-      if (!activeConnection) {
-        log(`\u{1F504} \u5C1D\u8BD5\u91CD\u65B0\u8FDE\u63A5\u5230\u4E3B\u5B9E\u4F8B... (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
-        connectToMainInstance();
-      }
+    failAllPending("\u4E0E\u5E38\u9A7B\u670D\u52A1\u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00");
+    consecutiveFailures++;
+    const attempt = consecutiveFailures;
+    const needDaemonCheck = attempt % DAEMON_CHECK_EVERY === 0;
+    setTimeout(async () => {
+      if (activeConnection) return;
+      if (needDaemonCheck) {
+        log(`\u{1F504} \u8FDE\u7EED ${attempt} \u6B21\u672A\u8FDE\u4E0A\u5E38\u9A7B\u670D\u52A1\uFF0C\u68C0\u67E5\u5E76\u5C1D\u8BD5\u62C9\u8D77...`);
+        await ensureDaemonRunning();
+      }
+      if (activeConnection) return;
+      log(`\u{1F504} \u5C1D\u8BD5\u91CD\u65B0\u8FDE\u63A5\u5230\u5E38\u9A7B\u670D\u52A1 (\u7B2C ${attempt} \u6B21)...`);
+      connectToMainInstance();
     }, RECONNECT_INTERVAL);
   });
   ws.on("error", (err) => {
-    log(`\u274C \u8FDE\u63A5\u4E3B\u5B9E\u4F8B\u5931\u8D25: ${err.message}`);
-    if (!wasEverConnected) {
-      reconnectAttempts++;
-      if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        log(`\u274C \u65E0\u6CD5\u8FDE\u63A5\u5230\u4E3B\u5B9E\u4F8B\uFF0C\u5BA2\u6237\u7AEF\u8FDB\u7A0B\u9000\u51FA`);
-        process.exit(0);
-      }
-    }
+    log(`\u274C \u8FDE\u63A5\u5E38\u9A7B\u670D\u52A1\u5931\u8D25: ${err.message}`);
   });
 }
 function failAllPending(message) {
@@ -29001,7 +29066,7 @@ function handleIncoming(data) {
   else resolve(result);
 }
 async function askMainInstance(command, params = {}) {
-  if (!activeConnection) throw new Error("\u672A\u8FDE\u63A5\u5230\u4E3B\u5B9E\u4F8B");
+  if (!activeConnection) throw new Error("\u672A\u8FDE\u63A5\u5230\u5E38\u9A7B\u670D\u52A1");
   const id = crypto.randomUUID();
   const payload = { id, command, params };
   return new Promise((resolve, reject) => {
@@ -29020,7 +29085,11 @@ async function askMainInstance(command, params = {}) {
   });
 }
 async function askChrome(command, params = {}, options = {}) {
-  if (!activeConnection) throw new Error("Chrome \u672A\u8FDE\u63A5\uFF0C\u8BF7\u786E\u8BA4\u6D4F\u89C8\u5668\u5F00\u542F\u4E14\u6269\u5C55\u5DF2\u542F\u7528");
+  if (!activeConnection) {
+    throw new Error(
+      IS_DAEMON ? "Chrome \u672A\u8FDE\u63A5\uFF0C\u8BF7\u786E\u8BA4\u6D4F\u89C8\u5668\u5F00\u542F\u4E14\u6269\u5C55\u5DF2\u542F\u7528" : "ghost-bridge \u5E38\u9A7B\u670D\u52A1\u672A\u8FDE\u63A5\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF08\u53EF\u7528 ghost-bridge status \u68C0\u67E5\uFF09"
+    );
+  }
   const id = crypto.randomUUID();
   const payload = { id, command, params, clientId: LOCAL_CLIENT_ID };
   if (WS_TOKEN) payload.token = WS_TOKEN;
@@ -29498,7 +29567,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             text: jsonText({
               service: "ghost-bridge",
               version: GHOST_BRIDGE_VERSION,
-              role: isMainInstance ? "\u4E3B\u5B9E\u4F8B (WebSocket Server)" : "\u5BA2\u6237\u7AEF (\u8FDE\u63A5\u5230\u4E3B\u5B9E\u4F8B)",
+              role: isMainInstance ? "daemon (\u5E38\u9A7B WebSocket \u670D\u52A1)" : "\u4F1A\u8BDD\u5BA2\u6237\u7AEF (\u8FDE\u63A5\u5E38\u9A7B\u670D\u52A1)",
               wsPort: actualPort,
               wsUrl: `ws://localhost:${actualPort}`,
               pid: process.pid,
@@ -29685,38 +29754,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     return { content: [{ type: "text", text: `Error: ${e.message}` }] };
   }
 });
-var transport = new StdioServerTransport();
-await server.connect(transport);
-var roleText = isMainInstance ? "\u4E3B\u5B9E\u4F8B" : "\u5BA2\u6237\u7AEF";
-log(`\u2705 MCP server \u5DF2\u542F\u52A8 | \u89D2\u8272: ${roleText} | \u7AEF\u53E3: ${actualPort} | PID: ${process.pid} | PPID: ${process.ppid}`);
-log(`\u{1F4C4} \u7AEF\u53E3\u4FE1\u606F\u6587\u4EF6: ${PORT_INFO_FILE}`);
-log(`\u{1F4A1} \u4F7F\u7528 get_server_info \u5DE5\u5177\u67E5\u770B\u8BE6\u7EC6\u72B6\u6001`);
-var PARENT_CHECK_INTERVAL = 5e3;
-var parentPid = process.ppid;
-process.stdin.on("end", () => {
-  log("\u26A0\uFE0F stdin \u5DF2\u5173\u95ED\uFF0C\u7236\u8FDB\u7A0B\u53EF\u80FD\u5DF2\u9000\u51FA\uFF0C\u6B63\u5728\u9000\u51FA...");
-  cleanup();
-  process.exit(0);
-});
-process.stdin.on("close", () => {
-  log("\u26A0\uFE0F stdin \u5DF2\u5173\u95ED\uFF0C\u6B63\u5728\u9000\u51FA...");
-  cleanup();
-  process.exit(0);
-});
-var parentCheckTimer = setInterval(() => {
-  try {
-    process.kill(parentPid, 0);
-  } catch (e) {
-    log(`\u26A0\uFE0F \u7236\u8FDB\u7A0B (PID: ${parentPid}) \u5DF2\u4E0D\u5B58\u5728\uFF0C\u6B63\u5728\u9000\u51FA...`);
-    clearInterval(parentCheckTimer);
+if (!IS_DAEMON) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log(`\u2705 MCP server \u5DF2\u542F\u52A8 | \u89D2\u8272: \u4F1A\u8BDD\u5BA2\u6237\u7AEF | \u5E38\u9A7B\u670D\u52A1\u7AEF\u53E3: ${actualPort} | PID: ${process.pid} | PPID: ${process.ppid}`);
+  log(`\u{1F4A1} \u4F7F\u7528 get_server_info \u5DE5\u5177\u67E5\u770B\u8BE6\u7EC6\u72B6\u6001`);
+  const PARENT_CHECK_INTERVAL = 5e3;
+  const parentPid = process.ppid;
+  process.stdin.on("end", () => {
+    log("\u26A0\uFE0F stdin \u5DF2\u5173\u95ED\uFF0C\u7236\u8FDB\u7A0B\u53EF\u80FD\u5DF2\u9000\u51FA\uFF0C\u6B63\u5728\u9000\u51FA...");
     cleanup();
     process.exit(0);
-  }
-}, PARENT_CHECK_INTERVAL);
-parentCheckTimer.unref();
+  });
+  process.stdin.on("close", () => {
+    log("\u26A0\uFE0F stdin \u5DF2\u5173\u95ED\uFF0C\u6B63\u5728\u9000\u51FA...");
+    cleanup();
+    process.exit(0);
+  });
+  const parentCheckTimer = setInterval(() => {
+    try {
+      process.kill(parentPid, 0);
+    } catch (e) {
+      log(`\u26A0\uFE0F \u7236\u8FDB\u7A0B (PID: ${parentPid}) \u5DF2\u4E0D\u5B58\u5728\uFF0C\u6B63\u5728\u9000\u51FA...`);
+      clearInterval(parentCheckTimer);
+      cleanup();
+      process.exit(0);
+    }
+  }, PARENT_CHECK_INTERVAL);
+  parentCheckTimer.unref();
+} else {
+  log(`\u2705 ghost-bridge daemon \u5DF2\u542F\u52A8 | \u7AEF\u53E3: ${actualPort} | PID: ${process.pid}`);
+  log(`\u{1F4C4} \u7AEF\u53E3\u4FE1\u606F\u6587\u4EF6: ${PORT_INFO_FILE}`);
+  log(`\u{1F4A1} \u505C\u6B62\u670D\u52A1: ghost-bridge stop`);
+}
 function cleanup() {
   log("\u{1F9F9} \u6B63\u5728\u6E05\u7406...");
-  if (isMainInstance) {
+  if (IS_DAEMON) {
     try {
       if (fs2.existsSync(PORT_INFO_FILE)) {
         const info = JSON.parse(fs2.readFileSync(PORT_INFO_FILE, "utf-8"));
@@ -29753,7 +29826,7 @@ process.on("SIGTERM", () => {
   process.exit(0);
 });
 process.on("exit", () => {
-  if (isMainInstance) {
+  if (IS_DAEMON) {
     try {
       if (fs2.existsSync(PORT_INFO_FILE)) {
         const info = JSON.parse(fs2.readFileSync(PORT_INFO_FILE, "utf-8"));

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Ghost Bridge",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Zero-restart Chrome debugger bridge for Claude MCP, optimized for no-sourcemap production debugging.",
   "permissions": [
     "debugger",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ghost-bridge",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "private": false,
   "type": "module",
   "description": "Ghost Bridge: Zero-restart Chrome debugger bridge for Claude MCP. Includes CLI for easy setup.",