@boostkit-dsh/kunpeng-execution 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.2.1 - 2026-09-22
+
+- 首次发布前将包名统一为 `@boostkit-dsh/kunpeng-execution`，去掉 scope 下重复的 `plugin-` 前缀。
+- 将 DSH 精确兼容基线升级为 `0.1.7-alpha.1`，并同步鉴权依赖到 `@boostkit-dsh/auth-management@0.1.1`。
+
+## 0.2.0 - 2026-09-22
+
+- 对鉴权与审计管理增加精确硬依赖，Agent 工具的读取和执行动作要求有效 GitCode ActorRef。
+- 运行与取消写入最小化本地审计事件，保留原有远程执行人工审批。
+
+## 0.1.0 - 2026-09-20
+
+- 提供 `ctx.kunpengExecution` Host 服务：环境注册表（remote-ssh / local / mock）、配方、run/cancel、同环境互斥，以及 `kunpeng-execution/state` 与 `kunpeng-execution/log` 事件。
+- 提供 `kunpeng_execution` Agent 工具（`run` 动作执行前需 danger-full-access 审批）。
+- remote-ssh Provider 把 `omnioperator-remote-build` Skill 插件化：密钥认证 + 系统 `ssh`（BatchMode），代码同步优先 `rsync`、无 rsync 时退化 `tar` 流管道；`build`/`ut`/`sysinfo` 默认配方自 Skill `config.ini` 原样移植。
+- local Provider 用平台 shell 执行配方；mock Provider 产出带 `[SIMULATED]` 标记的模拟结果，证据 `simulated: true`。
+- 执行证据按 `plugins/job-workbench/contract.md` 生成（schema `kunpeng-execution-evidence@1`）：退出码、耗时、GTest 统计、`BENCH` 性能行与尾部日志摘录。

package/README.md

@@ -0,0 +1,58 @@
+# 鲲鹏执行（Kunpeng Execution）
+
+DSH 支撑插件：管理鲲鹏执行环境与配方，执行构建、单元测试和 benchmark，产出结构化执行证据（`plugins/job-workbench/contract.md`）。本插件把 `omnioperator-remote-build` Skill 的远程构建能力（SSH 同步 + 远程编译/UT）插件化，供业务插件程序化消费，也提供 Agent 工具直接调用。
+
+- Host 服务：`ctx.kunpengExecution`（`listEnvironments` / `listRecipes` / `run` / `cancel`）
+- Agent 工具：`kunpeng_execution`（run 动作执行前需用户审批）
+- 事件：`kunpeng-execution/state`、`kunpeng-execution/log`（业务插件 `ctx.on` 订阅）
+
+`0.2.0` 起要求 GitCode 鉴权；当前版本精确依赖 `@boostkit-dsh/auth-management@0.1.1`。Agent 工具的环境/配方读取、run 和 cancel 都先验证当前 GitCode ActorRef；run 与 cancel 记录最小化审计，run 原有的 danger-full-access 人工审批仍然保留。
+
+## 执行环境
+
+| provider | 说明 |
+| --- | --- |
+| `remote-ssh` | 真实远程鲲鹏服务器：密钥认证 + 系统 `ssh`；同步优先 `rsync`，无 rsync（Windows）时退化为 `tar` 流管道 |
+| `local` | 本机 shell 执行配方（`shell: true`），用于本地构建/测试 |
+| `mock` | 模拟环境：输出全部带 `[SIMULATED]` 前缀，证据 `simulated: true`，不与真实结果混淆 |
+
+## 首次使用（SSH 密钥配置）
+
+本插件只支持密钥认证（`BatchMode=yes`，等价于 Skill 的 `--setup-key` 推荐路径，跨平台且凭据不落盘）：
+
+```bash
+# 1. 生成专用密钥（无口令，或加载进 ssh-agent）
+ssh-keygen -t ed25519 -f ~/.ssh/kunpeng_exec -N ""
+
+# 2. 把公钥安装到远程服务器（macOS/Linux）
+ssh-copy-id -i ~/.ssh/kunpeng_exec.pub -p <port> <user>@<host>
+
+# 3. 在 DSH 插件 config（或用户层 cordis.patch.yml）中填写
+#    host / user / port / identityFile=~/.ssh/kunpeng_exec
+```
+
+Windows 第 2 步可用：`type $env:USERPROFILE\.ssh\kunpeng_exec.pub | ssh -p <port> <user>@<host> "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"`。
+
+配置完成后用 `sysinfo` 配方验证连通性，再跑 `build` / `ut`。
+
+## 配方
+
+默认配方移植自 Skill 的 `config.ini`：`build`（OmniOperator + Gluten 编译，默认先同步）、`ut`（omtest 全量单元测试）、`sysinfo`（系统信息/连通性验证）、`benchmark`（通用模板，见下）。环境可在插件 config 中按 id 覆盖或新增配方。
+
+benchmark 约定：命令输出 `BENCH <name> <value> <unit>` 行，解析为结构化性能数据。默认 benchmark 配方只打印配置指引、不产出任何数据行（避免模板数字被当作真实结果）；请在 config 中替换为项目真实的 benchmark 命令。
+
+## 注意事项
+
+- **取消语义**：`cancel` 终止本地 ssh/rsync/tar 进程链；远程命令未用 nohup，随 SSH 会话一同终止。
+- **同步删除**：`rsync --delete` 默认关闭；确需镜像删除时在环境 `sync.deleteMode` 显式开启（tar 模式不支持删除）。
+- **同环境互斥**：一个环境同时只允许一个活动 run，重复请求返回 `busy`。
+- **密钥安全**：命令行只包含 host/user/密钥路径；证据日志仅保留输出尾部 16 KiB，不含凭据。
+- 模拟环境的证据 `simulated: true` 且首行 `[SIMULATED]`，SPEC 引用时必须保留模拟标记。
+
+## 开发
+
+```bash
+npm test   # 等价 node --test test/*.test.mjs
+```
+
+开发计划见仓库 `docs/kunpeng-execution-dev-plan.md`。

package/cordis.patch.yml

@@ -0,0 +1,38 @@
+# 鲲鹏执行：环境、配方与结构化执行证据服务（host 服务 + Agent 工具两个入口）。
+- insert:
+    - id: kunpeng-execution
+      name: '@boostkit-dsh/kunpeng-execution'
+      config:
+        environments:
+          # 真实远程环境：填好 host/user/identityFile 后即可使用（密钥认证，BatchMode）。
+          - id: omnioperator
+            provider: remote-ssh
+            displayName: 鲲鹏 OmniOperator 远程环境
+            host: ''
+            user: ''
+            port: 22
+            identityFile: ''
+            remoteArch: aarch64
+            sync:
+              targetPath: /home/omni/
+              exclude:
+                - .git
+                - build
+                - dist
+                - target
+                - node_modules
+                - .dsh
+                - .agents
+                - .vscode
+                - .idea
+                - .DS_Store
+                - '*.log'
+          # 模拟环境：输出全部带 [SIMULATED] 标记，证据 simulated: true。
+          - id: mock
+            provider: mock
+            displayName: 模拟鲲鹏环境（明确标记）
+            remoteArch: simulated
+
+    # Agent 工具半区：kunpeng_execution（run 动作前需用户审批）。
+    - id: tool-kunpeng-execution
+      name: '@boostkit-dsh/kunpeng-execution/tools'

package/evidence.js

@@ -0,0 +1,37 @@
+// ExecutionEvidence 组装。契约定义见 plugins/job-workbench/contract.md（§2.0 执行侧）。
+
+export const EVIDENCE_SCHEMA = 'kunpeng-execution-evidence@1'
+export const LOG_TAIL_BYTES = 16_384
+const EMPTY_PARSED = {}
+
+/** Keep the trailing slice of `text`, bounded by bytes (UTF-8 aware). */
+export function tailText(text, maxBytes = LOG_TAIL_BYTES) {
+  const buffer = Buffer.from(text, 'utf8')
+  if (buffer.length <= maxBytes) return text
+  return buffer.subarray(buffer.length - maxBytes).toString('utf8')
+}
+
+/**
+ * Build one execution evidence document.
+ * All fields are plain JSON; `simulated` must be true for mock provider runs.
+ */
+export function buildEvidence({ runId, startedAt, finishedAt, environment, recipe, status, exitCode, durationMs, parsed, simulated, logText }) {
+  return {
+    schema: EVIDENCE_SCHEMA,
+    runId,
+    startedAt: startedAt.toISOString(),
+    finishedAt: finishedAt.toISOString(),
+    environment: {
+      id: environment.id,
+      provider: environment.provider,
+      host: environment.provider === 'remote-ssh' ? environment.host : '',
+      arch: environment.remoteArch ?? '',
+      label: environment.displayName ?? environment.id,
+    },
+    recipe: { id: recipe.id, kind: recipe.kind, command: recipe.command },
+    result: { status, exitCode, durationMs },
+    parsed: parsed ?? EMPTY_PARSED,
+    simulated: simulated === true,
+    logExcerpt: { tailBytes: LOG_TAIL_BYTES, text: tailText(logText ?? '') },
+  }
+}

package/index.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import { createExecutionService } from './service.js'
+
+export const name = 'kunpeng-execution'
+export const inject = ['authManagement']
+
+/** Match the filesystem Skill provider's upward `.git` project-root discovery. */
+function dshProjectRoot(cwd) {
+  let current = cwd
+  while (true) {
+    if (existsSync(join(current, '.git'))) return current
+    const parent = dirname(current)
+    if (parent === current) return cwd
+    current = parent
+  }
+}
+
+/** Resolve a workspace id (or the single registered workspace) to a project root. */
+function resolveWorkspaceRoot(ctx, workspaceId) {
+  let registry
+  try { registry = ctx.get?.('workspaceRegistry') } catch { registry = undefined }
+  if (typeof workspaceId === 'string' && workspaceId !== '') {
+    const workspace = registry?.get?.(workspaceId)
+    if (workspace === undefined || typeof workspace.path !== 'string') throw new Error(`所选 DSH 工作区不存在：${workspaceId}`)
+    return dshProjectRoot(workspace.path)
+  }
+  const workspaces = registry?.list?.()
+  if (Array.isArray(workspaces) && workspaces.length === 1 && typeof workspaces[0]?.path === 'string') return dshProjectRoot(workspaces[0].path)
+  return null
+}
+
+/** Register the kunpeng execution service, host events and lifecycle cleanup. */
+export function apply(ctx, config = {}) {
+  const auth = ctx.get?.('authManagement') ?? ctx.authManagement
+  if (auth === undefined) throw new Error('kunpeng-execution 需要 authManagement 服务')
+  const service = createExecutionService({
+    environments: config.environments,
+    emit: (event, payload) => { if (typeof ctx.emit === 'function') ctx.emit(event, payload) },
+    resolveWorkspaceRoot: (workspaceId) => resolveWorkspaceRoot(ctx, workspaceId),
+  })
+  ctx.provide('kunpengExecution', service)
+  ctx.effect?.(() => () => service.dispose(), 'kunpeng-execution.dispose')
+}
+
+export const __testing = { dshProjectRoot, resolveWorkspaceRoot }

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@boostkit-dsh/kunpeng-execution",
+  "version": "0.2.1",
+  "type": "module",
+  "description": "鲲鹏执行环境、配方与结构化执行证据服务（本地、SSH 远程与明确标记的模拟 Provider）",
+  "main": "index.js",
+  "files": [
+    "CHANGELOG.md",
+    "README.md",
+    "cordis.patch.yml",
+    "evidence.js",
+    "index.js",
+    "parsers.js",
+    "providers.js",
+    "recipes.js",
+    "service.js",
+    "ssh.js",
+    "tool-impl.js",
+    "tools.js"
+  ],
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitcode.com/lujinxing/kunpeng-dsh-demo.git",
+    "directory": "plugins/kunpeng-execution"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./tools": "./tools.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@boostkit-dsh/auth-management": "0.1.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "market": {
+      "displayName": {
+        "zh": "鲲鹏执行",
+        "en": "Kunpeng Execution"
+      },
+      "category": "kunpeng-rd",
+      "maintainers": [
+        "@lujinxing"
+      ],
+      "compatibility": {
+        "dsh": "0.1.7-alpha.1"
+      },
+      "allowedBuilds": []
+    }
+  }
+}

package/parsers.js

@@ -0,0 +1,30 @@
+// 远程输出解析：编译耗时（skill 的“编译耗时: N 秒”约定）、GTest/omtest 汇总行、
+// BENCHMARK 约定为命令输出 `BENCH <name> <value> <unit>` 行。
+
+const COMPILE_TIME_RE = /编译耗时[:：]\s*(\d+)\s*秒/
+const GTEST_TOTAL_RE = /\[==========\]\s+(?:Running\s+)?(\d+)\s+tests?/
+const GTEST_PASSED_RE = /\[\s*PASSED\s*\]\s+(\d+)\s+tests?/
+const GTEST_FAILED_RE = /\[\s*FAILED\s*\]\s+(\d+)\s+tests?/
+const GTEST_SKIPPED_RE = /\[\s*SKIPPED\s*\]\s+(\d+)\s+tests?/
+const BENCH_LINE_RE = /^BENCH\s+(\S+)\s+(-?\d+(?:\.\d+)?)\s+(\S+)\s*$/gm
+
+/** Parse command output according to the recipe parse mode. Returns evidence `parsed` fields. */
+export function parseOutput(mode, text) {
+  if (mode === 'compile-time') {
+    const match = COMPILE_TIME_RE.exec(text)
+    return match === null ? {} : { compileTimeMs: Number(match[1]) * 1000 }
+  }
+  if (mode === 'gtest') {
+    const total = GTEST_TOTAL_RE.exec(text)?.[1]
+    const passed = GTEST_PASSED_RE.exec(text)?.[1]
+    const failed = GTEST_FAILED_RE.exec(text)?.[1]
+    const skipped = GTEST_SKIPPED_RE.exec(text)?.[1]
+    if (total === undefined && passed === undefined && failed === undefined) return {}
+    return { tests: { total: Number(total ?? 0), passed: Number(passed ?? 0), failed: Number(failed ?? 0), skipped: Number(skipped ?? 0) } }
+  }
+  if (mode === 'benchmark') {
+    const benchmark = [...text.matchAll(BENCH_LINE_RE)].map((match) => ({ name: match[1], value: Number(match[2]), unit: match[3] }))
+    return benchmark.length === 0 ? {} : { benchmark }
+  }
+  return {}
+}

package/providers.js

@@ -0,0 +1,122 @@
+// 三个执行 Provider：remote-ssh（真实远程）、local（本机 shell）、mock（明确标记的模拟）。
+// Provider 接口：prepare({sourcePath, signal, onLog})?（同步）与 execute({recipe, cwd, signal, onLog})。
+
+import { spawn as spawnChild } from 'node:child_process'
+
+import { createSshTransport } from './ssh.js'
+
+const SIMULATED_PREFIX = '[SIMULATED]'
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+/** Remote provider: sync (optional) and exec over the ssh transport. */
+export function createRemoteSshProvider(environment, { transport }) {
+  const ssh = transport ?? createSshTransport()
+  return {
+    simulated: false,
+    async prepare({ sourcePath, signal, onLog }) {
+      const result = await ssh.sync(environment, {
+        sourcePath,
+        deleteMode: environment.sync?.deleteMode === true,
+        signal,
+        onOutput: onLog,
+      })
+      return { exitCode: result.exitCode }
+    },
+    async execute({ recipe, signal, onLog }) {
+      const result = await ssh.exec(environment, recipe.command, { signal, onOutput: onLog })
+      return { exitCode: result.exitCode }
+    },
+  }
+}
+
+const LOCAL_KILL_GRACE_MS = 5_000
+
+/**
+ * Kill a local shell command together with its children. `shell: true` spawns a
+ * shell whose grandchildren keep the stdio pipes open, so killing only the shell
+ * never surfaces a `close`; kill the whole process group instead (taskkill /T on
+ * Windows).
+ */
+function killLocalTree(child) {
+  if (typeof child.pid !== 'number') { child.kill('SIGTERM'); return }
+  if (process.platform === 'win32') {
+    spawnChild('taskkill', ['/pid', String(child.pid), '/T', '/F'])
+    return
+  }
+  try { process.kill(-child.pid, 'SIGTERM') } catch { child.kill('SIGTERM') }
+  const killer = setTimeout(() => {
+    try { process.kill(-child.pid, 'SIGKILL') } catch { child.kill('SIGKILL') }
+  }, LOCAL_KILL_GRACE_MS)
+  killer.unref?.()
+}
+
+/** Local provider: run the recipe command through the platform shell. */
+export function createLocalProvider() {
+  return {
+    simulated: false,
+    async execute({ recipe, cwd, signal, onLog }) {
+      return new Promise((resolve, reject) => {
+        const child = spawnChild(recipe.command, { shell: true, cwd: cwd ?? undefined, detached: process.platform !== 'win32' })
+        const onAbort = () => killLocalTree(child)
+        if (signal?.aborted) onAbort()
+        else signal?.addEventListener('abort', onAbort, { once: true })
+        child.stdout?.on('data', (chunk) => onLog?.({ stream: 'stdout', text: chunk.toString('utf8') }))
+        child.stderr?.on('data', (chunk) => onLog?.({ stream: 'stderr', text: chunk.toString('utf8') }))
+        child.on('error', (error) => {
+          signal?.removeEventListener?.('abort', onAbort)
+          reject(Object.assign(new Error(`本地执行失败：${error.message}`), { code: 'spawn-error' }))
+        })
+        child.on('close', (exitCode) => {
+          signal?.removeEventListener?.('abort', onAbort)
+          resolve({ exitCode })
+        })
+      })
+    },
+  }
+}
+
+/** Simulated output lines for the mock provider, per recipe parse mode. */
+export function mockOutputLines(recipe) {
+  if (recipe.parse === 'compile-time') {
+    return [
+      `${SIMULATED_PREFIX} 模拟鲲鹏编译——非真实执行结果`,
+      `${SIMULATED_PREFIX} [ 50%] Building CXX object core/CMakeFiles/omniop.dir/ops/expr.cpp.o`,
+      '编译耗时: 42 秒',
+    ]
+  }
+  if (recipe.parse === 'gtest') {
+    return [
+      `${SIMULATED_PREFIX} 模拟鲲鹏单元测试——非真实执行结果`,
+      '[==========] Running 128 tests from 12 test suites.',
+      '[==========] 128 tests from 12 test suites ran. (35621 ms total)',
+      '[  PASSED  ] 126 tests.',
+      '[  FAILED  ] 2 tests, listed below:',
+    ]
+  }
+  if (recipe.parse === 'benchmark') {
+    return [
+      `${SIMULATED_PREFIX} 模拟 benchmark——非真实执行结果`,
+      'BENCH simulated-throughput 1250.5 ops/s',
+    ]
+  }
+  return [`${SIMULATED_PREFIX} 模拟输出——非真实执行结果`]
+}
+
+/** Mock provider: deterministic simulated output through the same parse pipeline. */
+export function createMockProvider({ delayMs = 1 } = {}) {
+  return {
+    simulated: true,
+    async prepare({ onLog }) {
+      onLog?.({ stream: 'stdout', text: `${SIMULATED_PREFIX} 模拟代码同步——非真实执行结果\n` })
+      return { exitCode: 0 }
+    },
+    async execute({ recipe, signal, onLog }) {
+      for (const line of mockOutputLines(recipe)) {
+        signal?.throwIfAborted()
+        if (delayMs > 0) await sleep(delayMs)
+        onLog?.({ stream: 'stdout', text: `${line}\n` })
+      }
+      return { exitCode: 0 }
+    },
+  }
+}

package/recipes.js

@@ -0,0 +1,109 @@
+// 配方模型与默认配方。build/ut/sysinfo 的命令自 omnioperator-remote-build Skill
+// 的 config.ini（task_compile/task_ut/task_sysinfo）原样移植，保持远程端语义不变。
+
+export const RECIPE_KINDS = ['build', 'test', 'benchmark', 'info']
+export const PARSE_MODES = ['compile-time', 'gtest', 'benchmark', 'raw']
+
+export const DEFAULT_RECIPES = [
+  {
+    id: 'build',
+    kind: 'build',
+    parse: 'compile-time',
+    timeoutMs: 3_600_000,
+    syncBefore: true,
+    command: [
+      'set -ex',
+      'start_time=$(date +%s)',
+      'export CMAKE_MODULE_PATH=',
+      'export OMNI_HOME=/home/omni/omni-operator',
+      'export LD_LIBRARY_PATH=/$OMNI_HOME/lib:/usr/local/lib:/usr/local/lib64:$LD_LIBRARY_PATH',
+      'export LIBRARY_PATH=$LD_LIBRARY_PATH',
+      'export omni_spark_version=spark-3.5',
+      'export CPLUS_INCLUDE_PATH=/usr/local/include/orc:/usr/local/include:$CPLUS_INCLUDE_PATH',
+      'export C_INCLUDE_PATH=$CPLUS_INCLUDE_PATH',
+      'work_dir=/home/omni',
+      'JIT_HOME=$work_dir/OmniOperator',
+      'GLUTEN_HOME=$work_dir/Gluten',
+      'cd $work_dir',
+      'rm $OMNI_HOME/lib/libboostkit-omniop-* -rf',
+      'rm $OMNI_HOME/lib/include -rf',
+      'rm $OMNI_HOME/lib/boostkit-omniop-* -rf',
+      'cd $JIT_HOME',
+      'bash build_scripts/build.sh release:java',
+      'cd $JIT_HOME/bindings/java',
+      'mvn clean install -Ddep.os.arch=aarch64 -DskipTests',
+      'end_time=$(date +%s)',
+      'compile_time=$(($end_time - $start_time))',
+      'echo "编译耗时: $compile_time 秒"',
+    ].join('; '),
+  },
+  {
+    id: 'ut',
+    kind: 'test',
+    parse: 'gtest',
+    timeoutMs: 1_800_000,
+    syncBefore: false,
+    command: [
+      'set -ex',
+      'export CMAKE_MODULE_PATH=',
+      'export OMNI_HOME=/home/omni/omni-operator',
+      'export LD_LIBRARY_PATH=/$OMNI_HOME/lib:/usr/local/lib:/usr/local/lib64:$LD_LIBRARY_PATH',
+      'export LIBRARY_PATH=$LD_LIBRARY_PATH',
+      'export omni_spark_version=spark-3.5',
+      'export CPLUS_INCLUDE_PATH=/usr/local/include/orc:/usr/local/include:$CPLUS_INCLUDE_PATH',
+      'export C_INCLUDE_PATH=$CPLUS_INCLUDE_PATH',
+      'work_dir=/home/omni',
+      'JIT_HOME=$work_dir/OmniOperator',
+      'GLUTEN_HOME=$work_dir/Gluten',
+      'cd $work_dir',
+      './OmniOperator/build/core/test/omtest',
+    ].join('; '),
+  },
+  {
+    id: 'sysinfo',
+    kind: 'info',
+    parse: 'raw',
+    timeoutMs: 30_000,
+    syncBefore: false,
+    command: 'echo "=== 系统信息 ===" && hostname && whoami && date && uptime',
+  },
+  {
+    id: 'benchmark',
+    kind: 'benchmark',
+    parse: 'benchmark',
+    timeoutMs: 1_800_000,
+    syncBefore: false,
+    // 通用模板：只打印指引，不产出任何 BENCH 数据行（避免模板数字被当成真实结果）。
+    // 项目真实的 benchmark 命令在插件 config 中按 id 覆盖，输出 `BENCH <name> <value> <unit>` 行。
+    command: 'echo "benchmark 配方未配置：请在插件 config 中覆盖 id 为 benchmark 的配方命令，并让命令输出 BENCH <name> <value> <unit> 行"',
+  },
+]
+
+/** Validate one recipe definition, returning a normalized copy. */
+export function normalizeRecipe(recipe) {
+  if (recipe === null || typeof recipe !== 'object') throw new Error('配方定义必须是对象')
+  if (typeof recipe.id !== 'string' || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(recipe.id)) throw new Error(`配方 id 非法：${recipe.id}`)
+  if (typeof recipe.command !== 'string' || recipe.command.trim() === '') throw new Error(`配方 ${recipe.id} 缺少 command`)
+  const kind = recipe.kind ?? 'info'
+  if (!RECIPE_KINDS.includes(kind)) throw new Error(`配方 ${recipe.id} 的 kind 非法：${kind}`)
+  const parse = recipe.parse ?? 'raw'
+  if (!PARSE_MODES.includes(parse)) throw new Error(`配方 ${recipe.id} 的 parse 非法：${parse}`)
+  return {
+    id: recipe.id,
+    kind,
+    parse,
+    command: recipe.command,
+    timeoutMs: recipe.timeoutMs,
+    syncBefore: recipe.syncBefore,
+  }
+}
+
+/** Merge environment recipe overrides over the defaults (match by id, extras appended). */
+export function mergeRecipes(defaults, overrides) {
+  const merged = new Map(defaults.map((recipe) => [recipe.id, recipe]))
+  for (const override of overrides ?? []) {
+    const normalized = normalizeRecipe(override)
+    merged.set(normalized.id, normalized)
+  }
+  return [...merged.values()]
+}

package/service.js

@@ -0,0 +1,181 @@
+// kunpengExecution 服务：环境注册表、run/cancel、状态与日志事件、同环境互斥。
+// 事件：kunpeng-execution/state（syncing/running/parsing/succeeded/failed/cancelled/timeout）
+// 与 kunpeng-execution/log（流式输出块），业务插件经 ctx.on 消费。
+
+import { randomUUID } from 'node:crypto'
+
+import { buildEvidence } from './evidence.js'
+import { parseOutput } from './parsers.js'
+import { createLocalProvider, createMockProvider, createRemoteSshProvider } from './providers.js'
+import { DEFAULT_RECIPES, mergeRecipes } from './recipes.js'
+import { createSshTransport } from './ssh.js'
+
+const PROVIDERS = ['remote-ssh', 'local', 'mock']
+const DEFAULT_TIMEOUT_MS = 1_800_000
+const LOG_ACCUMULATE_CHARS = 1_000_000
+const ENVIRONMENT_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+
+function abortReason(kind, message) {
+  return Object.assign(new Error(message), { kind })
+}
+
+function statusFromSignal(signal) {
+  return signal?.reason?.kind === 'timeout' ? 'timeout' : 'cancelled'
+}
+
+/** Create the host execution service. All external effects are injectable for tests. */
+export function createExecutionService(options = {}) {
+  const emit = options.emit ?? (() => {})
+  const now = options.now ?? (() => new Date())
+  const transport = options.sshTransport ?? createSshTransport(options.sshSpawn ? { spawnImpl: options.sshSpawn } : {})
+  const environments = new Map()
+  const active = new Map()
+  const runs = new Map()
+
+  for (const environment of options.environments ?? []) registerEnvironment(environment)
+
+  function registerEnvironment(environment) {
+    if (environment === null || typeof environment !== 'object') throw new Error('执行环境必须是对象')
+    if (typeof environment.id !== 'string' || !ENVIRONMENT_ID_RE.test(environment.id)) throw new Error(`环境 id 非法：${environment.id}`)
+    if (!PROVIDERS.includes(environment.provider)) throw new Error(`环境 ${environment.id} 的 provider 非法：${environment.provider}`)
+    if (environments.has(environment.id)) throw new Error(`环境 id 重复：${environment.id}`)
+    environments.set(environment.id, { port: 22, ...environment, recipes: mergeRecipes(DEFAULT_RECIPES, environment.recipes) })
+  }
+
+  function providerFor(environment) {
+    if (environment.provider === 'remote-ssh') return createRemoteSshProvider(environment, { transport })
+    if (environment.provider === 'local') return createLocalProvider()
+    return createMockProvider()
+  }
+
+  function listEnvironments() {
+    return [...environments.values()].map((environment) => ({
+      id: environment.id,
+      provider: environment.provider,
+      displayName: environment.displayName ?? environment.id,
+      host: environment.provider === 'remote-ssh' ? environment.host : '',
+      configured: environment.provider !== 'remote-ssh' || (typeof environment.host === 'string' && environment.host !== '' && typeof environment.user === 'string' && environment.user !== ''),
+      activeRunId: active.get(environment.id) ?? null,
+    }))
+  }
+
+  function listRecipes(environmentId) {
+    const environment = environments.get(environmentId)
+    if (environment === undefined) throw new Error(`未知执行环境：${environmentId}`)
+    return environment.recipes
+  }
+
+  function emitState(runId, environment, recipeId, state) {
+    emit('kunpeng-execution/state', { runId, environmentId: environment.id, recipeId, state })
+  }
+
+  function appendLog(current, text) {
+    const merged = current + text
+    return merged.length <= LOG_ACCUMULATE_CHARS ? merged : merged.slice(merged.length - LOG_ACCUMULATE_CHARS)
+  }
+
+  function settle(runId, environment, recipe, startedAt, status, exitCode, logText) {
+    const finishedAt = now()
+    emitState(runId, environment, recipe.id, 'parsing')
+    const parsed = parseOutput(recipe.parse, logText)
+    const evidence = buildEvidence({
+      runId, startedAt, finishedAt, environment, recipe,
+      status, exitCode,
+      durationMs: finishedAt - startedAt,
+      parsed,
+      simulated: environment.provider === 'mock',
+      logText,
+    })
+    emitState(runId, environment, recipe.id, status)
+    return evidence
+  }
+
+  function resolveRoot(workspaceId) {
+    const root = options.resolveWorkspaceRoot?.(workspaceId)
+    if (typeof root !== 'string' || root === '') {
+      throw new Error(workspaceId === null || workspaceId === undefined
+        ? '无法确定项目根：请在请求中提供 workspaceId，或保证 DSH 恰好登记了一个工作区'
+        : `无法解析工作区：${workspaceId}`)
+    }
+    return root
+  }
+
+  async function run(request) {
+    const environment = environments.get(request.environmentId)
+    if (environment === undefined) throw new Error(`未知执行环境：${request.environmentId}`)
+    if (environment.provider === 'remote-ssh' && (typeof environment.host !== 'string' || environment.host === '' || typeof environment.user !== 'string' || environment.user === '')) {
+      throw new Error(`环境 ${environment.id} 未配置 host/user（及可选 identityFile），请先在插件 config 中完成配置`)
+    }
+    const recipe = environment.recipes.find((candidate) => candidate.id === request.recipeId)
+    if (recipe === undefined) throw new Error(`环境 ${environment.id} 不存在配方：${request.recipeId}`)
+    if (active.has(environment.id)) {
+      throw Object.assign(new Error(`环境 ${environment.id} 正在执行 ${active.get(environment.id)}，请等待完成或先取消`), { code: 'busy' })
+    }
+    const runId = `run-${options.makeRunId?.() ?? randomUUID()}`
+    const controller = new AbortController()
+    active.set(environment.id, runId)
+    runs.set(runId, { environmentId: environment.id, controller })
+    return { runId, result: executeRun(runId, environment, recipe, request, controller) }
+  }
+
+  async function executeRun(runId, environment, recipe, request, controller) {
+    const { signal } = controller
+    let logText = ''
+    const onLog = (chunk) => {
+      logText = appendLog(logText, chunk.text)
+      emit('kunpeng-execution/log', { runId, environmentId: environment.id, recipeId: recipe.id, ...chunk })
+    }
+    const startedAt = now()
+    let timer = null
+    try {
+      const provider = providerFor(environment)
+      const projectRoot = request.workspaceId != null && request.workspaceId !== ''
+        ? resolveRoot(request.workspaceId)
+        : (options.resolveWorkspaceRoot?.(null) ?? null)
+      const sourcePath = environment.sync?.sourcePath ?? projectRoot
+      const doSync = request.sync ?? recipe.syncBefore ?? false
+      if (doSync) {
+        if (provider.prepare === undefined) throw new Error(`环境 ${environment.id} 不支持代码同步`)
+        if (environment.provider === 'remote-ssh' && (typeof sourcePath !== 'string' || sourcePath === '')) throw new Error('代码同步需要 workspaceId 或环境 sync.sourcePath')
+        emitState(runId, environment, recipe.id, 'syncing')
+        const syncResult = await provider.prepare({ sourcePath, signal, onLog })
+        if (syncResult.exitCode !== 0) return settle(runId, environment, recipe, startedAt, 'failed', syncResult.exitCode, logText)
+      }
+      emitState(runId, environment, recipe.id, 'running')
+      const timeoutMs = request.timeoutMs ?? recipe.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      timer = setTimeout(() => controller.abort(abortReason('timeout', '执行超时')), timeoutMs)
+      timer.unref?.()
+      const execResult = await provider.execute({ recipe, cwd: projectRoot, signal, onLog })
+      clearTimeout(timer)
+      timer = null
+      if (execResult.exitCode === 0) return settle(runId, environment, recipe, startedAt, 'succeeded', 0, logText)
+      if (execResult.exitCode != null) return settle(runId, environment, recipe, startedAt, 'failed', execResult.exitCode, logText)
+      return settle(runId, environment, recipe, startedAt, statusFromSignal(signal), null, logText)
+    } catch (error) {
+      if (timer !== null) clearTimeout(timer)
+      if (signal.aborted) {
+        const status = statusFromSignal(signal)
+        return settle(runId, environment, recipe, startedAt, status, null, `${logText}\n执行中止：${error.message}`)
+      }
+      return settle(runId, environment, recipe, startedAt, 'failed', null, `${logText}\n执行错误：${error.message}`)
+    } finally {
+      active.delete(environment.id)
+      runs.delete(runId)
+    }
+  }
+
+  function cancel(runId) {
+    const run = runs.get(runId)
+    if (run === undefined) return { status: 'not-found' }
+    run.controller.abort(abortReason('user', '用户取消'))
+    return { status: 'cancelled' }
+  }
+
+  function dispose() {
+    for (const run of runs.values()) run.controller.abort(abortReason('user', '服务释放'))
+    runs.clear()
+    active.clear()
+  }
+
+  return { listEnvironments, listRecipes, run, cancel, dispose }
+}

package/ssh.js

@@ -0,0 +1,127 @@
+// SSH CLI 封装：全部 spawn 使用数组参数（不经本地 shell），密钥认证 + BatchMode。
+// 同步优先 rsync（增量），本机无 rsync（典型为 Windows）时退化为 tar 流管道。
+
+import { spawn as spawnChild } from 'node:child_process'
+
+export const SSH_OPTION_ARGS = ['-o', 'StrictHostKeyChecking=accept-new', '-o', 'ConnectTimeout=10', '-o', 'BatchMode=yes']
+const KILL_GRACE_MS = 5_000
+
+/** Base ssh argv: shared options + port + identity + user@host destination. */
+export function sshBaseArgs(environment) {
+  const args = [...SSH_OPTION_ARGS, '-p', String(environment.port ?? 22)]
+  if (environment.identityFile) args.push('-i', environment.identityFile)
+  args.push(`${environment.user}@${environment.host}`)
+  return args
+}
+
+/** Wrap a command for remote login-shell execution (POSIX single-quote escaping). */
+export function remoteCommand(command) {
+  return `bash -l -c '${command.replace(/'/g, `'\\''`)}'`
+}
+
+/** The `-e` ssh command string rsync should use (mirrors sshBaseArgs options). */
+export function buildRsyncSshOption(environment) {
+  const parts = ['ssh', ...SSH_OPTION_ARGS, '-p', String(environment.port ?? 22)]
+  if (environment.identityFile) parts.push('-i', environment.identityFile)
+  return parts.join(' ')
+}
+
+/** rsync argv for an incremental sync (contents of `source` into `target`). */
+export function buildRsyncArgs(environment, { source, target, excludes = [], deleteMode = false }) {
+  const args = ['-az']
+  for (const pattern of excludes) args.push(`--exclude=${pattern}`)
+  if (deleteMode) args.push('--delete')
+  args.push('-e', buildRsyncSshOption(environment), `${source}/`, `${environment.user}@${environment.host}:${target}`)
+  return args
+}
+
+/** Local tar argv + remote extraction command for the no-rsync fallback. */
+export function buildTarSyncCommands(environment, { source, target, excludes = [] }) {
+  const tarArgs = ['-czf', '-']
+  for (const pattern of excludes) tarArgs.push('--exclude', pattern)
+  tarArgs.push('-C', source, '.')
+  const quotedTarget = target.replace(/'/g, `'\\''`)
+  return { tarArgs, remote: `mkdir -p '${quotedTarget}' && tar -xzf - -C '${quotedTarget}'` }
+}
+
+function killTree(child) {
+  if (child.killed) return
+  child.kill('SIGTERM')
+  const killer = setTimeout(() => child.kill('SIGKILL'), KILL_GRACE_MS)
+  killer.unref?.()
+}
+
+/** Run one process, streaming output through onOutput; resolves with its exit code. */
+function runProcess(spawnImpl, file, args, { signal, onOutput, stdin = 'ignore' }) {
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(file, args, { stdio: [stdin, 'pipe', 'pipe'] })
+    let spawnError = null
+    const onAbort = () => killTree(child)
+    if (signal?.aborted) onAbort()
+    else signal?.addEventListener('abort', onAbort, { once: true })
+    child.stdout?.on('data', (chunk) => onOutput?.({ stream: 'stdout', text: chunk.toString('utf8') }))
+    child.stderr?.on('data', (chunk) => onOutput?.({ stream: 'stderr', text: chunk.toString('utf8') }))
+    child.on('error', (error) => { spawnError = error })
+    child.on('close', (exitCode) => {
+      signal?.removeEventListener?.('abort', onAbort)
+      if (spawnError !== null) reject(Object.assign(new Error(`无法启动 ${file}：${spawnError.message}`), { code: 'spawn-error' }))
+      else resolve({ exitCode })
+    })
+  })
+}
+
+/** Create the ssh transport. `spawnImpl` is injectable for tests. */
+export function createSshTransport({ spawnImpl = spawnChild } = {}) {
+  let rsyncProbe = null
+  const hasRsync = () => {
+    if (rsyncProbe === null) {
+      rsyncProbe = runProcess(spawnImpl, 'rsync', ['--version'], {}).then(
+        ({ exitCode }) => exitCode === 0,
+        () => false,
+      )
+    }
+    return rsyncProbe
+  }
+
+  return {
+    hasRsync,
+
+    /** Execute one command on the remote host through a login shell. */
+    exec(environment, command, { signal, onOutput } = {}) {
+      return runProcess(spawnImpl, 'ssh', [...sshBaseArgs(environment), remoteCommand(command)], { signal, onOutput })
+    },
+
+    /** Sync a local directory to the remote target (rsync when available, else tar pipe). */
+    async sync(environment, { sourcePath, deleteMode = false, signal, onOutput }) {
+      if (await hasRsync()) {
+        const args = buildRsyncArgs(environment, { source: sourcePath, target: environment.sync.targetPath, excludes: environment.sync.exclude ?? [], deleteMode })
+        const result = await runProcess(spawnImpl, 'rsync', args, { signal, onOutput })
+        return { mode: 'rsync', exitCode: result.exitCode }
+      }
+      const { tarArgs, remote } = buildTarSyncCommands(environment, { source: sourcePath, target: environment.sync.targetPath, excludes: environment.sync.exclude ?? [] })
+      const tar = spawnImpl('tar', tarArgs, { stdio: ['ignore', 'pipe', 'pipe'] })
+      const ssh = spawnImpl('ssh', [...sshBaseArgs(environment), remote], { stdio: ['pipe', 'pipe', 'pipe'] })
+      let sshExit = null
+      let sshError = null
+      const onAbort = () => { killTree(tar); killTree(ssh) }
+      if (signal?.aborted) onAbort()
+      else signal?.addEventListener('abort', onAbort, { once: true })
+      ssh.stdout?.on('data', (chunk) => onOutput?.({ stream: 'stdout', text: chunk.toString('utf8') }))
+      ssh.stderr?.on('data', (chunk) => onOutput?.({ stream: 'stderr', text: chunk.toString('utf8') }))
+      tar.on('error', () => { ssh.stdin?.end?.() })
+      ssh.on('error', (error) => { sshError = error })
+      tar.stdout.on('data', (chunk) => ssh.stdin.write(chunk))
+      tar.stdout.on('end', () => ssh.stdin.end())
+      const sshClosed = new Promise((resolve) => ssh.on('close', (code) => { sshExit = code; resolve() }))
+      await sshClosed
+      signal?.removeEventListener?.('abort', onAbort)
+      if (sshError !== null) throw Object.assign(new Error(`无法启动 ssh：${sshError.message}`), { code: 'spawn-error' })
+      return { mode: 'tar', exitCode: sshExit }
+    },
+
+    /** Verify connectivity and key auth with a no-op remote command. */
+    testConnection(environment, { signal, onOutput } = {}) {
+      return this.exec(environment, 'true', { signal, onOutput })
+    },
+  }
+}

package/tool-impl.js

@@ -0,0 +1,66 @@
+// Agent 工具的动作逻辑（纯函数，不依赖 DSH 包，便于单测）。
+// 生产装配见 tools.js：defineTool 包装 + approveEscalation 审批。
+
+export const TOOL_NAME = 'kunpeng_execution'
+export const TOOL_ACTIONS = ['list_environments', 'list_recipes', 'run', 'cancel']
+
+export function toolParameters() {
+  return {
+    action: { type: 'string', required: true, enum: [...TOOL_ACTIONS], description: '执行操作。先 list_environments / list_recipes 获取标识。' },
+    environment: { type: 'string', description: '环境 id，list_recipes 与 run 必填。' },
+    recipe: { type: 'string', description: '配方 id，run 必填。' },
+    workspaceId: { type: 'string', description: 'DSH 工作区 id；代码同步与本地执行需要，远程不同步的配方可不填。' },
+    sync: { type: 'boolean', description: 'run 前强制同步代码；缺省用配方自身的 syncBefore 设置。' },
+    timeoutMs: { type: 'number', description: 'run 的超时毫秒数；缺省用配方默认值。' },
+    runId: { type: 'string', description: 'cancel 必填：要取消的运行 id。' },
+  }
+}
+
+function requireString(args, field) {
+  const value = args[field]
+  if (typeof value !== 'string' || value === '') throw new Error(`${args.action} 需要参数 ${field}`)
+  return value
+}
+
+/** Build the tool execute function over a kunpengExecution service. */
+export function createExecuteAction(service, { approve, authorize, audited } = {}) {
+  return async function executeToolAction(args) {
+    const action = args?.action
+    await authorize?.()
+    if (!TOOL_ACTIONS.includes(action)) throw new Error(`未知动作：${String(action)}`)
+    if (action === 'list_environments') {
+      return JSON.stringify({ environments: service.listEnvironments() }, null, 2)
+    }
+    if (action === 'list_recipes') {
+      const environmentId = requireString(args, 'environment')
+      return JSON.stringify({ recipes: service.listRecipes(environmentId) }, null, 2)
+    }
+    if (action === 'run') {
+      const environmentId = requireString(args, 'environment')
+      const recipeId = requireString(args, 'recipe')
+      await approve?.('鲲鹏执行', `kunpeng_execution run ${environmentId}/${recipeId}${args.sync === true ? '（含代码同步）' : ''}`)
+      const run = async () => {
+        const handle = await service.run({
+          environmentId,
+          recipeId,
+          workspaceId: args.workspaceId,
+          sync: args.sync,
+          timeoutMs: args.timeoutMs,
+        })
+        return handle.result
+      }
+      const event = {
+        action: 'kunpeng.run',
+        target: { type: 'recipe', id: `${environmentId}/${recipeId}` },
+        workspaceId: args.workspaceId,
+        outcome: (value) => value?.result?.status === 'succeeded' ? 'succeeded' : value?.result?.status === 'cancelled' ? 'cancelled' : 'failed',
+      }
+      const evidence = audited === undefined ? await run() : await audited(event, run)
+      return JSON.stringify(evidence, null, 2)
+    }
+    const runId = requireString(args, 'runId')
+    const cancel = async () => service.cancel(runId)
+    const result = audited === undefined ? await cancel() : await audited({ action: 'kunpeng.cancel', target: { type: 'run', id: runId } }, cancel)
+    return JSON.stringify(result)
+  }
+}

package/tools.js

@@ -0,0 +1,46 @@
+// Agent 工具半区：kunpeng_execution。挂载方式与 dsh-plugin-manager 的工具行一致
+// （cordis.patch.yml 中 '<pkg>/tools' 独立行）。run 动作影响远程服务器或本机，
+// 执行前须经 danger-full-access 审批（与 plugin_manager 工具同一模式）。
+
+import { approveEscalation } from '@deepseek-ai/dsh-sandbox'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+import { createExecuteAction, TOOL_NAME, toolParameters } from './tool-impl.js'
+
+/** Required services for the execution tool. */
+export const inject = ['tools', 'kunpengExecution', 'sandboxPolicy', 'authManagement']
+
+/** Register the kunpeng_execution agent tool. */
+export function apply(ctx) {
+  ctx.tools.register(defineTool({
+    name: TOOL_NAME,
+    description: '在鲲鹏执行环境上运行配方（远程 SSH 编译/单元测试/benchmark/系统信息，或本地、或明确标记的模拟环境），返回结构化执行证据。先 list_environments、list_recipes 获取可用标识；远程环境需在插件 config 中配置 host/user/identityFile。run 在真实环境执行命令并可能修改远程状态，每次调用都需要审批。',
+    parameters: toolParameters(),
+    output: {
+      schema: { type: 'string' },
+      render: (_args, value) => [{ type: 'text', text: value }],
+    },
+    async execute(args, exec) {
+      const policy = ctx.sandboxPolicy.resolve(exec.agent === undefined ? {} : { session: exec.agent.session })
+      const executeAction = createExecuteAction(ctx.kunpengExecution, {
+        authorize: () => ctx.authManagement.requireActor(),
+        audited: (event, task) => ctx.authManagement.executeAudited(event, task),
+        approve: async (subject, justification) => {
+          await approveEscalation({
+            requestedMode: 'danger-full-access',
+            effectiveMode: policy.mode,
+            subject,
+            justification,
+          }, {
+            approver: ctx.get('approval'),
+            agent: exec.agent,
+            callId: exec.callId,
+            toolName: TOOL_NAME,
+            signal: exec.signal,
+          })
+        },
+      })
+      return executeAction(args)
+    },
+  }))
+}