chatccc 0.2.297 → 0.2.298

package/README.md

@@ -229,7 +229,7 @@ Claude Code、Cursor 和 Codex 需要对应的本地工具；CCC Agent 内置于
 
 CCC Agent 是 ChatCCC 内置的编程 Agent，不需要额外安装 CLI，开箱即用。在首次配置向导或 Web 管理页中启用后，填写 API Key、Base URL 和模型即可使用；它可以设为 `/new` 的默认 Agent，也可以通过 `/new ccc` 显式创建会话。
 
-CCC Agent 支持**协作式让位**：任务运行期间你可以继续在群里发消息，ChatCCC 会在 Agent 的每个模型步骤边界把新消息注入当前任务，不打断正在执行的工具步骤、不新开一轮对话。已完成的中间工作会保留，Agent 收到插话后会调整后续方向。运行中的消息进入独立的注入队列（深度 50），与整轮排队（深度 1）分离。
+CCC Agent 支持**协作式让位**：任务运行期间你可以继续在群里发消息，ChatCCC 会在 Agent 的每个模型步骤边界把新消息注入当前任务，不打断正在执行的工具步骤、不新开一轮对话。已完成的中间工作会保留，Agent 收到插话后会调整后续方向。运行中的消息进入独立的注入队列（深度 50），与整轮排队（深度 1）分离。飞书中每条消息实际注入后，机器人会发送一条最多 200 字的回执，冻结注入前的过程卡片，并用新的“生成中”卡片展示后续过程。
 
 DeepCCC 同时提供独立端口的本地 Web UI。ChatCCC 管理页顶部点击 **DeepCCC Web** 会复用或按需启动该服务；只全局安装 `deepccc` 的用户直接运行 `deepccc` 即可启动并打开网页版，终端模式改用 `deepccc-cli`。默认地址为 `http://127.0.0.1:28080/`，端口可通过 `~/.deepccc/config.json` 的 `web.port` 修改。网页版支持多会话并发、持久化历史、会话级 model/effort、API 设置和会话内高风险操作审批。
 
@@ -290,7 +290,7 @@ codex --version
 
 Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理，也可以在 `config.json` 中覆盖。
 
-ChatCCC 通过 Codex 的 **app-server 模式**（一个常驻进程 + WebSocket JSON-RPC）驱动 Codex，而不是一次性 `codex exec` 子进程。因此 Codex 与 CCC Agent 一样支持**协作式让位**：任务运行期间继续发消息，ChatCCC 会在 Codex 的工具步骤边界把消息注入当前 turn（`turn/steer`），不打断正在执行的命令、不丢已完成的工作；`/stop` 通过 `turn/interrupt` 只打断当前 turn，不影响同进程内的其他会话。权限策略与旧 exec 的 `--dangerously-bypass-approvals-and-sandbox` 等价（零审批、完整沙箱权限），`/plan`、`/ask` 退化为只读沙箱。要求 Codex CLI >= 0.60.0（建议保持最新版）。
+ChatCCC 通过 Codex 的 **app-server 模式**（一个常驻进程 + WebSocket JSON-RPC）驱动 Codex，而不是一次性 `codex exec` 子进程。因此 Codex 与 CCC Agent 一样支持**协作式让位**：任务运行期间继续发消息，ChatCCC 会在 Codex 的工具步骤边界把消息注入当前 turn（`turn/steer`），不打断正在执行的命令、不丢已完成的工作；飞书会在 `turn/steer` 成功后发送注入回执，并从新的过程卡片继续展示。`/stop` 通过 `turn/interrupt` 只打断当前 turn，不影响同进程内的其他会话。权限策略与旧 exec 的 `--dangerously-bypass-approvals-and-sandbox` 等价（零审批、完整沙箱权限），`/plan`、`/ask` 退化为只读沙箱。要求 Codex CLI >= 0.60.0（建议保持最新版）。
 
 #### 可选：Chrome CDP
 

package/dist/src/cards.js

@@ -399,7 +399,7 @@ export function buildQueueFullCard() {
         ],
     });
 }
-// 协作式让位卡片（仅 ccc）：消息进入注入队列，将在 step 边界吸收进本轮。
+// 协作式让位卡片（ccc/codex）：消息进入注入队列，将在 step/item 边界吸收进本轮。
 // 与上面的整轮队列卡片区分，强调“无需等待整轮结束”。
 export function buildInjectionQueuedCard(text) {
     const preview = text.length > 100 ? text.slice(0, 100) + "…" : text;
@@ -419,7 +419,7 @@ export function buildInjectionQueuedCard(text) {
         ],
     });
 }
-// 注入队列满卡片（仅 ccc）
+// 注入队列满卡片（ccc/codex）
 export function buildInjectionQueueFullCard() {
     return JSON.stringify({
         config: { wide_screen_mode: true },

package/dist/src/session.js

@@ -267,6 +267,28 @@ function formatTerminalCardContent(state) {
         ? `${content}\n\n${reason}\n以上内容可能不完整。`
         : reason;
 }
+function formatTerminalCardContentForDisplay(state, display) {
+    if (display.rotationAccLen === undefined)
+        return formatTerminalCardContent(state);
+    const accumulatedDelta = state.accumulatedContent.slice(display.rotationAccLen);
+    const previousFinalReply = display.rotationFinalReply ?? "";
+    const finalReplyDelta = previousFinalReply && state.finalReply.startsWith(previousFinalReply)
+        ? state.finalReply.slice(previousFinalReply.length)
+        : state.finalReply;
+    const content = accumulatedDelta + finalReplyDelta;
+    if (state.status !== "error")
+        return content;
+    const error = state.terminalError ?? {
+        kind: "unknown",
+        title: "原因未记录",
+        message: "当前状态中没有可用的错误详情，请查看运行日志。",
+        occurredAt: Date.now(),
+    };
+    const reason = formatTerminalErrorReason(error);
+    return content.trim()
+        ? `${content}\n\n${reason}\n以上内容可能不完整。`
+        : reason;
+}
 function isCardKitSequenceConflict(err) {
     return err instanceof Error && err.message.includes("300317");
 }
@@ -729,6 +751,85 @@ export function _resetSessionRegistryFileForTest() {
 export function pickFinalReply(state) {
     return state.finalCompleteText || state.finalText;
 }
+const APPLIED_INJECTION_PREVIEW_CHARS = 200;
+export function unwrapInjectedUserMessage(text) {
+    const match = text.match(/^\[User message\]\r?\n([\s\S]*)\r?\n\[\/User message\]$/);
+    return match?.[1] ?? text;
+}
+export function formatAppliedInjectionReceipt(text) {
+    const normalized = text.trim() || "（空消息）";
+    const chars = Array.from(normalized);
+    const preview = chars.length > APPLIED_INJECTION_PREVIEW_CHARS
+        ? `${chars.slice(0, APPLIED_INJECTION_PREVIEW_CHARS).join("")}…`
+        : normalized;
+    return `已收到注入信息：${preview}`;
+}
+async function rotateFeishuCardForAppliedInjection(sessionId, turnCount, tool, injectedText, state, nextHeaderTitle) {
+    if (tool !== "codex" && tool !== "ccc")
+        return;
+    const chatId = pickDisplayChat(sessionId);
+    if (!chatId)
+        return;
+    const platform = platformForChat(chatId);
+    if (platform?.kind !== "feishu")
+        return;
+    let previousDisplay = displayCards.get(chatId);
+    if (previousDisplay
+        && (previousDisplay.sessionId !== sessionId || previousDisplay.turnCount !== turnCount)) {
+        previousDisplay = undefined;
+    }
+    if (previousDisplay) {
+        while (previousDisplay.cardBusy)
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        if (displayCards.get(chatId) !== previousDisplay)
+            previousDisplay = undefined;
+    }
+    if (previousDisplay) {
+        previousDisplay.cardBusy = true;
+        const nextSequence = previousDisplay.sequence + 1;
+        const oldContent = state.accumulatedContent + pickFinalReply(state);
+        const oldCard = buildProgressCard(progressView({
+            text: truncateContent(oldContent) || "等待 Agent 输出...",
+            status: "done",
+            showStop: false,
+            headerTitle: "已收到注入，后续转入新卡片",
+            headerTemplate: "blue",
+        }));
+        await platform.cardUpdate(previousDisplay.cardId, oldCard, nextSequence).then(() => {
+            previousDisplay.sequence = nextSequence;
+        }).catch((err) => {
+            console.error(`[${ts()}] [INJECT] freeze old card failed: ${err.message}`);
+            if (isCardKitSequenceConflict(err))
+                previousDisplay.sequence = nextSequence;
+        });
+    }
+    await platform.sendText(chatId, formatAppliedInjectionReceipt(injectedText)).catch((err) => {
+        console.error(`[${ts()}] [INJECT] receipt send failed: ${err.message}`);
+    });
+    const newCardId = await createVisibleProgressCard(platform, chatId, sessionId, turnCount, "新生成卡片发送失败，结果将继续更新在上一张卡片中。", nextHeaderTitle);
+    if (!newCardId) {
+        if (previousDisplay)
+            previousDisplay.cardBusy = false;
+        return;
+    }
+    if (previousDisplay) {
+        await markCardDone(sessionId, turnCount, previousDisplay.cardId);
+    }
+    displayCards.set(chatId, {
+        cardId: newCardId,
+        sequence: 1,
+        cardBusy: false,
+        cardCreatedAt: Date.now(),
+        lastSentContent: "",
+        lastSentHeaderTitle: nextHeaderTitle,
+        streamErrorNotified: false,
+        sessionId,
+        turnCount,
+        rotationAccLen: state.accumulatedContent.length,
+        rotationFinalReply: pickFinalReply(state),
+        dotCount: 0,
+    });
+}
 export function accumulateBlockContent(block, state, toolCallMap) {
     if (state.transcript !== undefined || (block.type !== "agent_progress" && block.type !== "text_reset")) {
         const transcriptState = { transcript: state.transcript ?? [] };
@@ -1123,7 +1224,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 else {
                     const nextSeq = display.sequence + 1;
                     const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(prevState.status, prevState.terminalError);
-                    const cardContent = truncateContent(formatTerminalCardContent(prevState)) || " ";
+                    const cardContent = truncateContent(formatTerminalCardContentForDisplay(prevState, display)) || " ";
                     const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
                     await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(err => {
                         console.error(`[${ts()}] [DISPLAY] prevState final cardUpdate failed: ${err.message}`);
@@ -1289,7 +1390,7 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
     }
     try {
         // 供 onInjectionRejected 退回的“最后一条已取出但未成功注入”的消息
-        let lastShiftedInjection = null;
+        const injectionState = { lastShifted: null };
         for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
             onProcessStart: (processInfo) => {
                 startPromptProcessMonitor(sessionId, processInfo);
@@ -1312,16 +1413,16 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 const injected = shiftInjection(sessionId);
                 if (!injected)
                     return undefined;
-                lastShiftedInjection = injected;
+                injectionState.lastShifted = injected;
                 // 与首次消息保持一致的结构化包装；imSkillsPrompt 已在首次消息中，
                 // 此处不重复注入，避免多轮注入导致上下文膨胀。
                 return `[User message]\n${injected.text}\n[/User message]`;
             } : undefined,
             // 注入未被当前 turn 吸收（如 turn 恰好已结束）时，退回队列头部，避免丢消息。
             onInjectionRejected: tool === "ccc" || tool === "codex" ? () => {
-                if (lastShiftedInjection) {
-                    unshiftInjection(sessionId, lastShiftedInjection);
-                    lastShiftedInjection = null;
+                if (injectionState.lastShifted) {
+                    unshiftInjection(sessionId, injectionState.lastShifted);
+                    injectionState.lastShifted = null;
                 }
             } : undefined,
         })) {
@@ -1339,7 +1440,15 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
             let activityChanged = false;
             let progressHeartbeat = false;
             let outputReset = false;
-            for (const block of unifiedMsg.blocks) {
+            let injectionBoundaryObserved = false;
+            for (const originalBlock of unifiedMsg.blocks) {
+                let block = originalBlock;
+                if (originalBlock.type === "input_injected") {
+                    const injectedText = injectionState.lastShifted?.text
+                        ?? unwrapInjectedUserMessage(originalBlock.text);
+                    injectionState.lastShifted = null;
+                    block = { ...originalBlock, text: injectedText };
+                }
                 if (block.type === "agent_progress")
                     progressHeartbeat = true;
                 if (block.type === "text_reset") {
@@ -1349,6 +1458,10 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
                 if (updateAgentActivity(activityTracker, block))
                     activityChanged = true;
                 accumulateBlockContent(block, state, toolCallMap);
+                if (block.type === "input_injected") {
+                    injectionBoundaryObserved = true;
+                    await rotateFeishuCardForAppliedInjection(sessionId, nextTurnCount, tool, block.text, state, formatAgentActivityTitle(activityTracker.activity));
+                }
                 if (block.type === "compact_boundary" && block.post_tokens) {
                     for (const cid of getChatsForSession(sessionId)) {
                         const sinfo = sessionInfoMap.get(cid);
@@ -1374,7 +1487,10 @@ export async function runAgentSession(sessionId, userText, platform, _chatId, ms
             }
             // 定时写入文件
             const now2 = Date.now();
-            if (activityChanged || outputReset || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
+            if (activityChanged
+                || outputReset
+                || injectionBoundaryObserved
+                || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
                 lastFileWrite = now2;
                 await writeStreamState({
                     sessionId,
@@ -1814,7 +1930,7 @@ export function startUnifiedDisplayLoop() {
                                 if (!terminalCardAlreadyUpdated) {
                                     const nextSeq = display.sequence + 1;
                                     const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status, state.terminalError);
-                                    const cardContent = truncateContent(formatTerminalCardContent(state)) || " ";
+                                    const cardContent = truncateContent(formatTerminalCardContentForDisplay(state, display)) || " ";
                                     const doneCard = buildProgressCard(progressView({ text: cardContent, status: "done", showStop: false, headerTitle, headerTemplate }));
                                     await p.cardUpdate(display.cardId, doneCard, nextSeq).then(() => {
                                         display.sequence = nextSeq;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.297",
+  "version": "0.2.298",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",