@muyichengshayu/promptx 0.1.48 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.2.1
+
+- 新增工作台 `shell` 命令模式：在右侧编辑区输入 `!pwd`、`!git status`、`!pnpm test` 这类纯文本命令时，PromptX 会直接按当前选中的 `Codex / Claude Code / OpenCode` 语义发起本地命令执行，并把结果继续收拢回原有的 `PromptX → Agent / Agent` 对话流，不额外引入一套独立的 Shell 卡片心智。
+- 收紧命令模式的安全边界与展示逻辑：命令意图改为由服务端重新解析，不再信任前端直传命令；shell run 固定绑定 root project session，避免污染 member session 的 thread/identity；默认仅本机可用，Relay 需在设置里显式开启“允许远程执行命令模式”后，且仅对带内部标记的 relay 转发请求放行。
+- 为远程命令模式补齐配置与回归测试：Relay 设置页新增高权限开关与明确警告，诊断信息也会带上该配置；同时新增本地允许、远程默认拒绝、仅 relay 显式开启可用、环境变量覆盖等测试，降低后续回归风险。
+- 修复 runner 大事件上报导致任务卡死的问题：内部 runner events 接口提高了 body limit，避免长过程日志或大批量事件刷新时触发 `Request body is too large`，导致一轮任务停在中间。
+- 改进代码变更审查对 Git submodule 的支持：代码变更与 diff review 现在会展开 submodule 内部的真实文件改动，而不再只显示顶层 submodule 占位项；相关任务级、轮次级与子文件明细链路都已补齐测试。
+- 补充开发环境的 `Vite allowedHosts` 配置，方便在代理、局域网或特定本地域名下更稳定地访问工作台开发服务。
+
+## 0.2.0
+
+- 项目正式升级为多 Agent 协作模型：一个项目可同时绑定 `Codex / Claude Code / OpenCode`，右侧可直接切换本轮发送目标，中栏也支持按 Agent 过滤整轮消息流，适合同一任务里拆分“方案 / 执行 / 复核”等分工。
+- 加强项目与本机会话的双向复用：创建或编辑项目时可直接发现并选择本机已有 session，`PromptX` 内新建和推进出来的会话也能稳定回流到候选列表；同时补齐 root project session 与 hidden member sessions 的绑定、回写、重置与删除语义。
+- 收敛多 Agent 下的事件与状态同步：runner 派发会把 run 正确绑定到实际 member session，事件回写后仍广播完整项目快照，避免 partial session 更新把 `agentBindings` 冲掉；同时为这条链路补齐服务端回归测试与真实浏览器 E2E。
+- 持续打磨源码查看、代码变更与上下文回插体验：支持在回复、源码与 diff 中直接选中片段插回右侧编辑区，并统一源码 / 搜索 / 代码变更 / Agent selector 的交互与选中态，减少桌面端与移动端的割裂感。
+- 更新产品文档与展示素材：中英文 README 重写为当前产品结构，截图统一切换为 `WeChat` 主题，并新增工作台总览、多 Agent 项目管理、源码查看、代码变更、设置页与手机端等多组场景图。
+- 修复 relay 场景下图片下发给 agent 时的地址问题：发送给 `Codex / Claude Code / OpenCode` 的图片 URL 改为优先使用本机 PromptX 服务地址，避免 relay 域名下的临时图片链接因鉴权或过期导致模型看图失败。
+
 ## 0.1.48
 
 - 修复移动端“选中后插入到编辑区”偶发无效的问题：选区按钮改为更早的 `pointerdown` 触发，避免手机上点击按钮时浏览器先清掉选区，导致按钮消失但内容没有真正插入。

package/README.en.md

@@ -2,21 +2,31 @@
 
 [中文 README](README.md)
 
-PromptX is a local AI agent workspace.
+PromptX is a local workspace for AI agents.
 
-It organizes `Codex`, `Claude Code`, and `OpenCode` into a cleaner workflow:
+It takes the CLI tools you already use — `Codex`, `Claude Code`, and `OpenCode` — and organizes them into a workflow that is easier to keep running over time:
 
 ```text
 Task -> Project -> Directory -> Thread -> Run -> Diff
 ```
 
-You keep using the agent CLI you already know, while PromptX brings inputs, project binding, execution logs, final replies, and code diffs into one workspace.
+You keep using the agent and model you already know. PromptX brings structured input, project binding, execution logs, final replies, code review, and source browsing into one workspace.
 
 PromptX can also reuse sessions with these agent CLIs in both directions:
 
 - Start a session in `Codex`, `Claude Code`, or `OpenCode`, then continue it inside PromptX
 - Start and advance a project inside PromptX, then resume the same session back in the agent CLI
 
+## Why It Is More Useful Now
+
+- One project can attach multiple agents, and you can switch the send target from the right panel
+- Review `PromptX` input cards, execution logs, final replies, and run history on the same page
+- Browse the current project source code in read-only mode, with path and content search
+- Inspect workspace-level, task-level, or per-run diffs without leaving the app
+- Insert useful fragments from prompts, replies, source files, and diffs back into the editor
+- Multiple built-in themes are available; the screenshots below use the `WeChat` theme
+- Relay support lets you access your local PromptX from mobile or external networks
+
 ## Quick Start
 
 ### Requirements
@@ -45,51 +55,82 @@ promptx status
 promptx stop
 ```
 
-### How To Use
+### Basic Workflow
 
-1. Create a task and prepare the context you want to send
-2. Bind the task to a project
-3. Choose a working directory and engine for that project
-4. Send and review execution logs, final replies, and code diffs on the same page
+1. Create a task and prepare the requirements, logs, screenshots, and files you want to send
+2. Bind that task to a project
+3. Choose a working directory, default engine, and optional collaborating agents
+4. Pick which agent should receive this round from the right panel
+5. Send and review logs, replies, source files, and diffs in the same workspace
+6. Insert useful snippets back into the editor and continue the next round
 
 ## Core Features
 
 - Structured input: text, images, `md`, `txt`, and `pdf`
-- Project reuse: keep a stable directory and engine/thread context
-- Visible process: inspect logs, final replies, and run history
+- Project reuse: keep a stable directory and default engine/thread context
+- Multi-agent collaboration: one project can attach `Codex`, `Claude Code`, and `OpenCode`
+- Visible process: inspect execution logs, final replies, and run history
+- Source browser: read-only source browsing with path search and content search
 - Built-in diff review: inspect workspace, accumulated task, or per-run changes
-- Multi-engine support: `Codex`, `Claude Code`, `OpenCode`
+- Context reinsertion: insert content from prompts, replies, source files, and diffs back into the editor
 - Session interoperability: PromptX can reuse sessions with `Codex`, `Claude Code`, and `OpenCode`
 - Remote access: connect from mobile or external networks through Relay
 
 ## Screenshots
 
-### Workspace
+All screenshots below use the `WeChat` theme.
+
+### 1. Workspace Overview
+
+See the task list, agent filter, input cards, execution logs, and final replies together.
+
+![PromptX workspace overview](docs/assets/readme-workbench-wechat.png)
+
+### 2. Execution Logs and Replies
+
+Review prompts, process logs, and final replies from the same round without bouncing between the terminal and diff tools.
+
+![PromptX execution focus](docs/assets/readme-execution-focus-wechat.png)
+
+### 3. Multi-Agent Project Management
+
+One project can attach multiple agents while sharing the same directory. Each agent builds its own thread on first send.
+
+![PromptX multi-agent project management](docs/assets/readme-project-manager-wechat.png)
+
+### 4. Read-Only Source Browser
+
+Use the directory tree and search results on the left, with file preview on the right, to inspect code and send context back into the editor.
+
+![PromptX source browser](docs/assets/readme-source-browser-wechat.png)
+
+### 5. Diff Review
+
+Inspect workspace-level, task-level, or single-run changes to understand exactly what an agent changed.
+
+![PromptX diff review](docs/assets/readme-diff-wechat.png)
 
-![PromptX workspace](docs/assets/readme-workbench-glass.png)
+### 6. Settings and System Panels
 
-### Settings
+Theme, shortcuts, remote access, and system configuration all live in the same settings dialog.
 
-![PromptX settings](docs/assets/readme-settings-theme-glass.png)
+![PromptX theme settings](docs/assets/readme-settings-theme-wechat.png)
 
-### Mobile
+![PromptX system settings](docs/assets/readme-settings-system-wechat.png)
 
-![PromptX mobile](docs/assets/readme-mobile-remote-glass.png)
+### 7. Mobile
 
-## Why It Helps
+With Relay or local network access, you can keep reading replies and pushing work forward from your phone.
 
-- Keeps long-running tasks out of scattered terminal tabs and notes
-- Avoids re-explaining directories, projects, and context every round
-- Lets you review process and result together, not just the final answer
-- Makes code review easier with built-in diff inspection
-- Keeps tasks accessible on mobile when you are away from your desk
+![PromptX mobile](docs/assets/readme-mobile-wechat.png)
 
 ## Good Fit For
 
-- Preparing requirements, screenshots, logs, and files before sending
-- Reusing the same project and directory across many rounds
-- Reviewing execution logs, final output, and code changes together
-- Exposing local PromptX to phones or external networks through Relay
+- Preparing requirements, screenshots, logs, and files before sending them to an agent
+- Reusing the same project, directory, and thread across many rounds
+- Coordinating multiple agents in one task without bouncing between terminals
+- Reviewing execution logs, replies, source files, and code changes together
+- Continuing local PromptX work from your phone when you are away from your desk
 
 ## Development
 

package/README.md

@@ -2,20 +2,30 @@
 
 [English README](README.en.md)
 
-PromptX 是一个面向本机 AI Agent 协作的工作台。
+PromptX 是一个面向本机 AI Agent 的协作工作台。
 
-它把 `Codex`、`Claude Code`、`OpenCode` 的使用过程整理成一套更顺手的结构：
+它把 `Codex`、`Claude Code`、`OpenCode` 这些你已经熟悉的 CLI，整理成一套更适合持续协作的界面：
 
 ```text
 任务 -> 项目 -> 目录 -> 线程 -> Run -> Diff
 ```
 
-你继续使用熟悉的 agent CLI，PromptX 负责把输入整理、项目绑定、执行过程、最终回复和代码变更放进同一个工作台里。
+你继续使用熟悉的 agent 与模型，PromptX 负责把输入整理、项目绑定、执行过程、最终回复、代码变更、源码查看放进同一个工作台里。
 
-并且，PromptX 和这些 agent CLI 之间可以互相复用会话：
+并且，PromptX 与这些 agent CLI 可以双向复用会话：
 
-- 可以在 `Codex`、`Claude Code`、`OpenCode` 里先创建会话，再回到 PromptX 里继续
-- 也可以在 PromptX 里创建和推进项目，再回到 agent CLI 里直接恢复同一个会话
+- 你可以先在 `Codex`、`Claude Code`、`OpenCode` 里创建会话，再回到 PromptX 继续
+- 也可以在 PromptX 里创建和推进项目，再回到 agent CLI 里恢复同一个会话
+
+## 为什么现在值得用
+
+- 一个项目可以挂多个 Agent，右侧直接切换发送目标
+- 同页查看 `PromptX` 输入卡片、执行过程、最终回复、历史 run
+- 直接查看当前项目源码，并支持按路径或内容搜索
+- 直接审查 workspace / 任务累计 / 单轮 run 的代码变更
+- 可以把 `Prompt`、回复、源码、Diff 中的内容再次插回编辑区，继续下一轮
+- 内置多主题，当前 README 截图统一使用 `WeChat` 主题
+- 可配合 Relay 从手机或外网访问自己的 PromptX
 
 ## 快速开始
 
@@ -45,51 +55,82 @@ promptx status
 promptx stop
 ```
 
-### 怎么用
+### 基本使用流程
 
-1. 新建任务，整理本轮要发给 agent 的内容
+1. 新建任务，先整理本轮要发给 agent 的需求、日志、图片、文件
 2. 给任务绑定一个项目
-3. 给项目选择工作目录和执行引擎
-4. 点击发送，在同一页查看执行过程、最终回复和代码变更
+3. 给项目选择工作目录、默认执行引擎，以及可协作的其他 Agents
+4. 在右侧选择这轮要发给哪个 Agent
+5. 发送后，在同一页查看执行过程、最终回复、源码、代码变更
+6. 把有价值的片段重新插回编辑区，继续下一轮
 
 ## 核心能力
 
 - 输入整理：支持文本、图片、`md`、`txt`、`pdf`
-- 项目复用：一个项目绑定固定目录和执行引擎，持续复用线程上下文
+- 项目复用：一个项目绑定固定目录与默认执行引擎，持续复用线程上下文
+- 多 Agent 协作：一个项目可同时挂 `Codex`、`Claude Code`、`OpenCode`
 - 过程可见：同页查看执行过程、最终回复、历史 run
+- 源码查看：只读浏览当前项目源码，支持路径搜索与内容搜索
 - 代码审查：直接查看 workspace / 任务累计 / 单次 run 的 diff
-- 多引擎统一：当前支持 `Codex`、`Claude Code`、`OpenCode`
+- 上下文回插：支持从 Prompt、回复、源码、Diff 中选取内容插回编辑区
 - 会话互通：PromptX 与 `Codex`、`Claude Code`、`OpenCode` 可双向复用会话
 - 远程访问：支持通过 Relay 从手机或外网访问自己的 PromptX
 
 ## 系统截图
 
-### 工作台
+以下截图基于 `WeChat` 主题。
+
+### 1. 工作台总览
+
+可以同时看到任务列表、Agent 过滤、输入卡片、执行过程和最终回复。
+
+![PromptX 工作台总览](docs/assets/readme-workbench-wechat.png)
+
+### 2. 执行过程与回复
+
+同一轮里直接看 Prompt、过程日志、最终回复，不用在终端和 diff 工具之间来回切。
+
+![PromptX 执行过程与回复](docs/assets/readme-execution-focus-wechat.png)
+
+### 3. 多 Agent 项目管理
+
+一个项目可以挂多个 Agent，目录保持一致，首次发送时自动建立各自线程。
+
+![PromptX 多 Agent 项目管理](docs/assets/readme-project-manager-wechat.png)
+
+### 4. 只读源码查看
+
+左侧目录树与搜索结果，右侧文件预览；适合快速浏览、搜索、选中代码并插回编辑区。
+
+![PromptX 源码查看](docs/assets/readme-source-browser-wechat.png)
+
+### 5. 代码变更审查
+
+直接看当前项目、任务累计或单轮 run 的代码变更，适合回顾 agent 到底改了什么。
+
+![PromptX 代码变更审查](docs/assets/readme-diff-wechat.png)
 
-![PromptX 工作台](docs/assets/readme-workbench-glass.png)
+### 6. 设置与系统
 
-### 设置
+主题、快捷键、远程访问、系统配置集中在同一个设置面板里。
 
-![PromptX 设置](docs/assets/readme-settings-theme-glass.png)
+![PromptX 主题设置](docs/assets/readme-settings-theme-wechat.png)
 
-### 手机端
+![PromptX 系统设置](docs/assets/readme-settings-system-wechat.png)
 
-![PromptX 手机端](docs/assets/readme-mobile-remote-glass.png)
+### 7. 手机端
 
-## 为什么好用
+通过 Relay 或局域网访问时，可以在手机端继续查看任务、阅读回复、推进协作。
 
-- 不用把多轮任务散落在终端和聊天记录里
-- 不用每轮都重新交代目录、项目和上下文
-- 不只看最终一句回答，还能回看过程和 run 历史
-- 改完代码后不用再切回命令行单独看 diff
-- 离开电脑后，也能继续在手机上看任务和推进任务
+![PromptX 手机端](docs/assets/readme-mobile-wechat.png)
 
 ## 适合什么场景
 
 - 先整理需求、截图、日志、文件，再交给 agent 执行
 - 一个项目要持续多轮协作，希望稳定复用目录和线程
-- 需要同时看执行过程、最终回复和代码改动
-- 希望把本机 PromptX 通过 Relay 暴露给手机或外部网络
+- 一个任务里需要多个 Agent 配合，但又不想来回切命令行
+- 需要同时看执行过程、最终回复、源码与代码改动
+- 离开电脑后，也想从手机继续推进本机 PromptX
 
 ## 源码开发
 

package/apps/runner/src/engines/index.js

@@ -7,22 +7,32 @@ import {
 import { codexRunner } from './codexRunner.js'
 import { claudeCodeRunner } from './claudeCodeRunner.js'
 import { openCodeRunner } from './openCodeRunner.js'
+import { shellRunner } from './shellRunner.js'
 
 const runnerRegistry = new Map([
   [codexRunner.engine, codexRunner],
   [claudeCodeRunner.engine, claudeCodeRunner],
   [openCodeRunner.engine, openCodeRunner],
+  [shellRunner.engine, shellRunner],
 ])
 
+function normalizeRunnerEngine(engine = AGENT_ENGINES.CODEX) {
+  const normalized = String(engine || '').trim().toLowerCase()
+  if (normalized === shellRunner.engine) {
+    return shellRunner.engine
+  }
+  return normalizeAgentEngine(normalized)
+}
+
 export function getAgentRunner(engine = AGENT_ENGINES.CODEX) {
-  return runnerRegistry.get(normalizeAgentEngine(engine)) || null
+  return runnerRegistry.get(normalizeRunnerEngine(engine)) || null
 }
 
 export function assertAgentRunner(engine = AGENT_ENGINES.CODEX) {
-  const normalized = normalizeAgentEngine(engine)
+  const normalized = normalizeRunnerEngine(engine)
   const runner = getAgentRunner(normalized)
   if (!runner) {
-    throw new Error(`当前还不支持执行引擎：${getAgentEngineLabel(normalized)}`)
+    throw new Error(`当前还不支持执行引擎：${normalized === shellRunner.engine ? shellRunner.label : getAgentEngineLabel(normalized)}`)
   }
   return runner
 }

package/apps/runner/src/engines/shellRunner.js

@@ -0,0 +1,216 @@
+import { spawn } from 'node:child_process'
+import {
+  createAgentEventEnvelopeEvent,
+  createCompletedEnvelopeEvent,
+  createStderrEnvelopeEvent,
+  createStdoutEnvelopeEvent,
+} from '../../../../packages/shared/src/agentRunEnvelopeEvents.js'
+import {
+  AGENT_RUN_EVENT_TYPES,
+  AGENT_RUN_ITEM_TYPES,
+  createItemCompletedEvent,
+  createItemStartedEvent,
+} from '../../../../packages/shared/src/agentRunEvents.js'
+import { createManagedSpawnOptions, forceStopChildProcess } from '../processControl.js'
+
+const SHELL_ENGINE = 'shell'
+const MAX_SHELL_OUTPUT_TAIL_LENGTH = Math.max(
+  16 * 1024,
+  Number(process.env.PROMPTX_SHELL_OUTPUT_TAIL_LENGTH) || 128 * 1024
+)
+
+function appendOutputTail(current = '', chunk = '', maxLength = MAX_SHELL_OUTPUT_TAIL_LENGTH) {
+  const next = `${String(current || '')}${String(chunk || '')}`
+  if (next.length <= maxLength) {
+    return next
+  }
+  return next.slice(next.length - maxLength)
+}
+
+function splitBufferedLines(buffer = '') {
+  const normalized = String(buffer || '')
+  if (!normalized) {
+    return { lines: [], rest: '' }
+  }
+
+  const parts = normalized.split(/\r?\n/g)
+  const rest = /(?:\r?\n)$/.test(normalized) ? '' : parts.pop() || ''
+  return {
+    lines: parts.filter(Boolean),
+    rest,
+  }
+}
+
+function getShellCommand(command = '') {
+  const raw = String(command || '').trim()
+  if (!raw) {
+    return {
+      executable: '',
+      args: [],
+      displayCommand: '',
+    }
+  }
+
+  if (process.platform === 'win32') {
+    const executable = process.env.ComSpec || 'cmd.exe'
+    return {
+      executable,
+      args: ['/d', '/s', '/c', raw],
+      displayCommand: `${executable} /d /s /c ${raw}`,
+    }
+  }
+
+  const executable = process.env.SHELL || '/bin/zsh'
+  return {
+    executable,
+    args: ['-lc', raw],
+    displayCommand: `${executable} -lc ${raw}`,
+  }
+}
+
+function createCommandItem(command = '', status = 'running', aggregatedOutput = '', exitCode = null) {
+  return {
+    type: AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION,
+    command: String(command || '').trim(),
+    status: String(status || '').trim() || 'running',
+    aggregated_output: String(aggregatedOutput || ''),
+    ...(typeof exitCode === 'number' ? { exit_code: exitCode } : {}),
+  }
+}
+
+export const shellRunner = {
+  engine: SHELL_ENGINE,
+  label: 'Shell',
+  supportsWorkspaceHistory: false,
+  streamSessionPrompt(session, prompt, callbacks = {}) {
+    const command = String(prompt || '').trim()
+    if (!command) {
+      throw new Error('缺少要执行的命令。')
+    }
+
+    const cwd = String(session?.cwd || '').trim()
+    const { executable, args, displayCommand } = getShellCommand(command)
+    if (!executable) {
+      throw new Error('当前环境没有可用的 shell。')
+    }
+
+    const onEvent = typeof callbacks.onEvent === 'function' ? callbacks.onEvent : () => {}
+    const child = spawn(executable, args, createManagedSpawnOptions({ cwd }))
+    let stdoutBuffer = ''
+    let stderrBuffer = ''
+    let outputTail = ''
+    let settled = false
+
+    onEvent(createAgentEventEnvelopeEvent(createItemStartedEvent(createCommandItem(displayCommand, 'running'))))
+
+    const result = new Promise((resolve, reject) => {
+      const rejectWithOutput = (message, payload = {}) => {
+        const error = new Error(String(message || '命令执行失败。'))
+        error.output = String(payload.output || outputTail || '').trim()
+        error.exitCode = typeof payload.exitCode === 'number' ? payload.exitCode : null
+        reject(error)
+      }
+
+      const flushStdout = (buffer, force = false) => {
+        const { lines, rest } = splitBufferedLines(buffer)
+        lines.forEach((line) => {
+          onEvent(createStdoutEnvelopeEvent(line))
+          outputTail = appendOutputTail(outputTail, `${line}\n`)
+        })
+        if (force && rest) {
+          onEvent(createStdoutEnvelopeEvent(rest))
+          outputTail = appendOutputTail(outputTail, `${rest}\n`)
+          return ''
+        }
+        return rest
+      }
+
+      const flushStderr = (buffer, force = false) => {
+        const { lines, rest } = splitBufferedLines(buffer)
+        lines.forEach((line) => {
+          onEvent(createStderrEnvelopeEvent(line))
+          outputTail = appendOutputTail(outputTail, `${line}\n`)
+        })
+        if (force && rest) {
+          onEvent(createStderrEnvelopeEvent(rest))
+          outputTail = appendOutputTail(outputTail, `${rest}\n`)
+          return ''
+        }
+        return rest
+      }
+
+      child.stdout?.on('data', (chunk) => {
+        stdoutBuffer += chunk.toString()
+        stdoutBuffer = flushStdout(stdoutBuffer)
+      })
+
+      child.stderr?.on('data', (chunk) => {
+        stderrBuffer += chunk.toString()
+        stderrBuffer = flushStderr(stderrBuffer)
+      })
+
+      child.once('error', (error) => {
+        if (settled) {
+          return
+        }
+        settled = true
+        stdoutBuffer = flushStdout(stdoutBuffer, true)
+        stderrBuffer = flushStderr(stderrBuffer, true)
+        const finalOutput = String(outputTail || '').trim()
+        onEvent(createAgentEventEnvelopeEvent(createItemCompletedEvent(createCommandItem(
+          displayCommand,
+          'failed',
+          finalOutput,
+          1
+        ))))
+        rejectWithOutput(error?.message || '命令启动失败。', {
+          output: finalOutput,
+          exitCode: 1,
+        })
+      })
+
+      child.once('close', (code, signal) => {
+        if (settled) {
+          return
+        }
+        settled = true
+        stdoutBuffer = flushStdout(stdoutBuffer, true)
+        stderrBuffer = flushStderr(stderrBuffer, true)
+        const exitCode = Number.isInteger(code) ? code : (signal ? 1 : 0)
+        const finalOutput = String(outputTail || '').trim()
+        const success = exitCode === 0
+
+        onEvent(createAgentEventEnvelopeEvent(createItemCompletedEvent(createCommandItem(
+          displayCommand,
+          success ? 'completed' : 'failed',
+          finalOutput,
+          exitCode
+        ))))
+
+        if (success) {
+          const message = finalOutput || `命令执行完成：${command}`
+          onEvent(createCompletedEnvelopeEvent(message))
+          resolve({
+            sessionId: String(session?.id || '').trim(),
+            threadId: '',
+            message,
+          })
+          return
+        }
+
+        rejectWithOutput(`命令执行失败(exit ${exitCode})`, {
+          output: finalOutput,
+          exitCode,
+        })
+      })
+    })
+
+    return {
+      child,
+      result,
+      cancel(options = {}) {
+        forceStopChildProcess(child, options)
+      },
+    }
+  },
+}