codex-to-im 1.0.28 → 1.0.29

package/dist/cli.mjs

@@ -86,6 +86,30 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+function collectTrackedBridgePids(bridgePid, statusPid) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const pid of [bridgePid, statusPid]) {
+    if (Number.isFinite(pid) && pid > 0) {
+      unique.add(pid);
+    }
+  }
+  return [...unique];
+}
+function resolveTrackedBridgePid(bridgePid, statusPid, isAlive = isProcessAlive) {
+  if (isAlive(bridgePid)) return bridgePid;
+  if (isAlive(statusPid)) return statusPid;
+  return bridgePid ?? statusPid;
+}
+function getTrackedBridgePids(status) {
+  const resolvedStatus = status ?? readJsonFile(bridgeStatusFile, { running: false });
+  return collectTrackedBridgePids(readPid(bridgePidFile), resolvedStatus.pid);
+}
+function clearBridgePidFile() {
+  try {
+    fs2.unlinkSync(bridgePidFile);
+  } catch {
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -246,7 +270,7 @@ function getCurrentUiServerUrl() {
 }
 function getBridgeStatus() {
   const status = readJsonFile(bridgeStatusFile, { running: false });
-  const pid = readPid(bridgePidFile) ?? status.pid;
+  const pid = resolveTrackedBridgePid(readPid(bridgePidFile), status.pid);
   if (!isProcessAlive(pid)) {
     return {
       ...status,
@@ -311,7 +335,11 @@ async function waitForUiServer(timeoutMs = 15e3) {
 async function startBridge() {
   ensureDirs();
   const current = getBridgeStatus();
-  if (current.running) return current;
+  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive(pid));
+  if (current.running && extraAlivePids.length === 0) return current;
+  if (current.running && extraAlivePids.length > 0) {
+    await stopBridge();
+  }
   const daemonEntry = path2.join(packageRoot, "dist", "daemon.mjs");
   if (!fs2.existsSync(daemonEntry)) {
     throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
@@ -333,31 +361,38 @@ async function startBridge() {
   return status;
 }
 async function stopBridge() {
-  const status = getBridgeStatus();
-  if (!status.pid || !isProcessAlive(status.pid)) {
-    return { ...status, running: false };
-  }
-  if (process.platform === "win32") {
-    await new Promise((resolve) => {
-      const killer = spawn("cmd", ["/c", "taskkill", "/PID", String(status.pid), "/T", "/F"], {
-        stdio: "ignore",
-        ...WINDOWS_HIDE
+  const status = readJsonFile(bridgeStatusFile, { running: false });
+  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive(pid));
+  if (pids.length === 0) {
+    clearBridgePidFile();
+    return { ...getBridgeStatus(), running: false };
+  }
+  for (const pid of pids) {
+    if (process.platform === "win32") {
+      await new Promise((resolve) => {
+        const killer = spawn("cmd", ["/c", "taskkill", "/PID", String(pid), "/T", "/F"], {
+          stdio: "ignore",
+          ...WINDOWS_HIDE
+        });
+        killer.on("exit", () => resolve());
+        killer.on("error", () => resolve());
       });
-      killer.on("exit", () => resolve());
-      killer.on("error", () => resolve());
-    });
-  } else {
-    try {
-      process.kill(status.pid, "SIGTERM");
-    } catch {
+    } else {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
     }
   }
   const startedAt = Date.now();
   while (Date.now() - startedAt < 1e4) {
-    const next = getBridgeStatus();
-    if (!next.running) return next;
+    if (pids.every((pid) => !isProcessAlive(pid))) {
+      clearBridgePidFile();
+      return getBridgeStatus();
+    }
     await sleep(300);
   }
+  clearBridgePidFile();
   return getBridgeStatus();
 }
 async function getBridgeAutostartStatus() {

package/dist/daemon.mjs

@@ -4255,6 +4255,7 @@ function getRegisteredTypes() {
 // src/lib/bridge/bridge-manager.ts
 import fs8 from "node:fs";
 import path11 from "node:path";
+import { inspect } from "node:util";
 
 // src/lib/bridge/adapters/telegram-adapter.ts
 import crypto from "crypto";
@@ -14233,12 +14234,6 @@ var WeixinAdapter = class extends BaseChannelAdapter {
     }
   }
   validateConfig() {
-    const linkedAccounts = this.filterConfiguredAccounts(
-      listWeixinAccounts().filter((account) => account.enabled && account.token)
-    );
-    if (linkedAccounts.length === 0) {
-      return "No linked WeChat account. Run the WeChat QR login helper first.";
-    }
     return null;
   }
   isAuthorized(_userId, _chatId) {
@@ -17018,6 +17013,9 @@ var MODE_OPTIONS_TEXT = "\u53EF\u9009\uFF1A`code`\uFF08\u76F4\u63A5\u6267\u884C\
 var REASONING_OPTIONS_TEXT = "\u53EF\u9009\uFF1A`1=minimal` `2=low` `3=medium` `4=high` `5=xhigh`";
 var DEFAULT_DESKTOP_THREAD_LIST_LIMIT = 10;
 var MAX_DESKTOP_THREAD_LIST_LIMIT = 200;
+var DANGLING_MIRROR_THREAD_RETRY_LIMIT = 3;
+var MIRROR_FAILURE_SUSPEND_MS = 6e4;
+var MIRROR_FAILURE_SUSPEND_THRESHOLD = 3;
 var MIRROR_POLL_INTERVAL_MS = 2500;
 var MIRROR_WATCH_DEBOUNCE_MS = 350;
 var MIRROR_EVENT_BATCH_LIMIT = 8;
@@ -17027,6 +17025,7 @@ var INTERACTIVE_IDLE_REMINDER_MS = 6e5;
 var MIRROR_IDLE_TIMEOUT_MS = 6e5;
 var AVAILABLE_CODEX_MODELS = listSelectableCodexModels();
 var AVAILABLE_CODEX_MODEL_MAP = new Map(AVAILABLE_CODEX_MODELS.map((model) => [model.slug, model]));
+var INVALID_ADAPTER_WARNING_CACHE = /* @__PURE__ */ new Map();
 function generateDraftId() {
   return Math.floor(Math.random() * 2147483646) + 1;
 }
@@ -17109,8 +17108,41 @@ function resolveByIndexOrPrefix(raw, items, getId) {
   }
   return { match: null, ambiguous: false };
 }
+function describeUnknownError(error) {
+  if (error instanceof Error) {
+    return error.stack || `${error.name}: ${error.message}`;
+  }
+  if (error === null) return "null";
+  if (typeof error === "undefined") return "undefined";
+  if (typeof error === "object") {
+    const ctor = error?.constructor?.name;
+    const rendered = inspect(error, {
+      depth: 4,
+      breakLength: Infinity,
+      compact: true
+    });
+    return ctor && ctor !== "Object" ? `${ctor} ${rendered}` : rendered;
+  }
+  return String(error);
+}
 function getDisplayedDesktopThreads(limit = DEFAULT_DESKTOP_THREAD_LIST_LIMIT) {
-  return listDesktopSessions(limit);
+  try {
+    return listDesktopSessions(limit);
+  } catch (error) {
+    console.error("[bridge-manager] Failed to list desktop sessions:", error);
+    return null;
+  }
+}
+function getDesktopSessionByThreadIdSafe(threadId, context) {
+  try {
+    return getDesktopSessionByThreadId(threadId);
+  } catch (error) {
+    console.error(
+      `[bridge-manager] Failed to load desktop thread ${threadId} during ${context}:`,
+      error
+    );
+    return null;
+  }
 }
 function parseDesktopThreadListArgs(args) {
   const trimmed = args.trim().toLowerCase();
@@ -17522,7 +17554,7 @@ async function summarizeHistory(currentBinding) {
 }
 function getDesktopThreadTitle(threadId) {
   if (!threadId) return null;
-  return getDesktopSessionByThreadId(threadId)?.title || null;
+  return getDesktopSessionByThreadIdSafe(threadId, "status lookup")?.title || null;
 }
 function formatCommandPath(cwd) {
   return cwd?.trim() || "~";
@@ -17684,6 +17716,7 @@ function getState() {
     g[GLOBAL_KEY] = {
       adapters: /* @__PURE__ */ new Map(),
       adapterMeta: /* @__PURE__ */ new Map(),
+      invalidAdapters: /* @__PURE__ */ new Map(),
       running: false,
       startedAt: null,
       loopAborts: /* @__PURE__ */ new Map(),
@@ -17706,6 +17739,9 @@ function getState() {
   if (!g[GLOBAL_KEY].mirrorSubscriptions) {
     g[GLOBAL_KEY].mirrorSubscriptions = /* @__PURE__ */ new Map();
   }
+  if (!g[GLOBAL_KEY].invalidAdapters) {
+    g[GLOBAL_KEY].invalidAdapters = /* @__PURE__ */ new Map();
+  }
   if (!g[GLOBAL_KEY].queuedCounts) {
     g[GLOBAL_KEY].queuedCounts = /* @__PURE__ */ new Map();
   }
@@ -18065,7 +18101,9 @@ function scheduleMirrorWake(delayMs = MIRROR_WATCH_DEBOUNCE_MS) {
   if (state.mirrorWakeTimer) return;
   state.mirrorWakeTimer = setTimeout(() => {
     state.mirrorWakeTimer = null;
-    void reconcileMirrorSubscriptions();
+    void reconcileMirrorSubscriptions().catch((err) => {
+      console.error("[bridge-manager] Mirror wake reconcile failed:", describeUnknownError(err));
+    });
   }, delayMs);
 }
 function watchMirrorFile(subscription, filePath) {
@@ -18103,6 +18141,16 @@ function syncMirrorSessionState(sessionId) {
     mirror_last_event_at: deliveredAt
   });
 }
+function syncMirrorSessionStateSafe(sessionId, context) {
+  try {
+    syncMirrorSessionState(sessionId);
+  } catch (error) {
+    console.error(
+      `[bridge-manager] Failed to sync mirror session state for ${sessionId} during ${context}:`,
+      describeUnknownError(error)
+    );
+  }
+}
 function getMirrorAssistantRuntimeLabel() {
   const { store } = getBridgeContext();
   const runtime = (store.getSetting("bridge_runtime") || "codex").trim().toLowerCase();
@@ -18467,7 +18515,17 @@ function removeMirrorSubscription(bindingId) {
   stopMirrorStreaming(existing);
   closeMirrorWatcher(existing);
   state.mirrorSubscriptions.delete(bindingId);
-  syncMirrorSessionState(existing.sessionId);
+  syncMirrorSessionStateSafe(existing.sessionId, "mirror subscription removal");
+}
+function clearDanglingMirrorThread(subscription, reason) {
+  const { store } = getBridgeContext();
+  const session = store.getSession(subscription.sessionId);
+  const currentThreadId = session?.sdk_session_id || subscription.threadId;
+  console.warn(
+    `[bridge-manager] Clearing dangling desktop thread ${currentThreadId} for session ${subscription.sessionId}: ${reason}`
+  );
+  store.updateSdkSessionId(subscription.sessionId, "");
+  removeMirrorSubscription(subscription.bindingId);
 }
 function upsertMirrorSubscription(binding) {
   const { store } = getBridgeContext();
@@ -18482,7 +18540,7 @@ function upsertMirrorSubscription(binding) {
     removeMirrorSubscription(binding.id);
     return;
   }
-  const desktopSession = getDesktopSessionByThreadId(threadId);
+  const desktopSession = getDesktopSessionByThreadIdSafe(threadId, "mirror subscription sync");
   const filePath = desktopSession?.filePath || null;
   const existing = state.mirrorSubscriptions.get(binding.id);
   if (!existing) {
@@ -18507,11 +18565,14 @@ function upsertMirrorSubscription(binding) {
       trailingText: "",
       activeMirrorTurnId: null,
       bufferedRecords: [],
-      pendingTurn: null
+      pendingTurn: null,
+      missingThreadPolls: 0,
+      consecutiveFailures: 0,
+      suspendedUntil: null
     };
     watchMirrorFile(created, filePath);
     state.mirrorSubscriptions.set(binding.id, created);
-    syncMirrorSessionState(binding.codepilotSessionId);
+    syncMirrorSessionStateSafe(binding.codepilotSessionId, "mirror subscription create");
     return;
   }
   const previousSessionId = existing.sessionId;
@@ -18529,18 +18590,23 @@ function upsertMirrorSubscription(binding) {
     existing.lastDeliveredAt = session.mirror_last_event_at || null;
     existing.dirty = true;
     existing.pendingTurn = null;
+    existing.missingThreadPolls = 0;
+    existing.consecutiveFailures = 0;
+    existing.suspendedUntil = null;
     resetMirrorReadState(existing);
   } else if (filePathChanged) {
     stopMirrorStreaming(existing);
     existing.dirty = true;
     existing.pendingTurn = null;
+    existing.consecutiveFailures = 0;
+    existing.suspendedUntil = null;
     resetMirrorReadState(existing);
   }
   watchMirrorFile(existing, filePath);
   if (previousSessionId !== binding.codepilotSessionId) {
-    syncMirrorSessionState(previousSessionId);
+    syncMirrorSessionStateSafe(previousSessionId, "mirror subscription rebind previous session");
   }
-  syncMirrorSessionState(binding.codepilotSessionId);
+  syncMirrorSessionStateSafe(binding.codepilotSessionId, "mirror subscription upsert");
 }
 function syncMirrorSubscriptionSet() {
   const { store } = getBridgeContext();
@@ -18554,7 +18620,14 @@ function syncMirrorSubscriptionSet() {
   const desiredIds = /* @__PURE__ */ new Set();
   for (const binding of desiredBindings) {
     desiredIds.add(binding.id);
-    upsertMirrorSubscription(binding);
+    try {
+      upsertMirrorSubscription(binding);
+    } catch (error) {
+      console.error(
+        `[bridge-manager] Failed to sync mirror subscription for binding ${binding.id}:`,
+        error
+      );
+    }
   }
   for (const bindingId of Array.from(state.mirrorSubscriptions.keys())) {
     if (!desiredIds.has(bindingId)) {
@@ -18569,7 +18642,29 @@ async function reconcileMirrorSubscription(subscription) {
     removeMirrorSubscription(subscription.bindingId);
     return;
   }
-  const desktopSession = getDesktopSessionByThreadId(subscription.threadId);
+  if (subscription.suspendedUntil && Date.now() < subscription.suspendedUntil) {
+    syncMirrorSessionStateSafe(subscription.sessionId, "mirror suspension");
+    return;
+  }
+  if (subscription.suspendedUntil) {
+    subscription.suspendedUntil = null;
+  }
+  const desktopSession = getDesktopSessionByThreadIdSafe(
+    subscription.threadId,
+    "mirror reconcile"
+  );
+  if (!desktopSession) {
+    subscription.missingThreadPolls += 1;
+    if (subscription.missingThreadPolls >= DANGLING_MIRROR_THREAD_RETRY_LIMIT) {
+      clearDanglingMirrorThread(
+        subscription,
+        "desktop thread no longer exists locally"
+      );
+      return;
+    }
+  } else {
+    subscription.missingThreadPolls = 0;
+  }
   const filePathChanged = subscription.filePath !== (desktopSession?.filePath || null);
   subscription.filePath = desktopSession?.filePath || null;
   subscription.status = subscription.filePath ? "watching" : "stale";
@@ -18580,7 +18675,7 @@ async function reconcileMirrorSubscription(subscription) {
   watchMirrorFile(subscription, subscription.filePath);
   subscription.lastReconciledAt = nowIso2();
   if (!subscription.filePath) {
-    syncMirrorSessionState(subscription.sessionId);
+    syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile without file");
     return;
   }
   const snapshot = statMirrorFile(subscription.filePath);
@@ -18588,12 +18683,12 @@ async function reconcileMirrorSubscription(subscription) {
     subscription.status = "stale";
     subscription.dirty = true;
     resetMirrorReadState(subscription);
-    syncMirrorSessionState(subscription.sessionId);
+    syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile missing snapshot");
     return;
   }
   const unchanged = !subscription.dirty && subscription.fileIdentity === snapshot.identity && subscription.fileSize === snapshot.size && subscription.fileMtimeMs === snapshot.mtimeMs;
   if (unchanged && !hasPendingMirrorWork(subscription)) {
-    syncMirrorSessionState(subscription.sessionId);
+    syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile unchanged snapshot");
     return;
   }
   let deliverableRecords = [];
@@ -18648,13 +18743,13 @@ async function reconcileMirrorSubscription(subscription) {
         console.warn("[bridge-manager] Mirror delivery failed:", error instanceof Error ? error.message : error);
       }
     }
-    syncMirrorSessionState(subscription.sessionId);
+    syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile active task");
     return;
   }
   const finalizedTurns = timedOutTurn ? [timedOutTurn] : [];
   finalizedTurns.push(...consumeBufferedMirrorTurns(subscription));
   if (finalizedTurns.length === 0) {
-    syncMirrorSessionState(subscription.sessionId);
+    syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile no finalized turns");
     return;
   }
   try {
@@ -18663,29 +18758,66 @@ async function reconcileMirrorSubscription(subscription) {
     subscription.dirty = true;
     console.warn("[bridge-manager] Mirror delivery failed:", error instanceof Error ? error.message : error);
   }
-  syncMirrorSessionState(subscription.sessionId);
+  syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile delivered turns");
 }
 async function reconcileMirrorSubscriptions() {
   const state = getState();
   if (!state.running || state.mirrorSyncInFlight) return;
   state.mirrorSyncInFlight = true;
+  let stage = "sync-start";
   try {
-    syncMirrorSubscriptionSet();
-    for (const subscription of state.mirrorSubscriptions.values()) {
+    try {
+      stage = "sync-subscription-set";
+      syncMirrorSubscriptionSet();
+    } catch (error) {
+      console.error("[bridge-manager] Mirror subscription set reconcile failed:", error);
+      return;
+    }
+    stage = "snapshot-subscriptions";
+    const subscriptions = Array.from(state.mirrorSubscriptions.values());
+    for (const subscription of subscriptions) {
+      stage = `subscription:${subscription.bindingId}`;
       try {
         await reconcileMirrorSubscription(subscription);
+        subscription.consecutiveFailures = 0;
+        subscription.suspendedUntil = null;
       } catch (error) {
-        stopMirrorStreaming(subscription, "interrupted");
-        resetMirrorReadState(subscription);
-        subscription.status = "stale";
-        subscription.dirty = false;
-        console.error(
-          `[bridge-manager] Mirror reconcile failed for thread ${subscription.threadId}:`,
-          error instanceof Error ? error.stack || error.message : error
-        );
-        syncMirrorSessionState(subscription.sessionId);
+        try {
+          stopMirrorStreaming(subscription, "interrupted");
+          subscription.pendingTurn = null;
+          subscription.bufferedRecords = [];
+          subscription.status = "stale";
+          subscription.dirty = false;
+          subscription.consecutiveFailures += 1;
+          if (subscription.consecutiveFailures >= MIRROR_FAILURE_SUSPEND_THRESHOLD) {
+            subscription.suspendedUntil = Date.now() + MIRROR_FAILURE_SUSPEND_MS;
+            console.warn(
+              `[bridge-manager] Mirror subscription for thread ${subscription.threadId} is suspended for ${Math.round(MIRROR_FAILURE_SUSPEND_MS / 1e3)}s after ${subscription.consecutiveFailures} consecutive failures`
+            );
+          }
+          console.error(
+            `[bridge-manager] Mirror reconcile failed for thread ${subscription.threadId}:`,
+            describeUnknownError(error)
+          );
+          syncMirrorSessionStateSafe(subscription.sessionId, "mirror reconcile failure");
+        } catch (recoveryError) {
+          console.error(
+            `[bridge-manager] Mirror reconcile recovery failed for thread ${subscription.threadId}:`,
+            describeUnknownError(recoveryError)
+          );
+          console.error(
+            `[bridge-manager] Original mirror reconcile error for thread ${subscription.threadId}:`,
+            describeUnknownError(error)
+          );
+        }
       }
     }
+    stage = "sync-complete";
+  } catch (error) {
+    console.error(
+      `[bridge-manager] Mirror reconcile failed during ${stage}:`,
+      describeUnknownError(error)
+    );
   } finally {
     state.mirrorSyncInFlight = false;
   }
@@ -18774,6 +18906,8 @@ function listEnabledAdapterInstances() {
 async function stopAdapterInstance(channelType) {
   const state = getState();
   const adapter = state.adapters.get(channelType);
+  state.invalidAdapters.delete(channelType);
+  INVALID_ADAPTER_WARNING_CACHE.delete(channelType);
   if (!adapter) return;
   state.loopAborts.get(channelType)?.abort();
   state.loopAborts.delete(channelType);
@@ -18799,6 +18933,14 @@ async function syncConfiguredAdapters(options) {
     await stopAdapterInstance(existingKey);
     changed = true;
   }
+  for (const invalidKey of Array.from(state.invalidAdapters.keys())) {
+    if (desiredKeys.has(invalidKey)) continue;
+    state.invalidAdapters.delete(invalidKey);
+  }
+  for (const invalidKey of Array.from(INVALID_ADAPTER_WARNING_CACHE.keys())) {
+    if (desiredKeys.has(invalidKey)) continue;
+    INVALID_ADAPTER_WARNING_CACHE.delete(invalidKey);
+  }
   for (const instance of desiredInstances) {
     const existing = state.adapters.get(instance.id);
     const desiredFingerprint = desiredFingerprints.get(instance.id) || "";
@@ -18812,9 +18954,16 @@ async function syncConfiguredAdapters(options) {
     if (!adapter) continue;
     const configError = adapter.validateConfig();
     if (configError) {
-      console.warn(`[bridge-manager] ${instance.id} adapter not valid:`, configError);
+      const invalidSignature = `${desiredFingerprint}:${configError}`;
+      if (INVALID_ADAPTER_WARNING_CACHE.get(instance.id) !== invalidSignature) {
+        console.warn(`[bridge-manager] ${instance.id} adapter not valid:`, configError);
+        INVALID_ADAPTER_WARNING_CACHE.set(instance.id, invalidSignature);
+        state.invalidAdapters.set(instance.id, invalidSignature);
+      }
       continue;
     }
+    state.invalidAdapters.delete(instance.id);
+    INVALID_ADAPTER_WARNING_CACHE.delete(instance.id);
     try {
       state.adapters.set(instance.id, adapter);
       state.adapterMeta.set(instance.id, {
@@ -18874,11 +19023,11 @@ async function start() {
   }, 5e3);
   state.mirrorPollTimer = setInterval(() => {
     void reconcileMirrorSubscriptions().catch((err) => {
-      console.error("[bridge-manager] Mirror reconcile failed:", err);
+      console.error("[bridge-manager] Mirror reconcile failed:", describeUnknownError(err));
     });
   }, MIRROR_POLL_INTERVAL_MS);
   void reconcileMirrorSubscriptions().catch((err) => {
-    console.error("[bridge-manager] Initial mirror reconcile failed:", err);
+    console.error("[bridge-manager] Initial mirror reconcile failed:", describeUnknownError(err));
   });
   console.log(`[bridge-manager] Bridge started with ${startedCount} adapter(s)`);
 }
@@ -18911,6 +19060,8 @@ async function stop() {
   state.mirrorSuppressUntil.clear();
   state.mirrorIgnoredTurnIds.clear();
   state.queuedCounts.clear();
+  state.invalidAdapters.clear();
+  INVALID_ADAPTER_WARNING_CACHE.clear();
   for (const sessionId of activeSessionIds) {
     syncSessionRuntimeState(sessionId);
   }
@@ -19403,6 +19554,10 @@ async function handleCommand(adapter, msg, text2) {
       }
       if (args === "all") {
         const desktopSessions = getDisplayedDesktopThreads(MAX_DESKTOP_THREAD_LIST_LIMIT);
+        if (!desktopSessions) {
+          response = "\u8BFB\u53D6\u684C\u9762\u4F1A\u8BDD\u5217\u8868\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+          break;
+        }
         if (desktopSessions.length === 0) {
           response = "\u6CA1\u6709\u627E\u5230\u684C\u9762\u4F1A\u8BDD\u3002\u5148\u5728 Codex Desktop App \u4E2D\u6253\u5F00\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u518D\u56DE\u6765\u8BD5\u4E00\u6B21\u3002";
           break;
@@ -19415,6 +19570,10 @@ async function handleCommand(adapter, msg, text2) {
         break;
       }
       const displayedThreads = getDisplayedDesktopThreads(MAX_DESKTOP_THREAD_LIST_LIMIT);
+      if (!displayedThreads) {
+        response = "\u8BFB\u53D6\u684C\u9762\u4F1A\u8BDD\u5217\u8868\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+        break;
+      }
       const threadPick = resolveByIndexOrPrefix(args, displayedThreads, (session) => session.threadId);
       if (threadPick.ambiguous) {
         response = "\u5339\u914D\u5230\u591A\u4E2A\u684C\u9762\u4F1A\u8BDD\uFF0C\u8BF7\u5148\u53D1\u9001 `/t` \u67E5\u770B\u5217\u8868\uFF0C\u518D\u7528 `/t 1` \u8FD9\u79CD\u5E8F\u53F7\u5207\u6362\u3002";
@@ -19422,7 +19581,7 @@ async function handleCommand(adapter, msg, text2) {
       }
       if (!threadPick.match) {
         if (validateSessionId(args)) {
-          const desktop = getDesktopSessionByThreadId(args);
+          const desktop = getDesktopSessionByThreadIdSafe(args, "thread switch");
           let binding2;
           try {
             binding2 = bindToSdkSession(msg.address, args, desktop ? {
@@ -19481,6 +19640,10 @@ async function handleCommand(adapter, msg, text2) {
       }
       const { showAll, limit } = listArgs;
       const desktopSessions = getDisplayedDesktopThreads(limit);
+      if (!desktopSessions) {
+        response = "\u8BFB\u53D6\u684C\u9762\u4F1A\u8BDD\u5217\u8868\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+        break;
+      }
       if (desktopSessions.length === 0) {
         response = showAll ? "\u6CA1\u6709\u627E\u5230\u684C\u9762\u4F1A\u8BDD\u3002\u5148\u5728 Codex Desktop App \u4E2D\u6253\u5F00\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u518D\u56DE\u6765\u8BD5\u4E00\u6B21\u3002" : "\u6CA1\u6709\u627E\u5230\u6700\u8FD1\u684C\u9762\u4F1A\u8BDD\u3002\u5148\u5728 Codex Desktop App \u4E2D\u6253\u5F00\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u518D\u56DE\u6765\u8BD5\u4E00\u6B21\u3002";
         break;
@@ -20887,6 +21050,7 @@ var PendingPermissions = class {
 // src/logger.ts
 import fs11 from "node:fs";
 import path13 from "node:path";
+import { inspect as inspect2 } from "node:util";
 var MASK_PATTERNS = [
   /(?:token|secret|password|api_key)["']?\s*[:=]\s*["']?([^\s"',]+)/gi,
   /bot\d+:[A-Za-z0-9_-]{35}/g,
@@ -20908,6 +21072,22 @@ var LOG_PATH = path13.join(LOG_DIR, "bridge.log");
 var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_ROTATED = 3;
 var logStream = null;
+function formatLogArg(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) {
+    return value.stack || `${value.name}: ${value.message}`;
+  }
+  if (value === null) return "null";
+  if (typeof value === "undefined") return "undefined";
+  if (typeof value === "object") {
+    return inspect2(value, {
+      depth: 4,
+      breakLength: Infinity,
+      compact: true
+    });
+  }
+  return String(value);
+}
 function openLogStream() {
   return fs11.createWriteStream(LOG_PATH, { flags: "a" });
 }
@@ -20937,7 +21117,7 @@ function setupLogger() {
   logStream = openLogStream();
   const write = (level, args) => {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+    const message = args.map((a) => formatLogArg(a)).join(" ");
     const formatted = `[${timestamp}] [${level}] ${message}`;
     const masked = maskSecrets(formatted);
     rotateIfNeeded();

package/dist/ui-server.mjs

@@ -5646,6 +5646,30 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+function collectTrackedBridgePids(bridgePid, statusPid) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const pid of [bridgePid, statusPid]) {
+    if (Number.isFinite(pid) && pid > 0) {
+      unique.add(pid);
+    }
+  }
+  return [...unique];
+}
+function resolveTrackedBridgePid(bridgePid, statusPid, isAlive = isProcessAlive) {
+  if (isAlive(bridgePid)) return bridgePid;
+  if (isAlive(statusPid)) return statusPid;
+  return bridgePid ?? statusPid;
+}
+function getTrackedBridgePids(status) {
+  const resolvedStatus = status ?? readJsonFile(bridgeStatusFile, { running: false });
+  return collectTrackedBridgePids(readPid(bridgePidFile), resolvedStatus.pid);
+}
+function clearBridgePidFile() {
+  try {
+    fs3.unlinkSync(bridgePidFile);
+  } catch {
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -5700,7 +5724,7 @@ function getUiServerUrl(port2 = uiPort) {
 }
 function getBridgeStatus() {
   const status = readJsonFile(bridgeStatusFile, { running: false });
-  const pid = readPid(bridgePidFile) ?? status.pid;
+  const pid = resolveTrackedBridgePid(readPid(bridgePidFile), status.pid);
   if (!isProcessAlive(pid)) {
     return {
       ...status,
@@ -5750,7 +5774,11 @@ async function waitForBridgeRunning(timeoutMs = 2e4) {
 async function startBridge() {
   ensureDirs();
   const current = getBridgeStatus();
-  if (current.running) return current;
+  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive(pid));
+  if (current.running && extraAlivePids.length === 0) return current;
+  if (current.running && extraAlivePids.length > 0) {
+    await stopBridge();
+  }
   const daemonEntry = path4.join(packageRoot, "dist", "daemon.mjs");
   if (!fs3.existsSync(daemonEntry)) {
     throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
@@ -5772,31 +5800,38 @@ async function startBridge() {
   return status;
 }
 async function stopBridge() {
-  const status = getBridgeStatus();
-  if (!status.pid || !isProcessAlive(status.pid)) {
-    return { ...status, running: false };
-  }
-  if (process.platform === "win32") {
-    await new Promise((resolve) => {
-      const killer = spawn("cmd", ["/c", "taskkill", "/PID", String(status.pid), "/T", "/F"], {
-        stdio: "ignore",
-        ...WINDOWS_HIDE
+  const status = readJsonFile(bridgeStatusFile, { running: false });
+  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive(pid));
+  if (pids.length === 0) {
+    clearBridgePidFile();
+    return { ...getBridgeStatus(), running: false };
+  }
+  for (const pid of pids) {
+    if (process.platform === "win32") {
+      await new Promise((resolve) => {
+        const killer = spawn("cmd", ["/c", "taskkill", "/PID", String(pid), "/T", "/F"], {
+          stdio: "ignore",
+          ...WINDOWS_HIDE
+        });
+        killer.on("exit", () => resolve());
+        killer.on("error", () => resolve());
       });
-      killer.on("exit", () => resolve());
-      killer.on("error", () => resolve());
-    });
-  } else {
-    try {
-      process.kill(status.pid, "SIGTERM");
-    } catch {
+    } else {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
     }
   }
   const startedAt = Date.now();
   while (Date.now() - startedAt < 1e4) {
-    const next = getBridgeStatus();
-    if (!next.running) return next;
+    if (pids.every((pid) => !isProcessAlive(pid))) {
+      clearBridgePidFile();
+      return getBridgeStatus();
+    }
     await sleep(300);
   }
+  clearBridgePidFile();
   return getBridgeStatus();
 }
 async function restartBridge() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-to-im",
-  "version": "1.0.28",
+  "version": "1.0.29",
   "description": "Installable Codex-to-IM bridge with local setup UI and background service",
   "license": "MIT",
   "homepage": "https://github.com/zhangle1987/codex-to-im#readme",