chatccc 0.2.296 → 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/deepccc-agent/README.md

@@ -165,7 +165,7 @@ Web UI 支持新建、恢复、重命名和删除多会话，多个会话可以
 
 API 设置采用单一 Provider 配置，支持 OpenAI-compatible 与 Anthropic Messages。完整 API Key 只保存在本机 `~/.deepccc/config.json`，浏览器读取设置时仅返回掩码。危险命令会在会话中暂停并请求“拒绝、允许一次、本会话允许、永久允许”，浏览器断开或审批超时默认拒绝。
 
-`git.coAuthor.enabled` 默认开启。DeepCCC 通过 `run_command` 创建 Git 提交时会保留用户为
+`git.coAuthor.enabled` 默认开启。DeepCCC 通过 `run_process` 或 `run_command` 创建 Git 提交时会保留用户为
 主 Author，并追加 `Co-authored-by: DeepCCC <20184052+wzj998@users.noreply.github.com>`。
 可设为 `false` 或用 `DEEPCCC_GIT_COAUTHOR=false` 全局关闭。ChatCCC 的
 `ccc.gitCoAuthor` 是三态 override：`null`/缺失跟随这里，`true` 强制开启，`false` 强制关闭。
@@ -276,7 +276,7 @@ deepccc-cli --max-output-tokens 8192
 
 ## 权限机制
 
-`deepccc` 内置轻量权限机制，对标主流 agent 的审批体验：**只拦截有副作用的操作**（`run_command` 与文件写操作），只读工具（`read_file` / `list_dir` / `search_code`）永不拦截，常规文件编辑默认放行不打断工作流。
+`deepccc` 内置轻量权限机制，对标主流 agent 的审批体验：**只拦截有副作用的操作**（`run_process` / `run_script` / `run_command` 与文件写操作），只读工具（`read_file` / `list_dir` / `search_code`）永不拦截，常规文件编辑默认放行不打断工作流。
 
 默认模式（`ask`）下，只有**命中内置危险命令库**的高危命令才会询问，例如：
 
@@ -307,11 +307,13 @@ deepccc-cli --max-output-tokens 8192
 ```json
 {
   "allow": [
+    "run_process:git status*",
     "run_command:git status*",
     "run_command:git push --force origin release*"
   ],
   "deny": [
     "edit_file:node_modules/**",
+    "run_process:npm publish*",
     "run_command:npm publish*"
   ]
 }
@@ -433,11 +435,13 @@ deepccc 的内核主战场在 ChatCCC 仓库的 `deepccc-agent/` 子目录；本
 - 用 ripgrep 搜索代码
 - 编辑、创建、删除、移动文件
 - 应用 unified diff patch
-- 运行非交互式 shell 命令，并返回 stdout、stderr、exitCode 和超时状态
+- 用 `run_process` 以结构化 argv、`shell:false` 运行单个程序，避免参数被 shell 二次解析
+- 用 `run_script` 通过 stdin 运行多行 Python/Node 代码，避免复杂 `python -c` / `node -e` 引号
+- 仅在需要 `&&`、管道或重定向时用 `run_command` 运行非交互式 shell 命令
 - 联网搜索（`websearch`：DuckDuckGo，免 API key，返回标题 + URL + 摘要）
 - 抓取网页并转纯文本（`webfetch`：仅 http/https，自动去 HTML 标签、控制长度与超时）
 
-命令返回非零退出码时不会直接被当成工具异常；模型可以读取结构化结果，继续判断下一步。
+三个命令工具都支持独立 `cwd`、超时、取消、输出限长和运行中消息让位；返回非零退出码时不会直接被当成工具异常，模型可以读取结构化结果继续判断。Windows 下 `run_command` 会拒绝多行或嵌套同类引号的复杂 Python/Node 内联代码，并提示改用 `run_script`。
 
 ## License
 

package/deepccc-agent/os-prompts/win32.md

@@ -1,11 +1,11 @@
 ## Windows 命令行提示
 
-你运行在 Windows 上。run_command 通过 cmd.exe 执行，而不是 bash。cmd 的引号规则与 bash 不同，容易踩坑：
+你运行在 Windows 上。优先绕过 shell，只有需要 shell 运算符时才进入 cmd.exe：
 
-- 双引号不会被剥离：`echo "hello world"` 会原样打印 `"hello world"`（含引号），`"a b" "c"` 会把带引号的字面量 `"a b"` 和 `"c"` 传给程序。
-- 单引号在 cmd.exe 中不是引用字符：`'a b'` 会被解析成两个参数（`'a` 和 `b'`）。
-- 多行或引号密集的内联脚本（python -c "...\n...", ssh host "bash -c '...'"）在 cmd 引号规则下经常失败；把脚本写入临时文件再执行该文件。
-- PowerShell 专用语法（Get-Item、2>$null、Select-Object）不可用；除非显式调用 powershell，否则 shell 是 cmd.exe。
-- 传含空格参数时用双引号，并预期引号会原样到达程序；当目标接受文件输入时，优先把值写入文件。
-- cmd.exe 跨盘 `cd` 需要 `/d`：`cd /d D:\repo` 才真正切换盘符和目录；裸 `cd D:\repo` 只打印目标路径、停留在原盘，后续命令会在错误的目录执行。
-- npm 11.x 在 Windows 上忽略 `--prefix` 对 `npm publish` 的作用：`npm --prefix D:/repo publish` 发布的是**当前目录**的包，而不是 `--prefix` 指向的目录。务必先 `cd /d` 进入包目录，再执行 `npm publish`。
+- 单个程序优先用 `run_process`，把可执行文件和每个参数分别放进 `executable` / `args`。它使用 `shell:false`，不会让 cmd.exe 再解释引号、反斜杠、`&`、`%VAR%` 等内容。
+- 多行或引号密集的 Python/Node 代码必须用 `run_script`。不要塞进 `python -c` / `node -e`；Windows 下复杂内联代码会被 `run_command` 拒绝，避免命令返回 0 却实际执行了不同代码。
+- `run_command` 仅用于 `&&`、管道、重定向等必须由 shell 解析的场景；它通过 cmd.exe 执行，不是 bash，也不是 PowerShell。
+- 双引号在 cmd.exe、Node 的 shell 封装和目标程序的 argv 解析之间会经历多层处理；是否保留或剥离取决于具体调用链，不能假设会“原样到达”。单引号在 cmd.exe 中不是可靠的引用字符。
+- 使用各命令工具的 `cwd` 参数切换工作目录，不要前置 `cd /d ... &&`。只有手工编写纯 cmd 命令时，跨盘 `cd` 才需要 `/d`。
+- PowerShell 专用语法（Get-Item、2>$null、Select-Object）不能直接写进 `run_command`；确需使用时，用 `run_process` 显式执行 `powershell.exe` 并逐项传参。
+- npm 11.x 在 Windows 上忽略 `--prefix` 对 `npm publish` 的作用。发布时把工具的 `cwd` 参数设为目标包目录，再执行 `npm publish`。

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "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

@@ -4,7 +4,7 @@ import { createReadStream } from "node:fs";
 import { copyFile, mkdir, open, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createInterface } from "node:readline";
 import { jsonSchema, tool } from "ai";
 import { isDangerousCommand } from "./permissions.js";
@@ -25,6 +25,7 @@ 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;
+const MAX_SCRIPT_BYTES = 2 * 1024 * 1024;
 /**
  * 让位注入的轮询间隔：run_command 执行期以此频率检查是否有待注入的用户消息。
  * 取 1s 而非更小值：轮询本身不花 token（只读内存队列，无模型调用），但更密的
@@ -54,6 +55,22 @@ export function withGitCoAuthor(command, coAuthor) {
     const trailer = ` --trailer "Co-authored-by: ${coAuthor.name} <${coAuthor.email}>"`;
     return command.replace(/(^|(?:&&|\|\||;|\|)\s*)(git\s+commit)\b/g, (_match, prefix, gitCommit) => `${prefix}${gitCommit}${trailer}`);
 }
+/** Structured equivalent of withGitCoAuthor for run_process({ executable: "git", args: [...] }). */
+export function withGitCoAuthorArgs(executable, args, coAuthor) {
+    const executableName = basename(executable).replace(/\.(?:exe|cmd|bat)$/i, "").toLowerCase();
+    if (!coAuthor?.enabled
+        || executableName !== "git"
+        || args[0]?.toLowerCase() !== "commit"
+        || args.some((arg) => arg.includes(coAuthor.email))) {
+        return [...args];
+    }
+    return [
+        args[0],
+        "--trailer",
+        `Co-authored-by: ${coAuthor.name} <${coAuthor.email}>`,
+        ...args.slice(1),
+    ];
+}
 /**
  * 把 `~` / `~/x`（含反斜杠 `~\\x`）展开为用户主目录绝对路径。
  * `~user/x` 形式不展开（Node 无内置支持），保持原样交给后续解析。
@@ -775,10 +792,91 @@ function pruneBackgroundCommands() {
             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");
+const WINDOWS_INLINE_SCRIPT = /\b(?:python(?:\d+(?:\.\d+)?)?|py|node)(?:\.exe)?\s+(?:-c|-e|--eval)\s+/gi;
+/**
+ * cmd.exe cannot reliably preserve nested quotes/backslashes in complex inline
+ * Python/Node programs. Keep simple one-line snippets working, but reject the
+ * cases for which a zero exit code can still mean that different code ran.
+ */
+export function isUnsafeWindowsInlineScript(command) {
+    WINDOWS_INLINE_SCRIPT.lastIndex = 0;
+    let match;
+    while ((match = WINDOWS_INLINE_SCRIPT.exec(command)) !== null) {
+        const tail = command.slice(WINDOWS_INLINE_SCRIPT.lastIndex);
+        if (/[\r\n]/.test(tail))
+            return true;
+        const shellBoundary = tail.search(/\s(?:&&|\|\||[|>])/);
+        const argument = (shellBoundary >= 0 ? tail.slice(0, shellBoundary) : tail).trim();
+        const quote = argument[0];
+        if (quote !== "\"" && quote !== "'")
+            continue;
+        // cmd.exe does not treat single quotes as argument delimiters.
+        if (quote === "'")
+            return true;
+        const closingQuote = argument.lastIndexOf(quote);
+        if (closingQuote <= 0)
+            return true;
+        const body = argument.slice(1, closingQuote);
+        if (body.includes(quote))
+            return true;
+    }
+    return false;
+}
+function assertStringArgs(args) {
+    if (args === undefined)
+        return [];
+    if (!Array.isArray(args) || args.some((arg) => typeof arg !== "string")) {
+        throw new Error("args must be an array of strings");
+    }
+    return [...args];
+}
+function resolveProcessExecutable(commandCwd, value) {
+    const executable = value.trim();
+    if (!executable)
+        throw new Error("executable is required");
+    const expanded = expandHomePath(executable);
+    if (isAbsolute(expanded))
+        return resolve(expanded);
+    if (expanded.includes("/") || expanded.includes("\\") || expanded.startsWith(".")) {
+        return resolve(commandCwd, expanded);
+    }
+    return executable;
+}
+function formatProcessCommand(executable, args) {
+    return [executable, ...args].map((part) => JSON.stringify(part)).join(" ");
+}
+async function resolveWindowsNodeShim(executable, args) {
+    if (process.platform !== "win32" || extname(executable).toLowerCase() === ".exe") {
+        return { executable, args };
+    }
+    const toolName = basename(executable).replace(/\.(?:cmd|bat)$/i, "").toLowerCase();
+    if (toolName !== "npm" && toolName !== "npx")
+        return { executable, args };
+    const cliName = toolName === "npm" ? "npm-cli.js" : "npx-cli.js";
+    const candidates = new Set();
+    const npmExecPath = process.env.npm_execpath?.trim();
+    if (npmExecPath) {
+        candidates.add(toolName === "npm" ? npmExecPath : join(dirname(npmExecPath), cliName));
+    }
+    const addInstallRoot = (root) => {
+        if (root)
+            candidates.add(join(root, "node_modules", "npm", "bin", cliName));
+    };
+    addInstallRoot(dirname(process.execPath));
+    if (executable.includes("/") || executable.includes("\\"))
+        addInstallRoot(dirname(executable));
+    for (const pathEntry of (process.env.PATH ?? "").split(delimiter)) {
+        addInstallRoot(pathEntry.replace(/^"(.*)"$/, "$1"));
+    }
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return { executable: process.execPath, args: [candidate, ...args] };
+        }
+    }
+    throw new Error(`无法在 shell:false 下定位 Windows ${toolName} CLI；请用 run_command 执行 ${toolName}，`
+        + "或用 run_process 显式调用 node 并把 npm CLI JS 路径放入 args。");
+}
+async function spawnForTool(cwd, input, abortSignal, shouldYield) {
     const commandCwd = resolveToolPath(cwd, input.cwd);
     const cwdInfo = await stat(commandCwd);
     if (!cwdInfo.isDirectory()) {
@@ -788,6 +886,7 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor, shoul
     const startedAt = Date.now();
     const stdout = { chunks: [], bytes: 0, truncated: false };
     const stderr = { chunks: [], bytes: 0, truncated: false };
+    const command = input.command;
     return new Promise((resolvePromise, reject) => {
         let settled = false;
         let timedOut = false;
@@ -795,11 +894,11 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor, shoul
         let fallbackTimer;
         let yieldPoll;
         let backgroundEntry;
-        const child = spawn(command, {
+        const child = spawn(input.executable, input.args, {
             cwd: commandCwd,
-            shell: true,
+            shell: input.shell,
             windowsHide: true,
-            stdio: ["ignore", "pipe", "pipe"],
+            stdio: [input.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
             detached: process.platform !== "win32",
         });
         const cleanup = () => {
@@ -934,6 +1033,10 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor, shoul
         child.stderr?.on("data", (chunk) => {
             appendLimitedOutput(stderr, chunk);
         });
+        child.stdin?.on("error", () => {
+            // The child error/close event is authoritative; ignore a secondary EPIPE
+            // when an interpreter exits before consuming all script input.
+        });
         child.once("error", (err) => {
             if (backgroundEntry) {
                 settle(null, "error");
@@ -948,8 +1051,76 @@ export async function runCommandForTool(cwd, input, abortSignal, coAuthor, shoul
         child.once("close", (code, signal) => {
             settle(code, signal);
         });
+        if (input.stdin !== undefined) {
+            child.stdin?.end(input.stdin, "utf8");
+        }
     });
 }
+export async function runCommandForTool(cwd, input, abortSignal, coAuthor, shouldYield) {
+    const command = withGitCoAuthor(input.command?.trim(), coAuthor);
+    if (!command)
+        throw new Error("command is required");
+    if (process.platform === "win32" && isUnsafeWindowsInlineScript(command)) {
+        throw new Error("Windows CMD 无法可靠传递复杂的 python -c/node -e 内联代码；请改用 run_script，"
+            + "单程序参数请用 run_process。run_command 仅保留给 &&、管道和重定向等 shell 操作。");
+    }
+    return spawnForTool(cwd, {
+        executable: command,
+        args: [],
+        command,
+        cwd: input.cwd,
+        timeoutMs: input.timeoutMs,
+        shell: true,
+    }, abortSignal, shouldYield);
+}
+export async function runProcessForTool(cwd, input, abortSignal, coAuthor, shouldYield) {
+    const commandCwd = resolveToolPath(cwd, input.cwd);
+    const requestedExecutable = resolveProcessExecutable(commandCwd, input.executable ?? "");
+    const requestedArgs = withGitCoAuthorArgs(requestedExecutable, assertStringArgs(input.args), coAuthor);
+    const invocation = await resolveWindowsNodeShim(requestedExecutable, requestedArgs);
+    return spawnForTool(cwd, {
+        executable: invocation.executable,
+        args: invocation.args,
+        command: formatProcessCommand(requestedExecutable, requestedArgs),
+        cwd: commandCwd,
+        timeoutMs: input.timeoutMs,
+        shell: false,
+    }, abortSignal, shouldYield);
+}
+async function defaultScriptExecutable(commandCwd, language) {
+    if (language === "node")
+        return process.execPath;
+    const venvPython = process.platform === "win32"
+        ? join(commandCwd, ".venv", "Scripts", "python.exe")
+        : join(commandCwd, ".venv", "bin", "python");
+    if (await pathExists(venvPython))
+        return venvPython;
+    return process.platform === "win32" ? "python" : "python3";
+}
+export async function runScriptForTool(cwd, input, abortSignal, shouldYield) {
+    if (input.language !== "node" && input.language !== "python") {
+        throw new Error("language must be node or python");
+    }
+    if (typeof input.code !== "string" || !input.code.trim()) {
+        throw new Error("code is required");
+    }
+    if (Buffer.byteLength(input.code, "utf8") > MAX_SCRIPT_BYTES) {
+        throw new Error(`script exceeds ${MAX_SCRIPT_BYTES} bytes`);
+    }
+    const commandCwd = resolveToolPath(cwd, input.cwd);
+    const configuredExecutable = input.executable?.trim();
+    const executable = resolveProcessExecutable(commandCwd, configuredExecutable || await defaultScriptExecutable(commandCwd, input.language));
+    const args = ["-", ...assertStringArgs(input.args)];
+    return spawnForTool(cwd, {
+        executable,
+        args,
+        command: `${formatProcessCommand(executable, args)} <${input.language} script via stdin>`,
+        cwd: commandCwd,
+        timeoutMs: input.timeoutMs,
+        shell: false,
+        stdin: input.code,
+    }, abortSignal, shouldYield);
+}
 /** 读取后台命令的最新输出；waitMs > 0 时最多等待该时长（等待期间仍可让位）。 */
 export async function commandOutputForTool(taskId, input, shouldYield) {
     const entry = backgroundCommands.get(taskId);
@@ -1407,14 +1578,72 @@ export function createBuiltinFileTools(cwd, options = {}) {
             }),
             execute: (input) => presentFileForTool(cwd, input),
         }),
+        run_process: tool({
+            description: "优先使用：以结构化 executable + args 直接运行单个非交互式程序（shell:false），参数不会经过平台 shell 展开，适合测试、git、npm 和含空格/引号的参数。需要 &&、管道或重定向时才用 run_command。",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    executable: { type: "string", description: "可执行文件名或路径，例如 git、npm、node、.venv/Scripts/python.exe。" },
+                    args: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "逐项传递给程序的参数；不要自行拼接或 shell 转义。",
+                    },
+                    cwd: { type: "string", description: "可选工作目录。请用此字段切换目录，不要在命令前拼接 cd /d。" },
+                    timeoutMs: { type: "number", description: `可选超时（毫秒），上限为 ${MAX_COMMAND_TIMEOUT_MS}。` },
+                },
+                required: ["executable"],
+            }),
+            execute: async (input, execOptions) => {
+                const action = [input.executable, ...(input.args ?? [])].join(" ");
+                await guard({
+                    tool: "run_process",
+                    action,
+                    reason: isDangerousCommand(action) ? "high-risk" : "rule",
+                    detail: `运行程序: ${action}`,
+                });
+                return runProcessForTool(cwd, input, execOptions.abortSignal, options.gitCoAuthor, options.shouldYieldToInjection);
+            },
+        }),
+        run_script: tool({
+            description: "运行多行 Node.js 或 Python 脚本，代码通过 stdin 传入解释器（shell:false），避免 python -c/node -e 的多层引号问题。Python 默认优先使用 cwd 下的 .venv，也可显式指定 executable。",
+            inputSchema: jsonSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    language: { type: "string", enum: ["node", "python"], description: "脚本语言。" },
+                    code: { type: "string", description: "要执行的完整多行代码，不需要 shell 引号。" },
+                    args: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "可选脚本参数，逐项原样传递。",
+                    },
+                    executable: { type: "string", description: "可选解释器路径，例如 .venv/Scripts/python.exe。" },
+                    cwd: { type: "string", description: "可选工作目录。请用此字段切换目录，不要在命令前拼接 cd /d。" },
+                    timeoutMs: { type: "number", description: `可选超时（毫秒），上限为 ${MAX_COMMAND_TIMEOUT_MS}。` },
+                },
+                required: ["language", "code"],
+            }),
+            execute: async (input, execOptions) => {
+                const runtime = input.executable?.trim() || input.language;
+                await guard({
+                    tool: "run_script",
+                    action: `${runtime} script`,
+                    reason: "rule",
+                    detail: `运行 ${input.language} 脚本`,
+                });
+                return runScriptForTool(cwd, input, execOptions.abortSignal, options.shouldYieldToInjection);
+            },
+        }),
         run_command: tool({
-            description: "在本地工作区运行非交互式 shell 命令。用于测试、git 和包脚本。返回 stdout/stderr 和 exitCode；非零退出码不是工具错误。命令运行期间若用户发来新消息，会立即转入后台并返回 taskId（backgrounded:true），命令继续运行，用 command_output 取后续输出。",
+            description: "仅在需要 &&、管道、重定向或其他 shell 运算符时运行非交互式 shell 命令；单程序优先用 run_process，多行 Python/Node 优先用 run_script。请用 cwd 字段切换目录，不要前置 cd /d。返回 stdout/stderr 和 exitCode；非零退出码不是工具错误。运行期间若有新消息会转入后台并返回 taskId。",
             inputSchema: jsonSchema({
                 type: "object",
                 additionalProperties: false,
                 properties: {
-                    command: { type: "string", description: "要在平台 shell 中运行的命令行。" },
-                    cwd: { type: "string", description: "可选的工作目录。默认为会话工作目录。" },
+                    command: { type: "string", description: "确实需要 shell 解析的命令行。Windows 下复杂 python -c/node -e 会被拒绝。" },
+                    cwd: { type: "string", description: "可选工作目录。请用此字段切换目录，不要在命令前拼接 cd /d。" },
                     timeoutMs: { type: "number", description: `可选超时（毫秒），上限为 ${MAX_COMMAND_TIMEOUT_MS}。` },
                 },
                 required: ["command"],
@@ -1430,12 +1659,12 @@ export function createBuiltinFileTools(cwd, options = {}) {
             },
         }),
         command_output: tool({
-            description: "读取被让位到后台的命令的最新输出。立即返回当前状态；waitMs 可最多等待 30 秒。任务结束后可反复读取完整 stdout/stderr。",
+            description: "读取 run_process、run_script 或 run_command 让位到后台后的最新输出。立即返回当前状态；waitMs 可最多等待 30 秒。",
             inputSchema: jsonSchema({
                 type: "object",
                 additionalProperties: false,
                 properties: {
-                    taskId: { type: "string", description: "run_command 返回的 taskId（backgrounded:true 时）。" },
+                    taskId: { type: "string", description: "命令工具返回的 taskId（backgrounded:true 时）。" },
                     waitMs: { type: "number", description: `可选等待毫秒数；0 或省略立即返回，上限 ${MAX_COMMAND_OUTPUT_WAIT_MS}。` },
                 },
                 required: ["taskId"],
@@ -1443,12 +1672,12 @@ export function createBuiltinFileTools(cwd, options = {}) {
             execute: (input) => commandOutputForTool(input.taskId, input, options.shouldYieldToInjection),
         }),
         command_kill: tool({
-            description: "终止一个仍在后台运行的命令（run_command 让位后转入后台的）。",
+            description: "终止一个由 run_process、run_script 或 run_command 转入后台的进程。",
             inputSchema: jsonSchema({
                 type: "object",
                 additionalProperties: false,
                 properties: {
-                    taskId: { type: "string", description: "run_command 返回的 taskId。" },
+                    taskId: { type: "string", description: "命令工具返回的 taskId。" },
                 },
                 required: ["taskId"],
             }),

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

@@ -153,8 +153,8 @@ function readProjectInstructionFiles(cwd) {
 function buildRuntimeWorkspacePrompt(cwd) {
     return [
         `当前工作目录：${cwd}`,
-        "需要理解代码、配置、项目结构、测试或 git 状态时，主动使用 read_file、list_dir、search_code 和 run_command。",
-        "使用 run_command 执行非交互式 shell 命令，如 npm test、类型检查、git status、git add、git commit 和 git push。先检查 exitCode、stdout 和 stderr 再决定下一步。",
+        "需要理解代码、配置、项目结构、测试或 git 状态时，主动使用 read_file、list_dir、search_code 和命令执行工具。",
+        "单个程序优先使用 run_process 的结构化 executable/args；多行 Python/Node 使用 run_script；只有 &&、管道、重定向等 shell 场景才使用 run_command。用 cwd 参数切换目录，不要前置 cd。先检查 exitCode、stdout 和 stderr 再决定下一步。",
         "编辑前先阅读相关文件范围。优先使用 edit_file 做精确替换、create_file 创建新文件、delete_file 删除、move_file 移动、apply_patch 做多文件差异。",
         "文件工具通过 DeepCCC 在本地执行。可行时优先使用带 SHA-256 前置条件的受保护编辑，避免覆盖并发用户修改。",
     ].join("\n");
@@ -288,7 +288,7 @@ export class ChatSession {
     context;
     compactionTimeoutMs;
     maxSteps;
-    /** 透传给 run_command 的让位注入判定（见 ChatSessionOptions.shouldYieldToInjection）。 */
+    /** 透传给命令工具的让位注入判定（见 ChatSessionOptions.shouldYieldToInjection）。 */
     shouldYieldToInjection;
     effort;
     maxOutputTokens;

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

@@ -146,7 +146,7 @@ export class PermissionGate {
             return "deny";
         if (rules.allow.some((r) => keys.some((k) => matchRule(r, k))))
             return "allow";
-        // 只有命中内置危险命令库的 run_command 才询问；文件编辑等常规操作默认放行
+        // 只有命令执行工具标记为 high-risk 才询问；文件编辑等常规操作默认放行
         if (request.reason !== "high-risk")
             return "allow";
         // 高危且无交互能力（非 TTY / JSONL / 程序化调用）→ 安全默认拒绝

package/dist/deepccc-agent/src/progress/cards-helpers.js

@@ -50,6 +50,8 @@ const TOOL_EMOJI_MAP = {
     read_file: "\u{1F4D6}", // 📖
     list_dir: "\u{1F4C2}", // 📂
     search_code: "\u{1F50E}", // 🔎
+    run_process: "\u{1F5A5}\u{FE0F}", // 🖥️
+    run_script: "\u{1F5A5}\u{FE0F}", // 🖥️
     run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
     edit_file: "\u{270F}\u{FE0F}", // ✏️
     create_file: "\u{270D}\u{FE0F}", // ✍️

package/dist/deepccc-agent/src/web-tool-presentation.js

@@ -2,6 +2,8 @@ export const WEB_TOOL_SUMMARY_RULES = {
     read_file: { emoji: "📖", inputFields: ["path"] },
     list_dir: { emoji: "📂", inputFields: ["path"] },
     search_code: { emoji: "🔎", inputFields: ["query", "path"] },
+    run_process: { emoji: "🖥️", inputFields: ["executable", "args", "cwd"] },
+    run_script: { emoji: "🖥️", inputFields: ["language", "cwd"] },
     run_command: { emoji: "🖥️", inputFields: ["command"] },
     edit_file: { emoji: "✏️", inputFields: ["path"] },
     create_file: { emoji: "✍️", inputFields: ["path"] },

package/dist/src/cards.js

@@ -61,6 +61,8 @@ const TOOL_EMOJI_MAP = {
     read_file: "\u{1F4D6}", // 📖
     list_dir: "\u{1F4C2}", // 📂
     search_code: "\u{1F50E}", // 🔎
+    run_process: "\u{1F5A5}\u{FE0F}", // 🖥️
+    run_script: "\u{1F5A5}\u{FE0F}", // 🖥️
     run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
     edit_file: "\u{270F}\u{FE0F}", // ✏️
     create_file: "\u{270D}\u{FE0F}", // ✍️
@@ -397,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;
@@ -417,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.296",
+  "version": "0.2.298",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",