chatccc 0.2.290 → 0.2.292

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "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,12 @@ 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 执行期以此频率检查是否有待注入的用户消息 */
+const YIELD_POLL_INTERVAL_MS = 250;
+/** 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 +728,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 +780,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 +793,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 +814,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 +851,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 +922,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 +933,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 +1287,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 +1305,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/agent-capability-grants.js

@@ -1,26 +1,109 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * 会话级能力凭据（capability grant）。
+ *
+ * 内存 Map 是本进程的权威视图；磁盘只用于跨进程重启恢复。
+ *
+ * 两条必须遵守的约束：
+ *  1. 签发后要落盘、校验时先内存后磁盘。否则 ChatCCC 重启会让所有定时发送
+ *     （周期报告、后台任务）在重启后立刻收到 403，而工作负载本身仍在运行 ——
+ *     故障是静默的。
+ *  2. clearAgentCapabilityGrants() 只清内存缓存，**绝不**删盘。它在进程首次启动
+ *     的 resetState() 里被调用；若此处删盘，每次重启都会重新随机发码，本修复
+ *     直接失效。需要真正作废授权请用 revokeAgentCapabilityGrant()。
+ */
 const grantsBySession = new Map();
+/**
+ * 与 config.ts 的 USER_DATA_DIR 同源。这里刻意不 import config.ts：该模块在顶层
+ * 有副作用（初始化文件日志、加载配置），被测试间接导入会带来多余 I/O 与循环
+ * 依赖风险；重复一个路径构造比引入副作用更安全。
+ */
+const DEFAULT_GRANTS_DIR = join(homedir(), ".chatccc", "state", "agent-grants");
+/** 覆盖点（测试/运维）；在每次调用时读取，便于测试导入之后再设置。 */
+export function agentGrantDir() {
+    const override = process.env.CHATCCC_AGENT_GRANT_DIR;
+    return override !== undefined && override.trim() !== "" ? override : DEFAULT_GRANTS_DIR;
+}
+function grantFilePath(sessionId) {
+    // sessionId 会进入文件名：只保留安全字符，避免路径穿越。
+    const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, "_");
+    return join(agentGrantDir(), `${safe}.grant`);
+}
+function readPersistedGrant(sessionId) {
+    try {
+        const value = readFileSync(grantFilePath(sessionId), "utf8").trim();
+        return value === "" ? undefined : value;
+    }
+    catch {
+        return undefined; // 不存在 / 不可读都视作“没有持久化授权”
+    }
+}
+function persistGrant(sessionId, grant) {
+    try {
+        mkdirSync(agentGrantDir(), { recursive: true });
+        const target = grantFilePath(sessionId);
+        const tmp = `${target}.tmp`;
+        // Windows 会忽略 mode，实际保护来自用户目录 ACL；POSIX 下为 0600。
+        writeFileSync(tmp, `${grant}\n`, { encoding: "utf8", mode: 0o600 });
+        renameSync(tmp, target); // 原子替换，避免读到半写文件
+    }
+    catch {
+        // 落盘失败不能让签发失败：内存里的授权码在本次进程生命周期内仍然可用。
+    }
+}
+function removePersistedGrant(sessionId) {
+    try {
+        rmSync(grantFilePath(sessionId), { force: true });
+    }
+    catch {
+        /* 删除失败不影响内存态 */
+    }
+}
+/** 内存优先；内存没有则从磁盘恢复，避免重启后重新随机发码。 */
+function expectedGrant(sessionId) {
+    const inMemory = grantsBySession.get(sessionId);
+    if (inMemory !== undefined)
+        return inMemory;
+    const persisted = readPersistedGrant(sessionId);
+    if (persisted !== undefined)
+        grantsBySession.set(sessionId, persisted);
+    return persisted;
+}
 export function issueAgentCapabilityGrant(sessionId) {
     if (!sessionId)
         throw new Error("sessionId is required for an agent capability grant");
-    const existing = grantsBySession.get(sessionId);
+    const existing = expectedGrant(sessionId);
     if (existing !== undefined)
         return existing;
     const grant = randomBytes(32).toString("base64url");
     grantsBySession.set(sessionId, grant);
+    persistGrant(sessionId, grant);
     return grant;
 }
 export function validateAgentCapabilityGrant(sessionId, candidate) {
     if (!sessionId || typeof candidate !== "string" || candidate.length === 0)
         return false;
-    const expected = grantsBySession.get(sessionId);
+    const expected = expectedGrant(sessionId);
     if (expected === undefined)
-        return false;
+        return false; // 查不到一律拒绝（fail closed）
     const expectedBytes = Buffer.from(expected, "utf8");
     const candidateBytes = Buffer.from(candidate, "utf8");
     return expectedBytes.length === candidateBytes.length
         && timingSafeEqual(expectedBytes, candidateBytes);
 }
+/** 真正作废某个会话的授权（内存 + 磁盘）。 */
+export function revokeAgentCapabilityGrant(sessionId) {
+    grantsBySession.delete(sessionId);
+    removePersistedGrant(sessionId);
+}
+/**
+ * 只清内存缓存，**不**删磁盘授权。
+ * 调用点：resetState()（进程首次启动）与测试清理。
+ * 若在这里同时删盘，则每次重启都会换码 —— 那正是本模块要修掉的故障。
+ */
 export function clearAgentCapabilityGrants() {
     grantsBySession.clear();
 }

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.290",
+  "version": "0.2.292",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",