codex-to-im 1.0.41 → 1.0.42

package/dist/cli.mjs

@@ -5,9 +5,9 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import { stdin as input, stdout as output } from "node:process";
 
 // src/service-manager.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os2 from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
@@ -233,42 +233,79 @@ function loadConfig() {
   return expandConfig(empty);
 }
 
-// src/service-manager.ts
-var moduleDir = path2.dirname(fileURLToPath(import.meta.url));
-var packageRoot = path2.resolve(moduleDir, "..");
+// src/bridge-instance-lock.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
 var runtimeDir = path2.join(CTI_HOME, "runtime");
-var logsDir = path2.join(CTI_HOME, "logs");
-var bridgePidFile = path2.join(runtimeDir, "bridge.pid");
-var bridgeStatusFile = path2.join(runtimeDir, "status.json");
-var bridgeStartLockFile = path2.join(runtimeDir, "bridge.start.lock");
-var uiStatusFile = path2.join(runtimeDir, "ui-server.json");
+var bridgeInstanceLockFile = path2.join(runtimeDir, "bridge.instance.lock");
+function readJsonFile(filePath, fallback) {
+  try {
+    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readBridgeInstanceLock(filePath = bridgeInstanceLockFile) {
+  const parsed = readJsonFile(filePath, null);
+  const pid = Number(parsed?.pid);
+  const createdAt = typeof parsed?.createdAt === "string" ? parsed.createdAt : "";
+  if (!Number.isFinite(pid) || pid <= 0 || !createdAt) return null;
+  return { pid, createdAt };
+}
+function clearStaleBridgeInstanceLock(filePath = bridgeInstanceLockFile, isAlive = isProcessAlive) {
+  const existing = readBridgeInstanceLock(filePath);
+  if (existing && isAlive(existing.pid)) return;
+  try {
+    fs2.unlinkSync(filePath);
+  } catch {
+  }
+}
+
+// src/service-manager.ts
+var moduleDir = path3.dirname(fileURLToPath(import.meta.url));
+var packageRoot = path3.resolve(moduleDir, "..");
+var runtimeDir2 = path3.join(CTI_HOME, "runtime");
+var logsDir = path3.join(CTI_HOME, "logs");
+var bridgePidFile = path3.join(runtimeDir2, "bridge.pid");
+var bridgeStatusFile = path3.join(runtimeDir2, "status.json");
+var bridgeStartLockFile = path3.join(runtimeDir2, "bridge.start.lock");
+var uiStatusFile = path3.join(runtimeDir2, "ui-server.json");
 var uiPort = 4781;
 var bridgeAutostartTaskName = "CodexToIMBridge";
-var bridgeAutostartLauncherFile = path2.join(runtimeDir, "bridge-autostart.ps1");
-var npmUninstallLogFile = path2.join(runtimeDir, "npm-uninstall.log");
+var bridgeAutostartLauncherFile = path3.join(runtimeDir2, "bridge-autostart.ps1");
+var npmUninstallLogFile = path3.join(runtimeDir2, "npm-uninstall.log");
 var WINDOWS_HIDE = process.platform === "win32" ? { windowsHide: true } : {};
 var BRIDGE_START_LOCK_STALE_MS = 3e4;
 function ensureDirs() {
-  fs2.mkdirSync(runtimeDir, { recursive: true });
-  fs2.mkdirSync(logsDir, { recursive: true });
+  fs3.mkdirSync(runtimeDir2, { recursive: true });
+  fs3.mkdirSync(logsDir, { recursive: true });
 }
-function readJsonFile(filePath, fallback) {
+function readJsonFile2(filePath, fallback) {
   try {
-    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
 }
 function readPid(filePath) {
   try {
-    const raw = fs2.readFileSync(filePath, "utf-8").trim();
+    const raw = fs3.readFileSync(filePath, "utf-8").trim();
     const pid = Number(raw);
     return Number.isFinite(pid) ? pid : void 0;
   } catch {
     return void 0;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -277,32 +314,37 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function collectTrackedBridgePids(bridgePid, statusPid) {
+function collectTrackedBridgePids(bridgePid, statusPid, instanceLockPid) {
   const unique = /* @__PURE__ */ new Set();
-  for (const pid of [bridgePid, statusPid]) {
+  for (const pid of [bridgePid, statusPid, instanceLockPid]) {
     if (Number.isFinite(pid) && pid > 0) {
       unique.add(pid);
     }
   }
   return [...unique];
 }
-function resolveTrackedBridgePid(bridgePid, statusPid, isAlive = isProcessAlive) {
+function resolveTrackedBridgePid(bridgePid, statusPid, instanceLockPid, isAlive = isProcessAlive2) {
   if (isAlive(bridgePid)) return bridgePid;
   if (isAlive(statusPid)) return statusPid;
-  return bridgePid ?? statusPid;
+  if (isAlive(instanceLockPid)) return instanceLockPid;
+  return bridgePid ?? statusPid ?? instanceLockPid;
 }
 function getTrackedBridgePids(status) {
-  const resolvedStatus = status ?? readJsonFile(bridgeStatusFile, { running: false });
-  return collectTrackedBridgePids(readPid(bridgePidFile), resolvedStatus.pid);
+  const resolvedStatus = status ?? readJsonFile2(bridgeStatusFile, { running: false });
+  return collectTrackedBridgePids(
+    readPid(bridgePidFile),
+    resolvedStatus.pid,
+    readBridgeInstanceLock()?.pid
+  );
 }
 function clearBridgePidFile() {
   try {
-    fs2.unlinkSync(bridgePidFile);
+    fs3.unlinkSync(bridgePidFile);
   } catch {
   }
 }
 function readBridgeStartLock(filePath = bridgeStartLockFile) {
-  const parsed = readJsonFile(filePath, null);
+  const parsed = readJsonFile2(filePath, null);
   const pid = Number(parsed?.pid);
   const createdAt = typeof parsed?.createdAt === "string" ? parsed.createdAt : "";
   if (!Number.isFinite(pid) || pid <= 0 || !createdAt) return null;
@@ -312,7 +354,7 @@ function isBridgeStartLockStale(lock, options = {}) {
   if (!lock) return true;
   const nowMs = options.nowMs ?? Date.now();
   const staleMs = options.staleMs ?? BRIDGE_START_LOCK_STALE_MS;
-  const isAlive = options.isAlive ?? isProcessAlive;
+  const isAlive = options.isAlive ?? isProcessAlive2;
   const createdAtMs = Date.parse(lock.createdAt);
   if (!Number.isFinite(createdAtMs)) return true;
   if (!isAlive(lock.pid)) return true;
@@ -328,7 +370,7 @@ function tryAcquireBridgeStartLock(options = {}) {
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs2.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      fs3.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
       return { acquired: true };
     } catch (error) {
       const code = error.code;
@@ -342,7 +384,7 @@ function tryAcquireBridgeStartLock(options = {}) {
         return { acquired: false, holderPid: existing2?.pid };
       }
       try {
-        fs2.unlinkSync(filePath);
+        fs3.unlinkSync(filePath);
       } catch {
       }
     }
@@ -354,14 +396,14 @@ function releaseBridgeStartLock(filePath = bridgeStartLockFile, ownerPid = proce
   const existing = readBridgeStartLock(filePath);
   if (!existing) {
     try {
-      fs2.unlinkSync(filePath);
+      fs3.unlinkSync(filePath);
     } catch {
     }
     return;
   }
   if (existing.pid !== ownerPid) return;
   try {
-    fs2.unlinkSync(filePath);
+    fs3.unlinkSync(filePath);
   } catch {
   }
 }
@@ -443,11 +485,11 @@ function ensureBridgeAutostartLauncher() {
     "    }",
     "  } catch { }",
     "}",
-    `& $node '${escapePowerShellSingleQuoted(path2.join(packageRoot, "dist", "cli.mjs"))}' start`,
+    `& $node '${escapePowerShellSingleQuoted(path3.join(packageRoot, "dist", "cli.mjs"))}' start`,
     "exit $LASTEXITCODE",
     ""
   ].join("\r\n");
-  fs2.writeFileSync(bridgeAutostartLauncherFile, content, "utf-8");
+  fs3.writeFileSync(bridgeAutostartLauncherFile, content, "utf-8");
   return bridgeAutostartLauncherFile;
 }
 function parsePowerShellJson(raw) {
@@ -491,7 +533,7 @@ function buildDeferredGlobalNpmUninstallLaunch(options = {}) {
 async function launchDeferredGlobalNpmUninstall() {
   ensureDirs();
   const launch = buildDeferredGlobalNpmUninstallLaunch();
-  fs2.writeFileSync(
+  fs3.writeFileSync(
     launch.logPath,
     [
       `[${(/* @__PURE__ */ new Date()).toISOString()}] Scheduling global uninstall.`,
@@ -519,14 +561,18 @@ function getUiServerUrl(port = uiPort) {
   return `http://127.0.0.1:${port}`;
 }
 function getCurrentUiServerUrl() {
-  const status = readJsonFile(uiStatusFile, null);
+  const status = readJsonFile2(uiStatusFile, null);
   if (!status?.port) return void 0;
   return getUiServerUrl(status.port);
 }
 function getBridgeStatus() {
-  const status = readJsonFile(bridgeStatusFile, { running: false });
-  const pid = resolveTrackedBridgePid(readPid(bridgePidFile), status.pid);
-  if (!isProcessAlive(pid)) {
+  const status = readJsonFile2(bridgeStatusFile, { running: false });
+  const pid = resolveTrackedBridgePid(
+    readPid(bridgePidFile),
+    status.pid,
+    readBridgeInstanceLock()?.pid
+  );
+  if (!isProcessAlive2(pid)) {
     return {
       ...status,
       pid,
@@ -540,8 +586,8 @@ function getBridgeStatus() {
   };
 }
 function getUiServerStatus() {
-  const status = readJsonFile(uiStatusFile, { running: false, port: uiPort });
-  if (!isProcessAlive(status.pid)) {
+  const status = readJsonFile2(uiStatusFile, { running: false, port: uiPort });
+  if (!isProcessAlive2(status.pid)) {
     return {
       ...status,
       running: false,
@@ -626,7 +672,7 @@ async function waitForUiServer(timeoutMs = 15e3) {
 async function startBridge() {
   ensureDirs();
   const current = getBridgeStatus();
-  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive(pid));
+  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive2(pid));
   if (current.running && extraAlivePids.length === 0) return current;
   if (current.running && extraAlivePids.length > 0) {
     await stopBridge();
@@ -651,17 +697,17 @@ async function startBridge() {
   startLockHeld = true;
   try {
     const currentAfterLock = getBridgeStatus();
-    const extraAlivePidsAfterLock = getTrackedBridgePids(currentAfterLock).filter((pid) => pid !== currentAfterLock.pid && isProcessAlive(pid));
+    const extraAlivePidsAfterLock = getTrackedBridgePids(currentAfterLock).filter((pid) => pid !== currentAfterLock.pid && isProcessAlive2(pid));
     if (currentAfterLock.running && extraAlivePidsAfterLock.length === 0) return currentAfterLock;
     if (currentAfterLock.running && extraAlivePidsAfterLock.length > 0) {
       await stopBridge();
     }
-    const daemonEntry = path2.join(packageRoot, "dist", "daemon.mjs");
-    if (!fs2.existsSync(daemonEntry)) {
+    const daemonEntry = path3.join(packageRoot, "dist", "daemon.mjs");
+    if (!fs3.existsSync(daemonEntry)) {
       throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
     }
-    const stdoutFd = fs2.openSync(path2.join(logsDir, "bridge-launcher.out.log"), "a");
-    const stderrFd = fs2.openSync(path2.join(logsDir, "bridge-launcher.err.log"), "a");
+    const stdoutFd = fs3.openSync(path3.join(logsDir, "bridge-launcher.out.log"), "a");
+    const stderrFd = fs3.openSync(path3.join(logsDir, "bridge-launcher.err.log"), "a");
     const child = spawn(process.execPath, [daemonEntry], {
       cwd: packageRoot,
       detached: true,
@@ -684,10 +730,11 @@ async function startBridge() {
   }
 }
 async function stopBridge() {
-  const status = readJsonFile(bridgeStatusFile, { running: false });
-  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive(pid));
+  const status = readJsonFile2(bridgeStatusFile, { running: false });
+  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive2(pid));
   if (pids.length === 0) {
     clearBridgePidFile();
+    clearStaleBridgeInstanceLock();
     return { ...getBridgeStatus(), running: false };
   }
   for (const pid of pids) {
@@ -709,13 +756,15 @@ async function stopBridge() {
   }
   const startedAt = Date.now();
   while (Date.now() - startedAt < 1e4) {
-    if (pids.every((pid) => !isProcessAlive(pid))) {
+    if (pids.every((pid) => !isProcessAlive2(pid))) {
       clearBridgePidFile();
+      clearStaleBridgeInstanceLock();
       return getBridgeStatus();
     }
     await sleep(300);
   }
   clearBridgePidFile();
+  clearStaleBridgeInstanceLock();
   return getBridgeStatus();
 }
 async function getBridgeAutostartStatus() {
@@ -804,8 +853,8 @@ async function uninstallBridgeAutostart() {
   ].join("; ");
   await runPowerShell(script);
   try {
-    if (fs2.existsSync(bridgeAutostartLauncherFile)) {
-      fs2.unlinkSync(bridgeAutostartLauncherFile);
+    if (fs3.existsSync(bridgeAutostartLauncherFile)) {
+      fs3.unlinkSync(bridgeAutostartLauncherFile);
     }
   } catch {
   }
@@ -836,12 +885,12 @@ async function ensureUiServerRunning() {
   ensureDirs();
   const current = getUiServerStatus();
   if (current.running) return current;
-  const serverEntry = path2.join(packageRoot, "dist", "ui-server.mjs");
-  if (!fs2.existsSync(serverEntry)) {
+  const serverEntry = path3.join(packageRoot, "dist", "ui-server.mjs");
+  if (!fs3.existsSync(serverEntry)) {
     throw new Error(`UI server bundle not found at ${serverEntry}. Run npm run build first.`);
   }
-  const stdoutFd = fs2.openSync(path2.join(logsDir, "ui-server.out.log"), "a");
-  const stderrFd = fs2.openSync(path2.join(logsDir, "ui-server.err.log"), "a");
+  const stdoutFd = fs3.openSync(path3.join(logsDir, "ui-server.out.log"), "a");
+  const stderrFd = fs3.openSync(path3.join(logsDir, "ui-server.err.log"), "a");
   const child = spawn(process.execPath, [serverEntry], {
     cwd: packageRoot,
     detached: true,
@@ -861,7 +910,7 @@ async function ensureUiServerRunning() {
 }
 async function stopUiServer() {
   const status = getUiServerStatus();
-  if (!status.pid || !isProcessAlive(status.pid)) {
+  if (!status.pid || !isProcessAlive2(status.pid)) {
     const next2 = { ...status, running: false };
     writeUiServerStatus(next2);
     return next2;
@@ -898,7 +947,7 @@ async function stopUiServer() {
 }
 function writeUiServerStatus(status) {
   ensureDirs();
-  fs2.writeFileSync(uiStatusFile, JSON.stringify(status, null, 2), "utf-8");
+  fs3.writeFileSync(uiStatusFile, JSON.stringify(status, null, 2), "utf-8");
 }
 function openBrowser(url) {
   if (process.platform === "win32") {

package/dist/daemon.mjs

@@ -3935,9 +3935,9 @@ var codex_provider_exports = {};
 __export(codex_provider_exports, {
   CodexProvider: () => CodexProvider
 });
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import os4 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function toApprovalPolicy(permissionMode) {
   switch (permissionMode) {
     case "never":
@@ -3964,7 +3964,7 @@ function normalizeCodexErrorMessage(message) {
   if (!trimmed) return "Codex \u6267\u884C\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
   const lower = trimmed.toLowerCase();
   if (lower.includes("timeout waiting for child process to exit") || lower.includes("reconnecting...")) {
-    return "Codex \u4F1A\u8BDD\u6062\u590D\u5931\u8D25\uFF0C\u4E0A\u4E00\u8F6E\u6267\u884C\u8FDB\u7A0B\u672A\u6B63\u5E38\u9000\u51FA\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u5982\u679C\u8FDE\u7EED\u5931\u8D25\uFF0C\u8BF7\u65B0\u5F00\u7EBF\u7A0B\u6216\u5207\u6362\u5230 `/t 0`\u3002";
+    return "Codex \u4F1A\u8BDD\u6062\u590D\u5931\u8D25\uFF0C\u4E0A\u4E00\u8F6E\u6267\u884C\u8FDB\u7A0B\u672A\u6B63\u5E38\u9000\u51FA\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u5982\u679C\u8FDE\u7EED\u5931\u8D25\uFF0C\u8BF7\u65B0\u5F00\u7EBF\u7A0B\u6216\u5207\u6362\u5230 /t 0\u3002";
   }
   return trimmed;
 }
@@ -4028,6 +4028,9 @@ var init_codex_provider = __esm({
       threadIds = /* @__PURE__ */ new Map();
       constructor(_pendingPerms) {
       }
+      clearCachedThreadId(sessionId) {
+        this.threadIds.delete(sessionId);
+      }
       /**
        * Lazily load the Codex SDK. Throws a clear error if the installation is incomplete.
        */
@@ -4081,13 +4084,13 @@ var init_codex_provider = __esm({
                     { type: "text", text: params.prompt }
                   ];
                   for (const file of imageFiles) {
-                    if (file.filePath && fs14.existsSync(file.filePath)) {
+                    if (file.filePath && fs15.existsSync(file.filePath)) {
                       parts.push({ type: "local_image", path: file.filePath });
                       continue;
                     }
                     const ext = MIME_EXT[file.type] || ".png";
-                    const tmpPath = path15.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-                    fs14.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
+                    const tmpPath = path16.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
+                    fs15.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
                     tempFiles.push(tmpPath);
                     parts.push({ type: "local_image", path: tmpPath });
                   }
@@ -4159,12 +4162,14 @@ var init_codex_provider = __esm({
                         }
                         case "turn.failed": {
                           const error = event.error?.message;
+                          self.clearCachedThreadId(params.sessionId);
                           controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(error || "Turn failed")));
                           sawTerminalEvent = true;
                           break;
                         }
                         case "error": {
                           const error = event.message;
+                          self.clearCachedThreadId(params.sessionId);
                           controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(error || "Thread error")));
                           sawTerminalEvent = true;
                           break;
@@ -4187,10 +4192,12 @@ var init_codex_provider = __esm({
                     const message = err instanceof Error ? err.message : String(err);
                     if (savedThreadId && !retryFresh && !sawAnyEvent && shouldRetryFreshThread(message)) {
                       console.warn("[codex-provider] Resume failed, retrying with a fresh thread:", message);
+                      self.clearCachedThreadId(params.sessionId);
                       savedThreadId = void 0;
                       retryFresh = true;
                       continue;
                     }
+                    self.clearCachedThreadId(params.sessionId);
                     throw err;
                   }
                 }
@@ -4198,6 +4205,7 @@ var init_codex_provider = __esm({
               } catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 console.error("[codex-provider] Error:", err instanceof Error ? err.stack || err.message : err);
+                self.clearCachedThreadId(params.sessionId);
                 try {
                   controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(message)));
                   controller.close();
@@ -4206,7 +4214,7 @@ var init_codex_provider = __esm({
               } finally {
                 for (const tmp of tempFiles) {
                   try {
-                    fs14.unlinkSync(tmp);
+                    fs15.unlinkSync(tmp);
                   } catch {
                   }
                 }
@@ -4318,6 +4326,7 @@ var init_codex_provider = __esm({
             break;
           }
           case "error": {
+            this.clearCachedThreadId(sessionId);
             controller.enqueue(sseEvent("error", normalizeCodexErrorMessage(item.message || "Codex error")));
             break;
           }
@@ -4339,8 +4348,8 @@ var init_codex_provider = __esm({
 });
 
 // src/main.ts
-import fs15 from "node:fs";
-import path16 from "node:path";
+import fs16 from "node:fs";
+import path17 from "node:path";
 import crypto10 from "node:crypto";
 
 // src/lib/bridge/context.ts
@@ -7160,20 +7169,20 @@ ${trimmedResponse}`;
         buffer = Buffer.concat(chunks);
       } catch (streamErr) {
         console.warn("[feishu-adapter] Stream read failed, falling back to writeFile:", streamErr instanceof Error ? streamErr.message : streamErr);
-        const fs16 = await import("fs");
+        const fs17 = await import("fs");
         const os5 = await import("os");
-        const path17 = await import("path");
-        const tmpPath = path17.join(os5.tmpdir(), `feishu-dl-${crypto2.randomUUID()}`);
+        const path18 = await import("path");
+        const tmpPath = path18.join(os5.tmpdir(), `feishu-dl-${crypto2.randomUUID()}`);
         try {
           await res.writeFile(tmpPath);
-          buffer = fs16.readFileSync(tmpPath);
+          buffer = fs17.readFileSync(tmpPath);
           if (buffer.length > MAX_FILE_SIZE) {
             console.warn(`[feishu-adapter] Resource too large (>${MAX_FILE_SIZE} bytes), key: ${fileKey}`);
             return null;
           }
         } finally {
           try {
-            fs16.unlinkSync(tmpPath);
+            fs17.unlinkSync(tmpPath);
           } catch {
           }
         }
@@ -23205,10 +23214,87 @@ function setupLogger() {
   console.warn = (...args) => write("WARN", args);
 }
 
+// src/bridge-instance-lock.ts
+import fs14 from "node:fs";
+import path15 from "node:path";
+var runtimeDir = path15.join(CTI_HOME, "runtime");
+var bridgeInstanceLockFile = path15.join(runtimeDir, "bridge.instance.lock");
+function readJsonFile(filePath, fallback) {
+  try {
+    return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readBridgeInstanceLock(filePath = bridgeInstanceLockFile) {
+  const parsed = readJsonFile(filePath, null);
+  const pid = Number(parsed?.pid);
+  const createdAt = typeof parsed?.createdAt === "string" ? parsed.createdAt : "";
+  if (!Number.isFinite(pid) || pid <= 0 || !createdAt) return null;
+  return { pid, createdAt };
+}
+function tryAcquireBridgeInstanceLock(options = {}) {
+  const filePath = options.filePath ?? bridgeInstanceLockFile;
+  const ownerPid = options.ownerPid ?? process.pid;
+  const nowMs = options.nowMs ?? Date.now();
+  const isAlive = options.isAlive ?? isProcessAlive;
+  const payload = {
+    pid: ownerPid,
+    createdAt: new Date(nowMs).toISOString()
+  };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs14.mkdirSync(path15.dirname(filePath), { recursive: true });
+      fs14.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      return { acquired: true };
+    } catch (error) {
+      const code2 = error.code;
+      if (code2 !== "EEXIST") throw error;
+      const existing2 = readBridgeInstanceLock(filePath);
+      if (existing2 && existing2.pid !== ownerPid && isAlive(existing2.pid)) {
+        return { acquired: false, holderPid: existing2.pid };
+      }
+      try {
+        fs14.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  }
+  const existing = readBridgeInstanceLock(filePath);
+  if (existing && existing.pid !== ownerPid && isAlive(existing.pid)) {
+    return { acquired: false, holderPid: existing.pid };
+  }
+  return existing?.pid === ownerPid ? { acquired: true } : { acquired: false, holderPid: existing?.pid };
+}
+function releaseBridgeInstanceLock(filePath = bridgeInstanceLockFile, ownerPid = process.pid) {
+  const existing = readBridgeInstanceLock(filePath);
+  if (!existing) {
+    try {
+      fs14.unlinkSync(filePath);
+    } catch {
+    }
+    return;
+  }
+  if (existing.pid !== ownerPid) return;
+  try {
+    fs14.unlinkSync(filePath);
+  } catch {
+  }
+}
+
 // src/main.ts
-var RUNTIME_DIR = path16.join(CTI_HOME, "runtime");
-var STATUS_FILE = path16.join(RUNTIME_DIR, "status.json");
-var PID_FILE = path16.join(RUNTIME_DIR, "bridge.pid");
+var RUNTIME_DIR = path17.join(CTI_HOME, "runtime");
+var STATUS_FILE = path17.join(RUNTIME_DIR, "status.json");
+var PID_FILE = path17.join(RUNTIME_DIR, "bridge.pid");
 async function resolveProvider(config2, pendingPerms) {
   const runtime = config2.runtime;
   if (runtime === "codex") {
@@ -23258,16 +23344,16 @@ async function resolveProvider(config2, pendingPerms) {
   return new SDKLLMProvider(pendingPerms, cliPath, config2.autoApprove);
 }
 function writeStatus(info) {
-  fs15.mkdirSync(RUNTIME_DIR, { recursive: true });
+  fs16.mkdirSync(RUNTIME_DIR, { recursive: true });
   let existing = {};
   try {
-    existing = JSON.parse(fs15.readFileSync(STATUS_FILE, "utf-8"));
+    existing = JSON.parse(fs16.readFileSync(STATUS_FILE, "utf-8"));
   } catch {
   }
   const merged = { ...existing, ...info };
   const tmp = STATUS_FILE + ".tmp";
-  fs15.writeFileSync(tmp, JSON.stringify(merged, null, 2), "utf-8");
-  fs15.renameSync(tmp, STATUS_FILE);
+  fs16.writeFileSync(tmp, JSON.stringify(merged, null, 2), "utf-8");
+  fs16.renameSync(tmp, STATUS_FILE);
 }
 function getRunningChannels() {
   return getStatus().adapters.map((adapter) => adapter.channelType).sort();
@@ -23276,6 +23362,24 @@ function getAdapterStatuses() {
   return getStatus().adapters;
 }
 async function main() {
+  const lockState = tryAcquireBridgeInstanceLock();
+  if (!lockState.acquired) {
+    const holderPid = lockState.holderPid;
+    writeStatus({
+      running: true,
+      ...Number.isFinite(holderPid) && holderPid ? { pid: holderPid } : {}
+    });
+    console.log(
+      `[codex-to-im] Another bridge daemon is already running${holderPid ? ` (PID: ${holderPid})` : ""}. Exiting duplicate launcher.`
+    );
+    process.exit(0);
+  }
+  let instanceLockHeld = true;
+  const releaseInstanceLock = () => {
+    if (!instanceLockHeld) return;
+    releaseBridgeInstanceLock(void 0, process.pid);
+    instanceLockHeld = false;
+  };
   const config2 = loadConfig();
   setupLogger();
   const runId = crypto10.randomUUID();
@@ -23294,8 +23398,8 @@ async function main() {
     permissions: gateway,
     lifecycle: {
       onBridgeStart: () => {
-        fs15.mkdirSync(RUNTIME_DIR, { recursive: true });
-        fs15.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+        fs16.mkdirSync(RUNTIME_DIR, { recursive: true });
+        fs16.writeFileSync(PID_FILE, String(process.pid), "utf-8");
         const channels = getRunningChannels();
         writeStatus({
           running: true,
@@ -23318,6 +23422,7 @@ async function main() {
         console.log(`[codex-to-im] Active channels updated: ${channels.join(", ") || "none"}`);
       },
       onBridgeStop: () => {
+        releaseInstanceLock();
         writeStatus({ running: false, channels: [], adapters: [] });
         console.log("[codex-to-im] Bridge stopped");
       }
@@ -23332,6 +23437,7 @@ async function main() {
     console.log(`[codex-to-im] Shutting down (${reason})...`);
     pendingPerms.denyAll();
     await stop();
+    releaseInstanceLock();
     writeStatus({ running: false, lastExitReason: reason });
     process.exit(0);
   };
@@ -23344,6 +23450,7 @@ async function main() {
   });
   process.on("uncaughtException", (err) => {
     console.error("[codex-to-im] uncaughtException:", err.stack || err.message);
+    releaseInstanceLock();
     writeStatus({ running: false, lastExitReason: `uncaughtException: ${err.message}` });
     process.exit(1);
   });
@@ -23351,6 +23458,7 @@ async function main() {
     console.log(`[codex-to-im] beforeExit (code: ${code2})`);
   });
   process.on("exit", (code2) => {
+    releaseInstanceLock();
     console.log(`[codex-to-im] exit (code: ${code2})`);
   });
   setInterval(() => {
@@ -23358,6 +23466,7 @@ async function main() {
 }
 main().catch((err) => {
   console.error("[codex-to-im] Fatal error:", err instanceof Error ? err.stack || err.message : err);
+  releaseBridgeInstanceLock(void 0, process.pid);
   try {
     writeStatus({ running: false, lastExitReason: `fatal: ${err instanceof Error ? err.message : String(err)}` });
   } catch {