chatccc 0.2.296 → 0.2.297

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}", // ✍️

package/package.json

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