chatccc 0.2.291 → 0.2.293

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [

package/dist/deepccc-agent/src/file-tools.js

@@ -25,6 +25,18 @@ const SEARCH_TIMEOUT_MS = 15_000;
 const MAX_COMMAND_OUTPUT_BYTES = 256 * 1024;
 const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
 const MAX_COMMAND_TIMEOUT_MS = 900_000;
+/**
+ * 让位注入的轮询间隔：run_command 执行期以此频率检查是否有待注入的用户消息。
+ * 取 1s 而非更小值：轮询本身不花 token（只读内存队列，无模型调用），但更密的
+ * 定时器唤醒有可测的 CPU 开销（实测 250ms 档约 0.27ms/s，1s 档低于计时精度）。
+ * 让位延迟从 250ms 放宽到 1s 对用户无感，却把长任务期间的定时器唤醒降低到
+ * 约 1/4，因此取 1s 作为响应速度与空转成本的平衡点。
+ */
+const YIELD_POLL_INTERVAL_MS = 1000;
+/** command_output 单次等待上限，避免代理用等待把 step 又堵死 */
+const MAX_COMMAND_OUTPUT_WAIT_MS = 30_000;
+/** 后台命令句柄上限；超出时优先回收已结束的句柄 */
+const MAX_BACKGROUND_COMMANDS = 32;
 /** task 子代理工具：子任务结果回传主会话前的最大字符数（防止子代理长输出撑爆主上下文） */
 export const MAX_TASK_OUTPUT_CHARS = 32_000;
 const requireFromHere = createRequire(import.meta.url);
@@ -722,7 +734,41 @@ export async function searchCodeForTool(cwd, input, signal, runtimeOptions = {})
             : fallback.truncated,
     };
 }
-export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
+const backgroundCommands = new Map();
+let backgroundCommandSeq = 0;
+function normalizeCommandOutputWaitMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return 0;
+    return Math.min(Math.trunc(value), MAX_COMMAND_OUTPUT_WAIT_MS);
+}
+function snapshotBackgroundCommand(entry) {
+    return {
+        taskId: entry.taskId,
+        command: entry.command,
+        cwd: entry.cwd,
+        running: !entry.done,
+        exitCode: entry.exitCode,
+        signal: entry.signal,
+        stdout: entry.stdout.chunks.join(""),
+        stderr: entry.stderr.chunks.join(""),
+        timedOut: entry.timedOut,
+        truncated: entry.stdout.truncated || entry.stderr.truncated,
+        durationMs: Date.now() - entry.startedAt,
+    };
+}
+/** 句柄超限时优先回收已结束的条目（运行中的条目保留，避免破坏 agent 的跟踪）。 */
+function pruneBackgroundCommands() {
+    if (backgroundCommands.size <= MAX_BACKGROUND_COMMANDS)
+        return;
+    for (const [id, entry] of backgroundCommands) {
+        if (!entry.done)
+            continue;
+        backgroundCommands.delete(id);
+        if (backgroundCommands.size <= MAX_BACKGROUND_COMMANDS)
+            return;
+    }
+}
+export async function runCommandForTool(cwd, input, abortSignal, coAuthor, shouldYield) {
     const command = withGitCoAuthor(input.command?.trim(), coAuthor);
     if (!command)
         throw new Error("command is required");
@@ -740,6 +786,8 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
         let timedOut = false;
         let timeout;
         let fallbackTimer;
+        let yieldPoll;
+        let backgroundEntry;
         const child = spawn(command, {
             cwd: commandCwd,
             shell: true,
@@ -751,6 +799,8 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
             clearTimeout(timeout);
             if (fallbackTimer)
                 clearTimeout(fallbackTimer);
+            if (yieldPoll)
+                clearInterval(yieldPoll);
             abortSignal?.removeEventListener("abort", abort);
         };
         const finish = (exitCode, signal) => {
@@ -770,12 +820,32 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
                 durationMs: Date.now() - startedAt,
             });
         };
+        /**
+         * 统一收敛点：已转入后台则更新句柄并唤醒等待方，否则按前台语义 resolve。
+         * 让位后 timeout 与 abort 的既有定时器/监听继续生效，因此后台任务仍受
+         * timeoutMs 约束，也仍能被 /stop 终止。
+         */
+        const settle = (exitCode, signal) => {
+            if (!backgroundEntry) {
+                finish(exitCode, signal);
+                return;
+            }
+            backgroundEntry.done = true;
+            backgroundEntry.exitCode = exitCode;
+            backgroundEntry.signal = signal;
+            backgroundEntry.timedOut = timedOut;
+            cleanup();
+            const waiters = backgroundEntry.waiters;
+            backgroundEntry.waiters = [];
+            for (const wake of waiters)
+                wake();
+        };
         const requestKill = (reason) => {
             void killProcessTree(child.pid);
             fallbackTimer = setTimeout(() => {
                 child.stdout?.destroy();
                 child.stderr?.destroy();
-                finish(null, reason === "timeout" ? "SIGTERM" : reason);
+                settle(null, reason === "timeout" ? "SIGTERM" : reason);
             }, 5_000);
             fallbackTimer.unref?.();
         };
@@ -787,6 +857,70 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
             requestKill("abort");
         };
         abortSignal?.addEventListener("abort", abort, { once: true });
+        /**
+         * 让位：命令既不杀也不等，转为后台句柄后立即返回。这样当前 step 尽快结束，
+         * 下一个 prepareStep 边界即可调用 drainInput 把用户新消息注入当前 turn。
+         */
+        const detachToBackground = () => {
+            if (settled || backgroundEntry)
+                return;
+            // close/error 重新挂到 settle：settle 会按 backgroundEntry 分流到后台句柄
+            child.removeAllListeners("close");
+            child.removeAllListeners("error");
+            child.once("close", (code, signal) => settle(code, signal));
+            child.once("error", () => settle(null, "error"));
+            const taskId = `cmd-${++backgroundCommandSeq}-${Math.random().toString(36).slice(2, 6)}`;
+            backgroundEntry = {
+                taskId,
+                command,
+                cwd: commandCwd,
+                startedAt,
+                child,
+                stdout,
+                stderr,
+                done: false,
+                exitCode: null,
+                signal: null,
+                timedOut: false,
+                waiters: [],
+            };
+            backgroundCommands.set(taskId, backgroundEntry);
+            pruneBackgroundCommands();
+            if (yieldPoll)
+                clearInterval(yieldPoll);
+            yieldPoll = undefined;
+            // 刻意不调 cleanup：超时定时器与 abort 监听继续为后台任务服务
+            settled = true;
+            resolvePromise({
+                command,
+                cwd: commandCwd,
+                exitCode: null,
+                signal: null,
+                stdout: stdout.chunks.join(""),
+                stderr: stderr.chunks.join(""),
+                timedOut: false,
+                truncated: stdout.truncated || stderr.truncated,
+                durationMs: Date.now() - startedAt,
+                backgrounded: true,
+                taskId,
+            });
+        };
+        if (shouldYield) {
+            yieldPoll = setInterval(() => {
+                if (settled || backgroundEntry)
+                    return;
+                let yieldNow = false;
+                try {
+                    yieldNow = shouldYield() === true;
+                }
+                catch {
+                    yieldNow = false;
+                }
+                if (yieldNow)
+                    detachToBackground();
+            }, YIELD_POLL_INTERVAL_MS);
+            yieldPoll.unref?.();
+        }
         child.stdout?.on("data", (chunk) => {
             appendLimitedOutput(stdout, chunk);
         });
@@ -794,6 +928,10 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
             appendLimitedOutput(stderr, chunk);
         });
         child.once("error", (err) => {
+            if (backgroundEntry) {
+                settle(null, "error");
+                return;
+            }
             if (settled)
                 return;
             settled = true;
@@ -801,10 +939,75 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor) {
             reject(err);
         });
         child.once("close", (code, signal) => {
-            finish(code, signal);
+            settle(code, signal);
         });
     });
 }
+/** 读取后台命令的最新输出；waitMs > 0 时最多等待该时长（等待期间仍可让位）。 */
+export async function commandOutputForTool(taskId, input, shouldYield) {
+    const entry = backgroundCommands.get(taskId);
+    if (!entry)
+        throw new Error(`未知的后台任务：${taskId}`);
+    const waitMs = normalizeCommandOutputWaitMs(input?.waitMs);
+    if (waitMs > 0 && !entry.done) {
+        await waitForBackgroundCommand(entry, waitMs, shouldYield);
+    }
+    return snapshotBackgroundCommand(entry);
+}
+/** 等待后台命令结束（或等待预算耗尽、或让位信号到来）。 */
+function waitForBackgroundCommand(entry, waitMs, shouldYield) {
+    return new Promise((resolve) => {
+        let finished = false;
+        let poll;
+        const wake = () => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            if (poll)
+                clearInterval(poll);
+            const index = entry.waiters.indexOf(wake);
+            if (index >= 0)
+                entry.waiters.splice(index, 1);
+            resolve();
+        };
+        const timer = setTimeout(wake, waitMs);
+        timer.unref?.();
+        entry.waiters.push(wake);
+        if (shouldYield) {
+            poll = setInterval(() => {
+                let yieldNow = false;
+                try {
+                    yieldNow = shouldYield() === true;
+                }
+                catch {
+                    yieldNow = false;
+                }
+                if (yieldNow)
+                    wake();
+            }, YIELD_POLL_INTERVAL_MS);
+            poll.unref?.();
+        }
+    });
+}
+/** 终止一个仍在运行的后台命令。 */
+export async function commandKillForTool(taskId) {
+    const entry = backgroundCommands.get(taskId);
+    if (!entry)
+        throw new Error(`未知的后台任务：${taskId}`);
+    if (entry.done)
+        return { taskId, killed: false };
+    await killProcessTree(entry.child.pid);
+    return { taskId, killed: true };
+}
+/** 终止并清空全部后台命令句柄（进程退出与测试收尾），避免留下孤儿进程。 */
+export function killAllBackgroundCommands() {
+    for (const entry of backgroundCommands.values()) {
+        if (!entry.done)
+            void killProcessTree(entry.child.pid);
+    }
+    backgroundCommands.clear();
+}
 export async function editFileForTool(cwd, input) {
     if (!Array.isArray(input.edits) || input.edits.length === 0) {
         throw new Error("edits must contain at least one replacement");
@@ -1090,7 +1293,7 @@ export function createBuiltinFileTools(cwd, options = {}) {
             execute: (input) => presentFileForTool(cwd, input),
         }),
         run_command: tool({
-            description: "在本地工作区运行非交互式 shell 命令。用于测试、git 和包脚本。返回 stdout/stderr 和 exitCode；非零退出码不是工具错误。",
+            description: "在本地工作区运行非交互式 shell 命令。用于测试、git 和包脚本。返回 stdout/stderr 和 exitCode；非零退出码不是工具错误。命令运行期间若用户发来新消息，会立即转入后台并返回 taskId（backgrounded:true），命令继续运行，用 command_output 取后续输出。",
             inputSchema: jsonSchema({
                 type: "object",
                 additionalProperties: false,
@@ -1108,9 +1311,34 @@ export function createBuiltinFileTools(cwd, options = {}) {
                     reason: isDangerousCommand(input.command) ? "high-risk" : "rule",
                     detail: `运行命令: ${input.command}`,
                 });
-                return runCommandForTool(cwd, input, execOptions.abortSignal, options.gitCoAuthor);
+                return runCommandForTool(cwd, input, execOptions.abortSignal, options.gitCoAuthor, options.shouldYieldToInjection);
             },
         }),
+        command_output: tool({
+            description: "读取被让位到后台的命令的最新输出。立即返回当前状态；waitMs 可最多等待 30 秒。任务结束后可反复读取完整 stdout/stderr。",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    taskId: { type: "string", description: "run_command 返回的 taskId（backgrounded:true 时）。" },
+                    waitMs: { type: "number", description: `可选等待毫秒数；0 或省略立即返回，上限 ${MAX_COMMAND_OUTPUT_WAIT_MS}。` },
+                },
+                required: ["taskId"],
+            }),
+            execute: (input) => commandOutputForTool(input.taskId, input, options.shouldYieldToInjection),
+        }),
+        command_kill: tool({
+            description: "终止一个仍在后台运行的命令（run_command 让位后转入后台的）。",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    taskId: { type: "string", description: "run_command 返回的 taskId。" },
+                },
+                required: ["taskId"],
+            }),
+            execute: (input) => commandKillForTool(input.taskId),
+        }),
         task: tool({
             description: "把独立子任务委派给子代理执行：子代理使用子模型、拥有独立上下文，不污染主对话上下文。适合边界清晰、可独立交付的调研/代码生成子任务（如扫描整个仓库、阅读长文档、生成独立模块）。子代理不能再次委派任务（禁止嵌套），结果会截断回传。",
             inputSchema: jsonSchema({

package/dist/deepccc-agent/src/index.js

@@ -270,6 +270,8 @@ export class ChatSession {
     context;
     compactionTimeoutMs;
     maxSteps;
+    /** 透传给 run_command 的让位注入判定（见 ChatSessionOptions.shouldYieldToInjection）。 */
+    shouldYieldToInjection;
     effort;
     maxOutputTokens;
     streaming;
@@ -359,6 +361,7 @@ export class ChatSession {
         this.subModel = this.subModelId ? provider(this.subModelId) : this.model;
         this.cwd = options.cwd ?? process.cwd();
         this.maxSteps = normalizeMaxSteps(options.maxSteps);
+        this.shouldYieldToInjection = options.shouldYieldToInjection;
         this.compactionTimeoutMs = Math.max(1, options.compactionTimeoutMs ?? DEFAULT_COMPACTION_TIMEOUT_MS);
         this.customSystemPrompt = options.systemPrompt ?? "";
         this.permissionMode = options.permissionMode ?? "ask";
@@ -493,6 +496,7 @@ export class ChatSession {
                 tools: createBuiltinFileTools(this.cwd, {
                     permissionGate: this.permissionGate,
                     runTask: this.runTask,
+                    shouldYieldToInjection: this.shouldYieldToInjection,
                     gitCoAuthor: {
                         ...appConfig.git.coAuthor,
                         enabled: this.gitCoAuthorEnabled,

package/dist/src/adapters/ccc-adapter.js

@@ -19,6 +19,9 @@ function toChatSessionOptions(sessionId, cwd, options) {
         // 高危命令不询问，全部放行（与独立 deepccc CLI 的 ask 模式不同）
         permissionMode: "bypass",
         ...(options.gitCoAuthor !== undefined ? { gitCoAuthor: options.gitCoAuthor } : {}),
+        ...(options.hasPendingInjection
+            ? { shouldYieldToInjection: () => options.hasPendingInjection(sessionId) === true }
+            : {}),
     };
 }
 export function createCccAdapter(options = {}) {

package/dist/src/session.js

@@ -29,7 +29,7 @@ function compressWechatDisplayText(text) {
 }
 import { readStreamState, writeStreamState, createEmptyStreamState, isFinalReplySentForTurn, markFinalReplySent, } from "./stream-state.js";
 import { addCardToTurn, finalizeTurnCards, markCardDone } from "./turn-cards.js";
-import { bindChatToSession, unbindChatFromSession, getChatsForSession, activePrompts, displayCards, unifiedDisplayLoopHandle, setUnifiedDisplayLoopHandle, rebuildSessionChatsFromRegistry, recordLastActiveChat, getLastActiveChat, pickDisplayChat, dequeueMessage, consumeQueuedMessage, cancelQueuedMessage, shiftInjection, unshiftInjection, drainRemainingInjections, clearInjections, setQueuePreservedChat, consumeQueuePreservedChat, markSessionFinalizing, clearSessionFinalizing, reserveAutoRecovery, consumeAutoRecoveryReservation, cancelAutoRecoveryReservation, hasAutoRecoveryReservation, } from "./session-chat-binding.js";
+import { bindChatToSession, unbindChatFromSession, getChatsForSession, activePrompts, displayCards, unifiedDisplayLoopHandle, setUnifiedDisplayLoopHandle, rebuildSessionChatsFromRegistry, recordLastActiveChat, getLastActiveChat, pickDisplayChat, dequeueMessage, consumeQueuedMessage, cancelQueuedMessage, shiftInjection, unshiftInjection, drainRemainingInjections, clearInjections, setQueuePreservedChat, consumeQueuePreservedChat, markSessionFinalizing, clearSessionFinalizing, reserveAutoRecovery, consumeAutoRecoveryReservation, cancelAutoRecoveryReservation, hasAutoRecoveryReservation, hasPendingInjection, } from "./session-chat-binding.js";
 async function sendFinalReplyTextOnce(platform, chatId, sessionId, turnCount, text) {
     const sent = await platform.sendText(chatId, text).then((ok) => ok !== false).catch(() => false);
     if (sent)
@@ -550,6 +550,7 @@ export function getAdapterForTool(tool, sessionId) {
             ...(config.ccc.provider ? { provider: config.ccc.provider } : {}),
             ...(config.ccc.subModel ? { subModel: config.ccc.subModel } : {}),
             ...(config.ccc.gitCoAuthor !== null ? { gitCoAuthor: config.ccc.gitCoAuthor } : {}),
+            hasPendingInjection,
         });
     }
     else if (tool === "dsh") {

package/package.json

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