codex-to-im 1.0.28 → 1.0.30

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";
@@ -7817,11 +7818,8 @@ function readJson(filePath, fallback) {
 function getAccountRecency(account) {
   return account.lastLoginAt ?? account.updatedAt ?? account.createdAt;
 }
-function normalizeAccounts(accounts) {
-  if (accounts.length <= 1) {
-    return { accounts, removedAccountIds: [] };
-  }
-  const sorted = [...accounts].sort((a, b) => {
+function sortAccountsByRecency(accounts) {
+  return [...accounts].sort((a, b) => {
     const recencyDiff = getAccountRecency(b).localeCompare(getAccountRecency(a));
     if (recencyDiff !== 0) return recencyDiff;
     const updatedDiff = b.updatedAt.localeCompare(a.updatedAt);
@@ -7830,16 +7828,14 @@ function normalizeAccounts(accounts) {
     if (createdDiff !== 0) return createdDiff;
     return 0;
   });
-  const kept = sorted[0];
-  const removedAccountIds = [
-    ...new Set(
-      sorted.slice(1).map((account) => account.accountId).filter((accountId) => accountId !== kept.accountId)
-    )
-  ];
-  return {
-    accounts: [kept],
-    removedAccountIds
-  };
+}
+function normalizeAccounts(accounts) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const account of sortAccountsByRecency(accounts)) {
+    if (!account?.accountId || deduped.has(account.accountId)) continue;
+    deduped.set(account.accountId, account);
+  }
+  return Array.from(deduped.values());
 }
 function readStoredAccounts() {
   ensureDir(DATA_DIR);
@@ -7847,7 +7843,7 @@ function readStoredAccounts() {
   return Array.isArray(raw) ? raw : [];
 }
 function readAccounts() {
-  return normalizeAccounts(readStoredAccounts()).accounts;
+  return normalizeAccounts(readStoredAccounts());
 }
 function readContextTokens() {
   ensureDir(DATA_DIR);
@@ -7861,7 +7857,7 @@ function contextKey(accountId, peerUserId) {
   return `${accountId}::${peerUserId}`;
 }
 function listWeixinAccounts() {
-  return readAccounts().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  return sortAccountsByRecency(readAccounts());
 }
 function getWeixinAccount(accountId) {
   return readAccounts().find((account) => account.accountId === accountId);
@@ -14233,11 +14229,21 @@ 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.";
+    const configuredAccountId = this.configuredAccountId;
+    const accounts = listWeixinAccounts();
+    const enabledAccounts = accounts.filter((account) => account.enabled && account.token);
+    if (configuredAccountId) {
+      const configured = getWeixinAccount(configuredAccountId);
+      if (!configured) {
+        return `Linked WeChat account ${configuredAccountId} not found`;
+      }
+      if (!configured.enabled || !configured.token) {
+        return `Linked WeChat account ${configuredAccountId} is disabled or missing token`;
+      }
+      return null;
+    }
+    if (enabledAccounts.length > 1) {
+      return "Multiple linked WeChat accounts detected. Please select a WeChat account for this channel.";
     }
     return null;
   }
@@ -15375,7 +15381,7 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
 import fs5 from "node:fs";
 import path6 from "node:path";
 var DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
-var MAX_HIDDEN_DRAFT_SESSIONS = 20;
+var MAX_HIDDEN_DRAFT_SESSIONS = 64;
 var INTERNAL_SESSION_ROOT = path6.join(CTI_HOME, "runtime", "internal-sessions");
 var DRAFT_SESSION_PREFIX = "Draft";
 var HISTORY_SESSION_PREFIX = "History Summary";
@@ -17018,6 +17024,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 +17036,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 +17119,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 +17565,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 +17727,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 +17750,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 +18112,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 +18152,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();
@@ -18368,7 +18427,6 @@ function consumeMirrorRecords(subscription, records) {
           subscription.pendingTurn.lastActivityAt = record.timestamp;
         }
       }
-      startMirrorStreaming(subscription, subscription.pendingTurn);
       continue;
     }
     if (record.type === "task_complete") {
@@ -18467,7 +18525,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 +18550,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 +18575,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 +18600,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 +18630,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 +18652,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 +18685,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 +18693,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 +18753,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 +18768,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 +18916,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 +18943,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 +18964,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 +19033,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 +19070,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 +19564,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 +19580,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 +19591,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 +19650,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 +21060,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 +21082,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 +21127,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();