codex-to-im 1.0.35 → 1.0.36

package/dist/daemon.mjs

@@ -5496,25 +5496,16 @@ function formatElapsed(ms) {
   const remSec = Math.floor(sec % 60);
   return `${min}m ${remSec}s`;
 }
-function buildStreamingContent(text2, tools) {
-  let content = text2 || "";
-  const toolMd = buildToolProgressMarkdown(tools);
-  if (toolMd) {
-    content = content ? `${content}
-
-${toolMd}` : toolMd;
-  }
-  return content || "\u{1F4AD} Thinking...";
+function buildStreamingTextContent(text2) {
+  return text2 || "\u{1F4AD} Thinking...";
+}
+function buildStreamingToolsContent(tools) {
+  return buildToolProgressMarkdown(tools);
 }
 function buildFinalCardJson(text2, tools, footer) {
   const elements = [];
-  let content = preprocessFeishuMarkdown(text2);
+  const content = preprocessFeishuMarkdown(text2);
   const toolMd = buildToolProgressMarkdown(tools);
-  if (toolMd) {
-    content = content ? `${content}
-
-${toolMd}` : toolMd;
-  }
   if (content) {
     elements.push({
       tag: "markdown",
@@ -5523,12 +5514,25 @@ ${toolMd}` : toolMd;
       text_size: "normal"
     });
   }
+  if (toolMd) {
+    if (elements.length > 0) {
+      elements.push({ tag: "hr" });
+    }
+    elements.push({
+      tag: "markdown",
+      content: toolMd,
+      text_align: "left",
+      text_size: "normal"
+    });
+  }
   if (footer) {
     const parts = [];
     if (footer.status) parts.push(footer.status);
     if (footer.elapsed) parts.push(footer.elapsed);
     if (parts.length > 0) {
-      elements.push({ tag: "hr" });
+      if (elements.length > 0) {
+        elements.push({ tag: "hr" });
+      }
       elements.push({
         tag: "markdown",
         content: parts.join(" \xB7 "),
@@ -5595,6 +5599,8 @@ var DEDUP_MAX = 1e3;
 var MAX_FILE_SIZE = 20 * 1024 * 1024;
 var TYPING_EMOJI = "Typing";
 var CARD_THROTTLE_MS = 200;
+var INITIAL_STREAMING_STATUS = "\u5DF2\u8FD0\u884C 0s";
+var EMPTY_STREAMING_TOOLS = "";
 var MIME_BY_TYPE = {
   image: "image/png",
   file: "application/octet-stream",
@@ -5642,6 +5648,9 @@ var FeishuAdapter = class extends BaseChannelAdapter {
   isStreamingEnabled() {
     return this.channelConfig.streamingEnabled !== false;
   }
+  supportsStructuredStreamingUi(_chatId) {
+    return this.isStreamingEnabled();
+  }
   resolveStreamKey(chatId, streamKey) {
     return streamKey?.trim() || chatId;
   }
@@ -5840,13 +5849,29 @@ var FeishuAdapter = class extends BaseChannelAdapter {
           summary: { content: "\u601D\u8003\u4E2D..." }
         },
         body: {
-          elements: [{
-            tag: "markdown",
-            content: "\u{1F4AD} Thinking...",
-            text_align: "left",
-            text_size: "normal",
-            element_id: "streaming_content"
-          }]
+          elements: [
+            {
+              tag: "markdown",
+              content: "\u{1F4AD} Thinking...",
+              text_align: "left",
+              text_size: "normal",
+              element_id: "streaming_content"
+            },
+            {
+              tag: "markdown",
+              content: EMPTY_STREAMING_TOOLS,
+              text_align: "left",
+              text_size: "normal",
+              element_id: "streaming_tools"
+            },
+            {
+              tag: "markdown",
+              content: INITIAL_STREAMING_STATUS,
+              text_align: "left",
+              text_size: "notation",
+              element_id: "streaming_status"
+            }
+          ]
         }
       };
       const createResp = await cardkit.card.create({
@@ -5888,8 +5913,14 @@ var FeishuAdapter = class extends BaseChannelAdapter {
         toolCalls: [],
         thinking: true,
         pendingText: null,
+        pendingStatusText: INITIAL_STREAMING_STATUS,
+        renderedText: "\u{1F4AD} Thinking...",
+        renderedToolsText: EMPTY_STREAMING_TOOLS,
+        renderedStatusText: INITIAL_STREAMING_STATUS,
         lastUpdateAt: 0,
-        throttleTimer: null
+        throttleTimer: null,
+        flushInFlight: null,
+        flushQueued: false
       });
       console.log(`[feishu-adapter] Streaming card created: streamKey=${cardKey}, cardId=${cardId}, msgId=${messageId}`);
       return true;
@@ -5909,12 +5940,43 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       state.thinking = false;
     }
     state.pendingText = text2;
+    this.scheduleCardFlush(cardKey);
+  }
+  updateCardStatus(chatId, statusText, streamKey) {
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    const state = this.activeCards.get(cardKey);
+    if (!state || !this.restClient) return;
+    state.pendingStatusText = statusText || INITIAL_STREAMING_STATUS;
+    this.scheduleCardFlush(cardKey);
+  }
+  enqueueCardFlush(streamKey) {
+    const state = this.activeCards.get(streamKey);
+    if (!state) return;
+    if (state.flushInFlight) {
+      state.flushQueued = true;
+      return;
+    }
+    state.flushInFlight = this.flushCardUpdate(streamKey).catch((err) => {
+      console.warn("[feishu-adapter] cardElement.content failed:", err instanceof Error ? err.message : err);
+    }).finally(() => {
+      const current = this.activeCards.get(streamKey);
+      if (!current) return;
+      current.flushInFlight = null;
+      if (current.flushQueued) {
+        current.flushQueued = false;
+        this.enqueueCardFlush(streamKey);
+      }
+    });
+  }
+  scheduleCardFlush(streamKey) {
+    const state = this.activeCards.get(streamKey);
+    if (!state) return;
     const elapsed = Date.now() - state.lastUpdateAt;
     if (elapsed < CARD_THROTTLE_MS && state.lastUpdateAt > 0) {
       if (!state.throttleTimer) {
         state.throttleTimer = setTimeout(() => {
           state.throttleTimer = null;
-          this.flushCardUpdate(cardKey);
+          this.enqueueCardFlush(streamKey);
         }, CARD_THROTTLE_MS - elapsed);
       }
       return;
@@ -5923,28 +5985,65 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
     }
-    this.flushCardUpdate(cardKey);
+    this.enqueueCardFlush(streamKey);
   }
   /**
    * Flush pending card update to Feishu API.
    */
-  flushCardUpdate(streamKey) {
+  async flushCardUpdate(streamKey) {
     const state = this.activeCards.get(streamKey);
     if (!state || !this.restClient) return;
     const cardkit = this.restClient.cardkit?.v1;
     if (!cardkit?.cardElement?.content) return;
-    const content = buildStreamingContent(state.pendingText || "", state.toolCalls);
-    state.sequence++;
-    const seq = state.sequence;
+    const content = buildStreamingTextContent(state.pendingText || "");
+    const toolsText = buildStreamingToolsContent(state.toolCalls) || EMPTY_STREAMING_TOOLS;
+    const statusText = state.pendingStatusText || INITIAL_STREAMING_STATUS;
+    const updates = [];
+    if (content !== state.renderedText) {
+      updates.push({
+        elementId: "streaming_content",
+        content,
+        onSuccess: () => {
+          state.renderedText = content;
+        }
+      });
+    }
+    if (toolsText !== state.renderedToolsText) {
+      updates.push({
+        elementId: "streaming_tools",
+        content: toolsText,
+        onSuccess: () => {
+          state.renderedToolsText = toolsText;
+        }
+      });
+    }
+    if (statusText !== state.renderedStatusText) {
+      updates.push({
+        elementId: "streaming_status",
+        content: statusText,
+        onSuccess: () => {
+          state.renderedStatusText = statusText;
+        }
+      });
+    }
+    if (updates.length === 0) return;
     const cardId = state.cardId;
-    cardkit.cardElement.content({
-      path: { card_id: cardId, element_id: "streaming_content" },
-      data: { content, sequence: seq }
-    }).then(() => {
-      state.lastUpdateAt = Date.now();
-    }).catch((err) => {
-      console.warn("[feishu-adapter] cardElement.content failed:", err instanceof Error ? err.message : err);
-    });
+    for (const update of updates) {
+      state.sequence++;
+      try {
+        await cardkit.cardElement.content({
+          path: { card_id: cardId, element_id: update.elementId },
+          data: { content: update.content, sequence: state.sequence }
+        });
+        update.onSuccess();
+        state.lastUpdateAt = Date.now();
+      } catch (err) {
+        console.warn(
+          `[feishu-adapter] cardElement.content failed for ${update.elementId}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
   }
   /**
    * Update tool progress in the streaming card.
@@ -5954,7 +6053,27 @@ var FeishuAdapter = class extends BaseChannelAdapter {
     const state = this.activeCards.get(cardKey);
     if (!state) return;
     state.toolCalls = tools;
-    this.updateCardContent(chatId, state.pendingText || "", cardKey);
+    this.scheduleCardFlush(cardKey);
+  }
+  async awaitCardFlushCompletion(streamKey) {
+    while (true) {
+      const state = this.activeCards.get(streamKey);
+      if (!state) return;
+      const inFlight = state.flushInFlight;
+      if (inFlight) {
+        try {
+          await inFlight;
+        } catch {
+        }
+        continue;
+      }
+      if (state.flushQueued) {
+        state.flushQueued = false;
+        this.enqueueCardFlush(streamKey);
+        continue;
+      }
+      return;
+    }
   }
   /**
    * Finalize the streaming card: close streaming mode, update with final content + footer.
@@ -5976,6 +6095,7 @@ var FeishuAdapter = class extends BaseChannelAdapter {
       clearTimeout(state.throttleTimer);
       state.throttleTimer = null;
     }
+    await this.awaitCardFlushCompletion(cardKey);
     try {
       state.sequence++;
       await cardkit.card.settings({
@@ -6041,6 +6161,9 @@ ${trimmedResponse}`;
   hasActiveCard(chatId, streamKey) {
     return this.activeCards.has(this.resolveStreamKey(chatId, streamKey));
   }
+  hasActiveStreamingUi(chatId, streamKey) {
+    return this.hasActiveCard(chatId, streamKey);
+  }
   // ── Streaming adapter interface ────────────────────────────────
   /**
    * Called by bridge-manager on each text SSE event.
@@ -6070,6 +6193,19 @@ ${trimmedResponse}`;
     if (!this.isStreamingEnabled()) return;
     this.updateToolProgress(chatId, tools, streamKey);
   }
+  onStreamStatus(chatId, statusText, streamKey) {
+    if (!this.isStreamingEnabled()) return;
+    const cardKey = this.resolveStreamKey(chatId, streamKey);
+    if (!this.activeCards.has(cardKey)) {
+      const messageId = this.lastIncomingMessageId.get(chatId);
+      this.createStreamingCard(chatId, messageId, cardKey).then((ok) => {
+        if (ok) this.updateCardStatus(chatId, statusText, cardKey);
+      }).catch(() => {
+      });
+      return;
+    }
+    this.updateCardStatus(chatId, statusText, cardKey);
+  }
   async onStreamEnd(chatId, status, responseText, streamKey) {
     if (!this.isStreamingEnabled()) return false;
     return this.finalizeCard(chatId, status, responseText, streamKey);
@@ -18789,6 +18925,16 @@ function pushStreamFeedbackTools(target, tools) {
   } catch {
   }
 }
+function pushStreamFeedbackStatus(target, text2) {
+  if (typeof target.adapter.onStreamStatus !== "function") return;
+  target.ensureStarted?.();
+  const rendered = renderFeedbackTextForChannel(target.channelType, text2);
+  if (!rendered) return;
+  try {
+    target.adapter.onStreamStatus(target.chatId, rendered, target.streamKey);
+  } catch {
+  }
+}
 async function finalizeStreamFeedback(target, status, text2) {
   if (typeof target.adapter.onStreamEnd !== "function") return false;
   const rendered = renderFeedbackTextForChannel(target.channelType, text2);
@@ -18807,6 +18953,7 @@ var STREAM_DEFAULTS = {
   telegram: { intervalMs: 700, minDeltaChars: 20, maxChars: 3900 },
   discord: { intervalMs: 1500, minDeltaChars: 40, maxChars: 1900 }
 };
+var STREAM_STATUS_HEARTBEAT_MS = 1e4;
 function getStreamConfig(channelType = "telegram") {
   const { store } = getBridgeContext();
   const defaults = STREAM_DEFAULTS[channelType] || STREAM_DEFAULTS.telegram;
@@ -18826,12 +18973,40 @@ function flushPreview(adapter, state, config2) {
   }).catch(() => {
   });
 }
+function formatRuntimeDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (totalMinutes < 60) {
+    return seconds > 0 ? `${totalMinutes}m ${seconds}s` : `${totalMinutes}m`;
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (minutes === 0 && seconds === 0) return `${hours}h`;
+  if (seconds === 0) return `${hours}h ${minutes}m`;
+  return `${hours}h ${minutes}m ${seconds}s`;
+}
+function formatInteractiveRuntimeStatus(elapsedMs, silentMs) {
+  const parts = [`\u5DF2\u8FD0\u884C ${formatRuntimeDuration(elapsedMs)}`];
+  if (typeof silentMs === "number" && silentMs >= 0) {
+    parts.push(`\u6700\u8FD1 ${formatRuntimeDuration(silentMs)} \u65E0\u65B0\u8F93\u51FA`);
+  }
+  return parts.join("\uFF0C");
+}
 async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
   const binding = resolve(msg.address);
   const streamKey = buildInteractiveStreamKey(binding.codepilotSessionId, msg.messageId);
+  const nowMs = deps.nowMs ?? (() => Date.now());
+  const setIntervalFn = deps.setIntervalFn ?? ((callback, intervalMs) => setInterval(callback, intervalMs));
+  const clearIntervalFn = deps.clearIntervalFn ?? ((handle) => clearInterval(handle));
+  const processMessageImpl = deps.processMessageImpl ?? processMessage;
+  const forwardPermissionRequestImpl = deps.forwardPermissionRequestImpl ?? forwardPermissionRequest;
+  const streamStatusHeartbeatMs = Math.max(1e3, deps.streamStatusHeartbeatMs ?? STREAM_STATUS_HEARTBEAT_MS);
   adapter.onMessageStart?.(msg.address.chatId, streamKey);
   const taskAbort = new AbortController();
   const taskId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const taskStartedAt = nowMs();
   deps.resetMirrorSessionForInteractiveRun(binding.codepilotSessionId);
   const taskState = {
     id: taskId,
@@ -18842,7 +19017,8 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     streamKey,
     sessionId: binding.codepilotSessionId,
     hasStreamingCards: false,
-    lastActivityAt: Date.now(),
+    structuredStreamUiActive: false,
+    lastActivityAt: taskStartedAt,
     idleReminderSent: false,
     streamFinalized: false,
     uiEnded: false,
@@ -18905,6 +19081,33 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     chatId: msg.address.chatId,
     streamKey
   };
+  const supportsPersistentStreamStatus = hasStreamingCards && adapter.provider === "feishu" && typeof adapter.onStreamStatus === "function";
+  const supportsStructuredStreamUi = supportsPersistentStreamStatus && (adapter.supportsStructuredStreamingUi?.(msg.address.chatId) ?? true);
+  const syncStructuredStreamUiState = () => {
+    if (!supportsStructuredStreamUi || taskState.structuredStreamUiActive) return;
+    if (adapter.hasActiveStreamingUi?.(msg.address.chatId, streamKey)) {
+      taskState.structuredStreamUiActive = true;
+    }
+  };
+  const pushRunningStatus = (silentMs) => {
+    if (!supportsStructuredStreamUi || streamStatusUpdatesClosed) return;
+    pushStreamFeedbackStatus(
+      streamFeedbackTarget,
+      formatInteractiveRuntimeStatus(nowMs() - taskStartedAt, silentMs)
+    );
+    syncStructuredStreamUiState();
+  };
+  let streamStatusHeartbeat = null;
+  let streamStatusUpdatesClosed = false;
+  const clearStreamStatusHeartbeat = () => {
+    if (streamStatusHeartbeat == null) return;
+    clearIntervalFn(streamStatusHeartbeat);
+    streamStatusHeartbeat = null;
+  };
+  const stopStructuredStreamStatusUpdates = () => {
+    streamStatusUpdatesClosed = true;
+    clearStreamStatusHeartbeat();
+  };
   const onStreamCardText = hasStreamingCards ? (fullText) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
     pushStreamFeedbackText(
@@ -18925,6 +19128,8 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     if (hasStreamingCards) {
       pushStreamFeedbackTools(streamFeedbackTarget, Array.from(toolCallTracker.values()));
     }
+    pushRunningStatus(null);
+    syncStructuredStreamUiState();
   };
   const onPartialText = (fullText) => {
     if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId)) return;
@@ -18932,17 +19137,36 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     deps.recordInteractiveHealthProgress(binding.codepilotSessionId, "text");
     previewOnPartialText?.(fullText);
     onStreamCardText?.(fullText);
+    pushRunningStatus(null);
+    syncStructuredStreamUiState();
   };
+  if (supportsStructuredStreamUi) {
+    pushRunningStatus(null);
+    streamStatusHeartbeat = setIntervalFn(() => {
+      if (streamStatusUpdatesClosed) {
+        clearStreamStatusHeartbeat();
+        return;
+      }
+      if (!deps.isCurrentInteractiveTask(binding.codepilotSessionId, taskId) || taskAbort.signal.aborted) {
+        clearStreamStatusHeartbeat();
+        return;
+      }
+      const silentMs = nowMs() - taskState.lastActivityAt;
+      if (silentMs < streamStatusHeartbeatMs) return;
+      pushRunningStatus(silentMs);
+      syncStructuredStreamUiState();
+    }, streamStatusHeartbeatMs);
+  }
   let finalOutcome = "failed";
   let finalOutcomeDetail;
   let shouldRecordHealthEnd = true;
   try {
     const promptText = text2 || (attachments && attachments.length > 0 ? "Describe this image." : "");
-    const result = await processMessage(
+    const result = await processMessageImpl(
       binding,
       promptText,
       async (perm) => {
-        await forwardPermissionRequest(
+        await forwardPermissionRequestImpl(
           adapter,
           msg.address,
           perm.permissionRequestId,
@@ -18974,6 +19198,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     }
     let cardFinalized = false;
     if (hasStreamingCards) {
+      stopStructuredStreamStatusUpdates();
       cardFinalized = await finalizeStreamFeedback(
         streamFeedbackTarget,
         result.hasError ? "error" : "completed",
@@ -19008,6 +19233,7 @@ async function runInteractiveMessage(adapter, msg, text2, attachments, deps) {
     finalOutcome = result.hasError ? "failed" : "completed";
     finalOutcomeDetail = result.hasError ? result.errorMessage?.trim() || void 0 : void 0;
   } finally {
+    stopStructuredStreamStatusUpdates();
     if (previewState) {
       if (previewState.throttleTimer) {
         clearTimeout(previewState.throttleTimer);
@@ -19052,6 +19278,9 @@ function buildInteractiveIdleReminderNotice() {
     "\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 shouldSkipIdleReminder(task) {
+  return task.adapter.provider === "feishu" && task.structuredStreamUiActive;
+}
 function createInteractiveRuntime(getState2, options, deps) {
   function getQueuedCount(sessionId) {
     return getState2().queuedCounts.get(sessionId) || 0;
@@ -19110,6 +19339,7 @@ function createInteractiveRuntime(getState2, options, deps) {
     const now2 = Date.now();
     const tasks = Array.from(getState2().activeTasks.values());
     for (const task of tasks) {
+      if (shouldSkipIdleReminder(task)) continue;
       if (task.idleReminderSent) continue;
       if (now2 - task.lastActivityAt < options.idleReminderMs) continue;
       await remindIdleInteractiveTask(task);

package/package.json

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