codex-to-im 1.0.18 → 1.0.20

package/dist/cli.mjs

@@ -22,6 +22,29 @@ function resolveDefaultCtiHome() {
 }
 var CTI_HOME = process.env.CTI_HOME || resolveDefaultCtiHome();
 var CONFIG_PATH = path.join(CTI_HOME, "config.env");
+function parseEnvFile(content) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    entries.set(key, value);
+  }
+  return entries;
+}
+function loadRawConfigEnv() {
+  try {
+    return parseEnvFile(fs.readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
 
 // src/service-manager.ts
 var moduleDir = path2.dirname(fileURLToPath(import.meta.url));
@@ -104,6 +127,24 @@ function getUiServerStatus() {
     port: status.port ?? uiPort
   };
 }
+function buildDaemonEnv() {
+  const env = { ...process.env };
+  env.CTI_HOME = CTI_HOME;
+  for (const [key, value] of loadRawConfigEnv()) {
+    env[key] = value;
+  }
+  delete env.CLAUDECODE;
+  return env;
+}
+async function waitForBridgeRunning(timeoutMs = 2e4) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const status = getBridgeStatus();
+    if (status.running) return status;
+    await sleep(500);
+  }
+  return getBridgeStatus();
+}
 async function waitForUiServer(timeoutMs = 15e3) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
@@ -119,6 +160,30 @@ async function waitForUiServer(timeoutMs = 15e3) {
   }
   return getUiServerStatus();
 }
+async function startBridge() {
+  ensureDirs();
+  const current = getBridgeStatus();
+  if (current.running) return current;
+  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.`);
+  }
+  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 child = spawn(process.execPath, [daemonEntry], {
+    cwd: packageRoot,
+    detached: true,
+    env: buildDaemonEnv(),
+    stdio: ["ignore", stdoutFd, stderrFd],
+    ...WINDOWS_HIDE
+  });
+  child.unref();
+  const status = await waitForBridgeRunning();
+  if (!status.running) {
+    throw new Error(status.lastExitReason || "Bridge failed to report running=true.");
+  }
+  return status;
+}
 async function stopBridge() {
   const status = getBridgeStatus();
   if (!status.pid || !isProcessAlive(status.pid)) {
@@ -238,8 +303,19 @@ async function main() {
       const status = await ensureUiServerRunning();
       const url = getUiServerUrl(status.port);
       openBrowser(url);
-      process.stdout.write(`Codex to IM is available at ${url}
+      try {
+        await startBridge();
+        process.stdout.write(`Codex to IM is available at ${url}
 `);
+      } catch (error) {
+        process.stdout.write(`Codex to IM UI is available at ${url}
+`);
+        process.stderr.write(
+          `Bridge failed to start. Open the UI and check logs/config first: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+        process.exitCode = 1;
+      }
       return;
     }
     case "url": {
@@ -260,14 +336,6 @@ async function main() {
       process.exitCode = 1;
       return;
     }
-    case "share-feishu": {
-      const status = await ensureUiServerRunning();
-      const url = `${getUiServerUrl(status.port)}/#desktop`;
-      openBrowser(url);
-      process.stdout.write(`Opened Feishu handoff entry at ${url}
-`);
-      return;
-    }
     case "stop": {
       const bridge = await stopBridge();
       const ui = await stopUiServer();
@@ -290,7 +358,7 @@ async function main() {
       return;
     }
     default:
-      process.stdout.write("Usage: codex-to-im [open|url|share-feishu|stop|status]\n");
+      process.stdout.write("Usage: codex-to-im [open|url|stop|status]\n");
   }
 }
 main().catch((error) => {

package/dist/daemon.mjs

@@ -4047,7 +4047,9 @@ var init_codex_provider = __esm({
                   }
                   let sawAnyEvent = false;
                   try {
-                    const { events } = await thread.runStreamed(input);
+                    const { events } = await thread.runStreamed(input, {
+                      signal: params.abortController?.signal
+                    });
                     for await (const event of events) {
                       sawAnyEvent = true;
                       if (params.abortController?.signal.aborted) {
@@ -5271,15 +5273,18 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   lastIncomingMessageId = /* @__PURE__ */ new Map();
   /** Track active typing reaction IDs per chat for cleanup. */
   typingReactions = /* @__PURE__ */ new Map();
-  /** Active streaming card state per chatId. */
+  /** Active streaming card state per stream key. */
   activeCards = /* @__PURE__ */ new Map();
-  /** In-flight card creation promises per chatId — prevents duplicate creation. */
+  /** In-flight card creation promises per stream key — prevents duplicate creation. */
   cardCreatePromises = /* @__PURE__ */ new Map();
   /** Cached tenant token for upload APIs. */
   tenantTokenCache = null;
   isStreamingEnabled() {
     return getBridgeContext().store.getSetting("bridge_feishu_streaming_enabled") !== "false";
   }
+  resolveStreamKey(chatId, streamKey) {
+    return streamKey?.trim() || chatId;
+  }
   // ── Lifecycle ───────────────────────────────────────────────
   async start() {
     if (this.running) return;
@@ -5384,10 +5389,10 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Add a "Typing" emoji reaction to the user's message and create streaming card.
    * Called by bridge-manager via onMessageStart().
    */
-  onMessageStart(chatId) {
+  onMessageStart(chatId, streamKey) {
     const messageId = this.lastIncomingMessageId.get(chatId);
     if (messageId && this.isStreamingEnabled()) {
-      this.createStreamingCard(chatId, messageId).catch(() => {
+      this.createStreamingCard(chatId, messageId, streamKey).catch(() => {
       });
     }
     if (!messageId || !this.restClient) return;
@@ -5410,8 +5415,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Remove the "Typing" emoji reaction and clean up card state.
    * Called by bridge-manager via onMessageEnd().
    */
-  onMessageEnd(chatId) {
-    this.cleanupCard(chatId);
+  onMessageEnd(chatId, streamKey) {
+    this.cleanupCard(chatId, streamKey);
     const reactionId = this.typingReactions.get(chatId);
     const messageId = this.lastIncomingMessageId.get(chatId);
     if (!reactionId || !messageId || !this.restClient) return;
@@ -5462,17 +5467,19 @@ var FeishuAdapter = class extends BaseChannelAdapter {
    * Create a new streaming card and send it as a message.
    * Returns true if card was created successfully.
    */
-  createStreamingCard(chatId, replyToMessageId) {
-    if (!this.restClient || this.activeCards.has(chatId)) return Promise.resolve(false);
-    const existing = this.cardCreatePromises.get(chatId);
+  createStreamingCard(chatId, replyToMessageId, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.restClient || this.activeCards.has(cardKey)) return Promise.resolve(false);
+    const existing = this.cardCreatePromises.get(cardKey);
     if (existing) return existing;
-    const promise = this._doCreateStreamingCard(chatId, replyToMessageId);
-    this.cardCreatePromises.set(chatId, promise);
-    promise.finally(() => this.cardCreatePromises.delete(chatId));
+    const promise = this._doCreateStreamingCard(chatId, replyToMessageId, cardKey);
+    this.cardCreatePromises.set(cardKey, promise);
+    promise.finally(() => this.cardCreatePromises.delete(cardKey));
     return promise;
   }
-  async _doCreateStreamingCard(chatId, replyToMessageId) {
+  async _doCreateStreamingCard(chatId, replyToMessageId, streamKey) {
     if (!this.restClient) return false;
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.card) {
       console.warn("[feishu-adapter] CardKit v1 API is unavailable in the current Feishu SDK client");
@@ -5526,7 +5533,8 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         console.warn("[feishu-adapter] Card message send returned no message_id");
         return false;
       }
-      this.activeCards.set(chatId, {
+      this.activeCards.set(cardKey, {
+        chatId,
         cardId,
         messageId,
         sequence: 0,
@@ -5537,7 +5545,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         lastUpdateAt: 0,
         throttleTimer: null
       });
-      console.log(`[feishu-adapter] Streaming card created: cardId=${cardId}, msgId=${messageId}`);
+      console.log(`[feishu-adapter] Streaming card created: streamKey=${cardKey}, cardId=${cardId}, msgId=${messageId}`);
       return true;
     } catch (err) {
       console.warn("[feishu-adapter] Failed to create streaming card:", err instanceof Error ? err.message : err);
@@ -5547,8 +5555,9 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   /**
    * Update streaming card content with throttling.
    */
-  updateCardContent(chatId, text2) {
-    const state = this.activeCards.get(chatId);
+  updateCardContent(chatId, text2, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const state = this.activeCards.get(cardKey);
     if (!state || !this.restClient) return;
     if (state.thinking && text2.trim()) {
       state.thinking = false;
@@ -5559,7 +5568,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       if (!state.throttleTimer) {
         state.throttleTimer = setTimeout(() => {
           state.throttleTimer = null;
-          this.flushCardUpdate(chatId);
+          this.flushCardUpdate(cardKey);
         }, CARD_THROTTLE_MS - elapsed);
       }
       return;
@@ -5568,13 +5577,13 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
     }
-    this.flushCardUpdate(chatId);
+    this.flushCardUpdate(cardKey);
   }
   /**
    * Flush pending card update to Feishu API.
    */
-  flushCardUpdate(chatId) {
-    const state = this.activeCards.get(chatId);
+  flushCardUpdate(streamKey) {
+    const state = this.activeCards.get(streamKey);
     if (!state || !this.restClient) return;
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.cardElement?.content) return;
@@ -5594,24 +5603,26 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   /**
    * Update tool progress in the streaming card.
    */
-  updateToolProgress(chatId, tools) {
-    const state = this.activeCards.get(chatId);
+  updateToolProgress(chatId, tools, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const state = this.activeCards.get(cardKey);
     if (!state) return;
     state.toolCalls = tools;
-    this.updateCardContent(chatId, state.pendingText || "");
+    this.updateCardContent(chatId, state.pendingText || "", cardKey);
   }
   /**
    * Finalize the streaming card: close streaming mode, update with final content + footer.
    */
-  async finalizeCard(chatId, status, responseText) {
-    const pending = this.cardCreatePromises.get(chatId);
+  async finalizeCard(chatId, status, responseText, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const pending = this.cardCreatePromises.get(cardKey);
     if (pending) {
       try {
         await pending;
       } catch {
       }
     }
-    const state = this.activeCards.get(chatId);
+    const state = this.activeCards.get(cardKey);
     if (!state || !this.restClient) return false;
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.card?.settings || !cardkit?.card?.update) return false;
@@ -5638,7 +5649,16 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         status: statusLabels[status] || status,
         elapsed: formatElapsed(elapsedMs)
       };
-      const finalCardJson = buildFinalCardJson(responseText, state.toolCalls, footer);
+      const existingText = state.pendingText || "";
+      const trimmedExisting = existingText.trim();
+      const trimmedResponse = responseText.trim();
+      let finalText = trimmedResponse || trimmedExisting;
+      if (status === "interrupted" && trimmedExisting && trimmedResponse && trimmedResponse !== trimmedExisting && !trimmedExisting.includes(trimmedResponse)) {
+        finalText = `${trimmedExisting}
+
+${trimmedResponse}`;
+      }
+      const finalCardJson = buildFinalCardJson(finalText, state.toolCalls, footer);
       state.sequence++;
       await cardkit.card.update({
         path: { card_id: state.cardId },
@@ -5647,63 +5667,66 @@ var FeishuAdapter = class extends BaseChannelAdapter {
           sequence: state.sequence
         }
       });
-      console.log(`[feishu-adapter] Card finalized: cardId=${state.cardId}, status=${status}, elapsed=${formatElapsed(elapsedMs)}`);
+      console.log(`[feishu-adapter] Card finalized: streamKey=${cardKey}, cardId=${state.cardId}, status=${status}, elapsed=${formatElapsed(elapsedMs)}`);
       return true;
     } catch (err) {
       console.warn("[feishu-adapter] Card finalize failed:", err instanceof Error ? err.message : err);
       return false;
     } finally {
-      this.activeCards.delete(chatId);
+      this.activeCards.delete(cardKey);
     }
   }
   /**
    * Clean up card state without finalizing (e.g. on unexpected errors).
    */
-  cleanupCard(chatId) {
-    this.cardCreatePromises.delete(chatId);
-    const state = this.activeCards.get(chatId);
+  cleanupCard(chatId, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    this.cardCreatePromises.delete(cardKey);
+    const state = this.activeCards.get(cardKey);
     if (!state) return;
     if (state.throttleTimer) {
       clearTimeout(state.throttleTimer);
     }
-    this.activeCards.delete(chatId);
+    this.activeCards.delete(cardKey);
   }
   /**
    * Check if there is an active streaming card for a given chat.
    */
-  hasActiveCard(chatId) {
-    return this.activeCards.has(chatId);
+  hasActiveCard(chatId, streamKey) {
+    return this.activeCards.has(this.resolveStreamKey(chatId, streamKey));
   }
   // ── Streaming adapter interface ────────────────────────────────
   /**
    * Called by bridge-manager on each text SSE event.
    * Creates streaming card on first call, then updates content.
    */
-  onStreamText(chatId, fullText) {
+  onStreamText(chatId, fullText, streamKey) {
     if (!this.isStreamingEnabled()) return;
-    if (!this.activeCards.has(chatId)) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.activeCards.has(cardKey)) {
       const messageId = this.lastIncomingMessageId.get(chatId);
-      this.createStreamingCard(chatId, messageId).then((ok) => {
-        if (ok) this.updateCardContent(chatId, fullText);
+      this.createStreamingCard(chatId, messageId, cardKey).then((ok) => {
+        if (ok) this.updateCardContent(chatId, fullText, cardKey);
       }).catch(() => {
       });
       return;
     }
-    this.updateCardContent(chatId, fullText);
+    this.updateCardContent(chatId, fullText, cardKey);
   }
-  onMirrorStreamStart(chatId) {
+  onMirrorStreamStart(chatId, streamKey) {
     if (!this.isStreamingEnabled()) return;
-    if (this.activeCards.has(chatId)) return;
-    this.createStreamingCard(chatId, void 0).catch(() => {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (this.activeCards.has(cardKey)) return;
+    this.createStreamingCard(chatId, void 0, cardKey).catch(() => {
     });
   }
-  onToolEvent(chatId, tools) {
+  onToolEvent(chatId, tools, streamKey) {
     if (!this.isStreamingEnabled()) return;
-    this.updateToolProgress(chatId, tools);
+    this.updateToolProgress(chatId, tools, streamKey);
   }
-  async onStreamEnd(chatId, status, responseText) {
+  async onStreamEnd(chatId, status, responseText, streamKey) {
     if (!this.isStreamingEnabled()) return false;
-    return this.finalizeCard(chatId, status, responseText);
+    return this.finalizeCard(chatId, status, responseText, streamKey);
   }
   // ── Send ────────────────────────────────────────────────────
   async send(message) {
@@ -16784,7 +16807,8 @@ var MIRROR_WATCH_DEBOUNCE_MS = 350;
 var MIRROR_EVENT_BATCH_LIMIT = 8;
 var MIRROR_SUPPRESSION_WINDOW_MS = 4e3;
 var MIRROR_PROMPT_MATCH_GRACE_MS = 12e4;
-var MIRROR_IDLE_TIMEOUT_MS = 12e5;
+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]));
 function generateDraftId() {
@@ -16818,8 +16842,6 @@ function resolveCommandAlias(rawCommand, args) {
       return "/help";
     case "/t":
       return !args ? "/threads" : /^(all|n\b)/i.test(args.trim()) ? "/threads" : "/thread";
-    case "/s":
-      return args ? "/use" : "/sessions";
     case "/n":
       return "/new";
     case "/m":
@@ -16890,6 +16912,12 @@ function getSessionDisplayName(session, fallbackDirectory) {
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function buildInteractiveStreamKey(sessionId, messageId) {
+  return `im:${sessionId}:${messageId}`;
+}
+function buildMirrorStreamKey(sessionId, turnId, startedAt) {
+  return `mirror:${sessionId}:${turnId || startedAt}`;
+}
 function getWorkspaceRoot() {
   const { store } = getBridgeContext();
   return store.getSetting("bridge_default_workspace_root") || DEFAULT_WORKSPACE_ROOT;
@@ -17468,6 +17496,53 @@ function getQueuedCount(sessionId) {
   const state = getState();
   return state.queuedCounts.get(sessionId) || 0;
 }
+function buildInteractiveIdleReminderNotice() {
+  return [
+    "\u63D0\u9192\uFF1A\u8FD9\u8F6E\u4EFB\u52A1\u4ECD\u5728\u8FD0\u884C\uFF0C\u4F46\u5DF2\u7ECF\u8D85\u8FC7 10 \u5206\u949F\u6CA1\u6709\u65B0\u7684\u6267\u884C\u8F93\u51FA\u3002",
+    "\u7CFB\u7EDF\u4E0D\u4F1A\u81EA\u52A8\u7EC8\u6B62\u5B83\uFF1B\u5982\u679C\u4F60\u4ECD\u5728\u5BF9\u5E94\u7EBF\u7A0B\uFF0C\u53EF\u53D1\u9001 `/stop` \u4E3B\u52A8\u505C\u6B62\uFF1B\u5982\u679C\u5DF2\u7ECF\u5207\u5230\u522B\u7684\u7EBF\u7A0B\uFF0C\u9700\u8981\u5148\u5207\u56DE\u5BF9\u5E94\u7EBF\u7A0B\u3002"
+  ].join("\n");
+}
+function isCurrentInteractiveTask(sessionId, taskId) {
+  return getState().activeTasks.get(sessionId)?.id === taskId;
+}
+function touchInteractiveTask(sessionId, taskId) {
+  const task = getState().activeTasks.get(sessionId);
+  if (task?.id !== taskId) return;
+  task.lastActivityAt = Date.now();
+  task.idleReminderSent = false;
+}
+function releaseInteractiveTask(sessionId, taskId) {
+  const state = getState();
+  const current = state.activeTasks.get(sessionId);
+  if (current?.id !== taskId) return;
+  state.activeTasks.delete(sessionId);
+  syncSessionRuntimeState(sessionId);
+}
+async function remindIdleInteractiveTask(task) {
+  if (!isCurrentInteractiveTask(task.sessionId, task.id) || task.idleReminderSent) return;
+  task.idleReminderSent = true;
+  try {
+    await deliver(task.adapter, {
+      address: task.address,
+      text: renderFeedbackTextForChannel(
+        task.adapter.channelType,
+        buildInteractiveIdleReminderNotice()
+      ),
+      parseMode: getFeedbackParseMode(task.adapter.channelType),
+      replyToMessageId: task.requestMessageId
+    });
+  } catch {
+  }
+}
+async function reconcileIdleInteractiveTasks() {
+  const now2 = Date.now();
+  const tasks = Array.from(getState().activeTasks.values());
+  for (const task of tasks) {
+    if (task.idleReminderSent) continue;
+    if (now2 - task.lastActivityAt < INTERACTIVE_IDLE_REMINDER_MS) continue;
+    await remindIdleInteractiveTask(task);
+  }
+}
 function syncSessionRuntimeState(sessionId) {
   const { store } = getBridgeContext();
   const session = store.getSession(sessionId);
@@ -17829,6 +17904,16 @@ function formatMirrorMessage(threadTitle, userText, assistantText, markdown = fa
   sections.unshift(buildMirrorTitle(threadTitle, markdown));
   return sections.join("\n\n").trim();
 }
+function buildMirrorTimeoutNotice(markdown = false) {
+  return markdown ? "> \u8D85\u65F6\u63D0\u9192\uFF1A\u957F\u65F6\u95F4\u6CA1\u6709\u6536\u5230\u65B0\u7684\u684C\u9762\u4F1A\u8BDD\u8F93\u51FA\uFF0C\u672C\u6B21\u6D41\u5F0F\u540C\u6B65\u5DF2\u5148\u7ED3\u675F\uFF1B\u5982\u679C\u684C\u9762\u540E\u7EED\u7EE7\u7EED\u4EA7\u51FA\u5185\u5BB9\uFF0C\u4F1A\u91CD\u65B0\u5F00\u59CB\u65B0\u4E00\u8F6E\u540C\u6B65\u3002" : "\u8D85\u65F6\u63D0\u9192\uFF1A\u957F\u65F6\u95F4\u6CA1\u6709\u6536\u5230\u65B0\u7684\u684C\u9762\u4F1A\u8BDD\u8F93\u51FA\uFF0C\u672C\u6B21\u6D41\u5F0F\u540C\u6B65\u5DF2\u5148\u7ED3\u675F\uFF1B\u5982\u679C\u684C\u9762\u540E\u7EED\u7EE7\u7EED\u4EA7\u51FA\u5185\u5BB9\uFF0C\u4F1A\u91CD\u65B0\u5F00\u59CB\u65B0\u4E00\u8F6E\u540C\u6B65\u3002";
+}
+function appendMirrorTimeoutNotice(text2, markdown = false) {
+  const notice = buildMirrorTimeoutNotice(markdown);
+  const normalized = text2.trim();
+  return normalized ? `${normalized}
+
+${notice}` : notice;
+}
 function getMirrorStreamingAdapter(subscription) {
   const state = getState();
   const adapter = state.adapters.get(subscription.channelType);
@@ -17855,9 +17940,9 @@ function startMirrorStreaming(subscription, turnState) {
   const adapter = getMirrorStreamingAdapter(subscription);
   if (!adapter || turnState.streamStarted) return;
   try {
-    adapter.onMirrorStreamStart?.(subscription.chatId);
+    adapter.onMirrorStreamStart?.(subscription.chatId, turnState.streamKey);
     if (!adapter.onMirrorStreamStart) {
-      adapter.onStreamText?.(subscription.chatId, "");
+      adapter.onStreamText?.(subscription.chatId, "", turnState.streamKey);
     }
     turnState.streamStarted = true;
   } catch {
@@ -17873,7 +17958,7 @@ function updateMirrorStreaming(subscription, turnState) {
   );
   if (!text2) return;
   try {
-    adapter.onStreamText?.(subscription.chatId, text2);
+    adapter.onStreamText?.(subscription.chatId, text2, turnState.streamKey);
   } catch {
   }
 }
@@ -17882,7 +17967,7 @@ function updateMirrorToolProgress(subscription, turnState) {
   if (!adapter || typeof adapter.onToolEvent !== "function") return;
   startMirrorStreaming(subscription, turnState);
   try {
-    adapter.onToolEvent(subscription.chatId, Array.from(turnState.toolCalls.values()));
+    adapter.onToolEvent(subscription.chatId, Array.from(turnState.toolCalls.values()), turnState.streamKey);
   } catch {
   }
 }
@@ -17894,7 +17979,7 @@ function stopMirrorStreaming(subscription, status = "interrupted") {
     subscription.channelType,
     getMirrorStreamingText(subscription, pendingTurn)
   );
-  void adapter.onStreamEnd(subscription.chatId, status, text2).catch(() => {
+  void adapter.onStreamEnd(subscription.chatId, status, text2, pendingTurn.streamKey).catch(() => {
   });
 }
 async function deliverMirrorTurn(subscription, turn) {
@@ -17904,8 +17989,10 @@ async function deliverMirrorTurn(subscription, turn) {
   const title = getDesktopThreadTitle(subscription.threadId)?.trim() || "\u684C\u9762\u7EBF\u7A0B";
   const responseParseMode = getFeedbackParseMode(subscription.channelType);
   const markdown = responseParseMode === "Markdown";
-  const renderedText = formatMirrorMessage(title, turn.userText, turn.text, markdown);
-  const renderedStreamText = formatMirrorMessage(title, turn.userText, turn.text, markdown, true);
+  const renderedTextBase = formatMirrorMessage(title, turn.userText, turn.text, markdown);
+  const renderedStreamTextBase = formatMirrorMessage(title, turn.userText, turn.text, markdown, true);
+  const renderedText = turn.timedOut ? appendMirrorTimeoutNotice(renderedTextBase || buildMirrorTitle(title, markdown), markdown) : renderedTextBase;
+  const renderedStreamText = turn.timedOut ? appendMirrorTimeoutNotice(renderedStreamTextBase || buildMirrorTitle(title, markdown), markdown) : renderedStreamTextBase;
   const text2 = renderedText ? renderFeedbackText(renderedText, responseParseMode) : "";
   const streamText = renderFeedbackText(
     renderedStreamText || buildMirrorTitle(title, markdown),
@@ -17916,7 +18003,8 @@ async function deliverMirrorTurn(subscription, turn) {
       const finalized = await adapter.onStreamEnd(
         subscription.chatId,
         turn.status,
-        streamText
+        streamText,
+        turn.streamKey
       );
       if (finalized) {
         subscription.lastDeliveredAt = turn.timestamp || nowIso();
@@ -17948,10 +18036,11 @@ async function deliverMirrorTurns(subscription, turns) {
     await deliverMirrorTurn(subscription, turn);
   }
 }
-function createMirrorTurnState(timestamp, turnId) {
+function createMirrorTurnState(sessionId, timestamp, turnId) {
   const safeTimestamp = timestamp || nowIso();
   return {
     turnId: turnId || null,
+    streamKey: buildMirrorStreamKey(sessionId, turnId || null, safeTimestamp),
     startedAt: safeTimestamp,
     lastActivityAt: safeTimestamp,
     userText: null,
@@ -17985,7 +18074,7 @@ ${normalized}` : normalized;
 }
 function ensureMirrorTurnState(subscription, record) {
   if (!subscription.pendingTurn) {
-    subscription.pendingTurn = createMirrorTurnState(record.timestamp, record.turnId);
+    subscription.pendingTurn = createMirrorTurnState(subscription.sessionId, record.timestamp, record.turnId);
     return subscription.pendingTurn;
   }
   if (!subscription.pendingTurn.turnId && record.turnId) {
@@ -18008,11 +18097,13 @@ function finalizeMirrorTurn(subscription, signature, timestamp, status, preferre
   const userText = pendingTurn.userText?.trim() || null;
   if (!text2 && !userText && pendingTurn.toolCalls.size === 0) return null;
   return {
+    streamKey: pendingTurn.streamKey,
     userText,
     text: text2,
     signature,
     timestamp: timestamp || pendingTurn.lastActivityAt || nowIso(),
-    status
+    status,
+    ...signature.startsWith("timeout:") ? { timedOut: true } : {}
   };
 }
 function consumeMirrorRecords(subscription, records) {
@@ -18026,7 +18117,7 @@ function consumeMirrorRecords(subscription, records) {
         if (superseded) finalized.push(superseded);
       }
       if (!subscription.pendingTurn) {
-        subscription.pendingTurn = createMirrorTurnState(record.timestamp, record.turnId);
+        subscription.pendingTurn = createMirrorTurnState(subscription.sessionId, record.timestamp, record.turnId);
       } else {
         if (!subscription.pendingTurn.turnId && record.turnId) {
           subscription.pendingTurn.turnId = record.turnId;
@@ -18305,11 +18396,21 @@ async function reconcileMirrorSubscription(subscription) {
       subscription.bufferedRecords.push(...filteredRecords);
     }
   }
+  const timedOutTurn = flushTimedOutMirrorTurn(subscription);
   if (getState().activeTasks.has(subscription.sessionId) || isMirrorSuppressed(subscription.sessionId)) {
+    if (timedOutTurn) {
+      try {
+        await deliverMirrorTurns(subscription, [timedOutTurn]);
+      } catch (error) {
+        subscription.dirty = true;
+        console.warn("[bridge-manager] Mirror delivery failed:", error instanceof Error ? error.message : error);
+      }
+    }
     syncMirrorSessionState(subscription.sessionId);
     return;
   }
-  const finalizedTurns = consumeBufferedMirrorTurns(subscription);
+  const finalizedTurns = timedOutTurn ? [timedOutTurn] : [];
+  finalizedTurns.push(...consumeBufferedMirrorTurns(subscription));
   if (finalizedTurns.length === 0) {
     syncMirrorSessionState(subscription.sessionId);
     return;
@@ -18473,6 +18574,9 @@ async function start() {
     void syncConfiguredAdapters({ startLoops: true }).catch((err) => {
       console.error("[bridge-manager] Adapter reconcile failed:", err);
     });
+    void reconcileIdleInteractiveTasks().catch((err) => {
+      console.error("[bridge-manager] Interactive idle reminder reconcile failed:", err);
+    });
   }, 5e3);
   state.mirrorPollTimer = setInterval(() => {
     void reconcileMirrorSubscriptions().catch((err) => {
@@ -18506,8 +18610,8 @@ async function stop() {
   }
   state.loopAborts.clear();
   const activeSessionIds = Array.from(state.activeTasks.keys());
-  for (const abort of state.activeTasks.values()) {
-    abort.abort();
+  for (const task of state.activeTasks.values()) {
+    task.abortController.abort();
   }
   state.activeTasks.clear();
   state.mirrorSuppressUntil.clear();
@@ -18712,12 +18816,28 @@ async function handleMessage(adapter, msg) {
     return;
   }
   const binding = resolve(msg.address);
-  adapter.onMessageStart?.(msg.address.chatId);
+  const streamKey = buildInteractiveStreamKey(binding.codepilotSessionId, msg.messageId);
+  adapter.onMessageStart?.(msg.address.chatId, streamKey);
   const taskAbort = new AbortController();
+  const taskId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const state = getState();
   resetMirrorSessionForInteractiveRun(binding.codepilotSessionId);
-  state.activeTasks.set(binding.codepilotSessionId, taskAbort);
-  let mirrorSuppressionId = null;
+  const taskState = {
+    id: taskId,
+    abortController: taskAbort,
+    adapter,
+    address: msg.address,
+    requestMessageId: msg.messageId,
+    streamKey,
+    sessionId: binding.codepilotSessionId,
+    hasStreamingCards: false,
+    lastActivityAt: Date.now(),
+    idleReminderSent: false,
+    streamFinalized: false,
+    uiEnded: false,
+    mirrorSuppressionId: null
+  };
+  state.activeTasks.set(binding.codepilotSessionId, taskState);
   syncSessionRuntimeState(binding.codepilotSessionId);
   let previewState = null;
   const caps = adapter.getPreviewCapabilities?.(msg.address.chatId) ?? null;
@@ -18766,18 +18886,22 @@ async function handleMessage(adapter, msg) {
     flushPreview(adapter, ps, cfg);
   } : void 0;
   const hasStreamingCards = typeof adapter.onStreamText === "function";
+  taskState.hasStreamingCards = hasStreamingCards;
   const toolCallTracker = /* @__PURE__ */ new Map();
   const onStreamCardText = hasStreamingCards ? (fullText) => {
+    if (!isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
     const rendered = renderFeedbackTextForChannel(
       adapter.channelType,
       stripOutboundArtifactBlocksForStreaming(fullText)
     );
     try {
-      adapter.onStreamText(msg.address.chatId, rendered);
+      adapter.onStreamText(msg.address.chatId, rendered, streamKey);
     } catch {
     }
   } : void 0;
   const onToolEvent = hasStreamingCards ? (toolId, toolName, status) => {
+    if (!isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
+    touchInteractiveTask(binding.codepilotSessionId, taskId);
     if (toolName) {
       toolCallTracker.set(toolId, { id: toolId, name: toolName, status });
     } else {
@@ -18785,11 +18909,13 @@ async function handleMessage(adapter, msg) {
       if (existing) existing.status = status;
     }
     try {
-      adapter.onToolEvent(msg.address.chatId, Array.from(toolCallTracker.values()));
+      adapter.onToolEvent(msg.address.chatId, Array.from(toolCallTracker.values()), streamKey);
     } catch {
     }
   } : void 0;
   const onPartialText = previewOnPartialText || onStreamCardText ? (fullText) => {
+    if (!isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
+    touchInteractiveTask(binding.codepilotSessionId, taskId);
     if (previewOnPartialText) previewOnPartialText(fullText);
     if (onStreamCardText) onStreamCardText(fullText);
   } : void 0;
@@ -18807,10 +18933,13 @@ async function handleMessage(adapter, msg) {
         msg.messageId
       );
     }, taskAbort.signal, hasAttachments ? msg.attachments : void 0, onPartialText, onToolEvent, (preparedPrompt) => {
-      if (!mirrorSuppressionId) {
-        mirrorSuppressionId = beginMirrorSuppression(binding.codepilotSessionId, preparedPrompt);
+      if (!taskState.mirrorSuppressionId) {
+        taskState.mirrorSuppressionId = beginMirrorSuppression(binding.codepilotSessionId, preparedPrompt);
       }
     });
+    if (!isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) {
+      return;
+    }
     let cardFinalized = false;
     if (hasStreamingCards && adapter.onStreamEnd) {
       try {
@@ -18818,8 +18947,10 @@ async function handleMessage(adapter, msg) {
         cardFinalized = await adapter.onStreamEnd(
           msg.address.chatId,
           status,
-          renderFeedbackTextForChannel(adapter.channelType, result.responseText)
+          renderFeedbackTextForChannel(adapter.channelType, result.responseText),
+          streamKey
         );
+        taskState.streamFinalized = cardFinalized;
       } catch (err) {
         console.warn("[bridge-manager] Card finalize failed:", err instanceof Error ? err.message : err);
       }
@@ -18844,14 +18975,9 @@ async function handleMessage(adapter, msg) {
         []
       );
     }
-    if (binding.id) {
-      try {
-        const update = computeSdkSessionUpdate(result.sdkSessionId, result.hasError);
-        if (update !== null) {
-          store.updateChannelBinding(binding.id, { sdkSessionId: update });
-        }
-      } catch {
-      }
+    try {
+      persistSdkSessionUpdate(binding.codepilotSessionId, result.sdkSessionId, result.hasError);
+    } catch {
     }
   } finally {
     if (previewState) {
@@ -18861,18 +18987,22 @@ async function handleMessage(adapter, msg) {
       }
       adapter.endPreview?.(msg.address.chatId, previewState.draftId);
     }
-    if (hasStreamingCards && adapter.onStreamEnd && taskAbort.signal.aborted) {
+    if (hasStreamingCards && adapter.onStreamEnd && taskAbort.signal.aborted && !taskState.streamFinalized) {
       try {
-        await adapter.onStreamEnd(msg.address.chatId, "interrupted", "");
+        await adapter.onStreamEnd(msg.address.chatId, "interrupted", "", streamKey);
+        taskState.streamFinalized = true;
       } catch {
       }
     }
-    if (mirrorSuppressionId) {
-      settleMirrorSuppression(binding.codepilotSessionId, mirrorSuppressionId);
+    if (taskState.mirrorSuppressionId) {
+      settleMirrorSuppression(binding.codepilotSessionId, taskState.mirrorSuppressionId);
+      taskState.mirrorSuppressionId = null;
+    }
+    releaseInteractiveTask(binding.codepilotSessionId, taskId);
+    if (!taskState.uiEnded) {
+      adapter.onMessageEnd?.(msg.address.chatId, streamKey);
+      taskState.uiEnded = true;
     }
-    state.activeTasks.delete(binding.codepilotSessionId);
-    syncSessionRuntimeState(binding.codepilotSessionId);
-    adapter.onMessageEnd?.(msg.address.chatId);
     ack();
   }
 }
@@ -18925,15 +19055,6 @@ async function handleCommand(adapter, msg, text2) {
         response = resolved.message;
         break;
       }
-      if (currentBinding) {
-        const st = getState();
-        const oldTask = st.activeTasks.get(currentBinding.codepilotSessionId);
-        if (oldTask) {
-          oldTask.abort();
-          st.activeTasks.delete(currentBinding.codepilotSessionId);
-          syncSessionRuntimeState(currentBinding.codepilotSessionId);
-        }
-      }
       const workDir = resolved.workDir;
       ensureWorkingDirectoryExists(workDir);
       const binding = createBinding(msg.address, workDir);
@@ -18947,6 +19068,7 @@ async function handleCommand(adapter, msg, text2) {
         ],
         [
           args.trim() ? "\u63A5\u4E0B\u6765\u76F4\u63A5\u53D1\u9001\u6587\u672C\u5373\u53EF\u7EE7\u7EED\u3002" : "\u5DF2\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u4E0B\u65B0\u5EFA\u4E00\u4E2A\u7EBF\u7A0B\u3002\u63A5\u4E0B\u6765\u76F4\u63A5\u53D1\u9001\u6587\u672C\u5373\u53EF\u7EE7\u7EED\u3002",
+          "\u5982\u679C\u5F53\u524D\u804A\u5929\u91CC\u5DF2\u6709\u65E7\u4EFB\u52A1\u5728\u8FD0\u884C\uFF0C\u5B83\u4E0D\u4F1A\u88AB\u7EC8\u6B62\uFF0C\u4ECD\u4F1A\u5728\u540E\u53F0\u7EE7\u7EED\u6267\u884C\u5E76\u53EF\u80FD\u7A0D\u540E\u56DE\u6D88\u606F\u3002",
           "\u8FD9\u662F IM \u4FA7\u7EBF\u7A0B\uFF0C\u5F53\u524D\u53EA\u4FDD\u8BC1\u5728 IM \u4E2D\u53EF\u7EE7\u7EED\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u51FA\u73B0\u5728 Codex Desktop \u4F1A\u8BDD\u5217\u8868\u4E2D\u3002"
         ],
         responseParseMode === "Markdown"
@@ -19358,6 +19480,7 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
             return {
               heading: `${getSessionDisplayName(session, session.working_directory)}${session.id === currentBinding?.codepilotSessionId ? " [\u5F53\u524D]" : ""}`,
               details: [
+                `\u72B6\u6001\uFF1A${formatRuntimeStatus(session)}`,
                 `\u76EE\u5F55\uFF1A${formatCommandPath(session.working_directory)}`
               ]
             };
@@ -19376,9 +19499,7 @@ ${truncateHistoryContent(formatStoredMessageContent(message.content))}`;
       const st = getState();
       const taskAbort = st.activeTasks.get(binding.codepilotSessionId);
       if (taskAbort) {
-        taskAbort.abort();
-        st.activeTasks.delete(binding.codepilotSessionId);
-        syncSessionRuntimeState(binding.codepilotSessionId);
+        taskAbort.abortController.abort();
         response = "\u6B63\u5728\u505C\u6B62\u5F53\u524D\u4EFB\u52A1...";
       } else {
         response = "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\u3002";
@@ -19483,6 +19604,13 @@ function computeSdkSessionUpdate(sdkSessionId, hasError) {
   }
   return null;
 }
+function persistSdkSessionUpdate(sessionId, sdkSessionId, hasError) {
+  const update = computeSdkSessionUpdate(sdkSessionId, hasError);
+  if (update === null) {
+    return;
+  }
+  getBridgeContext().store.updateSdkSessionId(sessionId, update);
+}
 
 // src/store.ts
 import fs9 from "node:fs";

package/dist/ui-server.mjs

@@ -5045,7 +5045,9 @@ var CodexProvider = class {
               }
               let sawAnyEvent = false;
               try {
-                const { events } = await thread.runStreamed(input);
+                const { events } = await thread.runStreamed(input, {
+                  signal: params.abortController?.signal
+                });
                 for await (const event of events) {
                   sawAnyEvent = true;
                   if (params.abortController?.signal.aborted) {

package/package.json

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