@capclaw/mcp-stdio 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# `@capclaw/mcp-stdio`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Official MCP `stdio` proxy and multi-host plugin installer for **CapClaw (开刻)** AI Video Editor (`https://www.capclaw.cn`).
+
+## Usage
+
+### 1. Run as an MCP `stdio` server (WorkBuddy / Claude Code / OpenAI Codex)
+
+```json
+{
+  "mcpServers": {
+    "capclaw-video-editor": {
+      "command": "npx",
+      "args": ["-y", "@capclaw/mcp-stdio"]
+    }
+  }
+}
+```
+
+### 2. Install DeepSeek Harness (`dsh`) Plugin & Skill
+
+```bash
+npx -y @capclaw/mcp-stdio --install-dsh
+```
+
+### 3. Install All 4 Host Plugins Locally (`codex`, `claude`, `workbuddy`, `dsh`)
+
+```bash
+npx -y @capclaw/mcp-stdio --install-all
+```

package/bin/capclaw-mcp-stdio.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * CapClaw MCP stdio-to-HTTP Bridge & Host Plugin CLI (Zero external dependencies).
+ *
+ * Used by stdio-based or auto-waking MCP hosts (Codex, Claude Code, WorkBuddy, dsh):
+ *   1. Reads ~/.capclaw/runtime.json to discover the active sidecar port (5600-5639).
+ *   2. Probes GET http://127.0.0.1:<port>/mcp/health.
+ *   3. If CapClaw is not running, spawns `CapClaw.exe --background` (detached, no window)
+ *      and polls up to 15 seconds until runtime.json and /mcp/health are ready.
+ *   4. Forwards newline-delimited JSON-RPC messages from stdin to POST http://127.0.0.1:<port>/mcp
+ *      and writes JSON-RPC responses back to stdout.
+ *
+ * CLI Installer flags:
+ *   npx -y @capclaw/mcp-stdio --install-dsh
+ *   npx -y @capclaw/mcp-stdio --install-workbuddy
+ *   npx -y @capclaw/mcp-stdio --install-claude
+ *   npx -y @capclaw/mcp-stdio --install-codex
+ *   npx -y @capclaw/mcp-stdio --install-all
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const DEFAULT_PORTS = Array.from({ length: 40 }, (_, i) => 5600 + i);
+
+function getRuntimeFilePath() {
+  if (process.env.CAPCLAW_RUNTIME_FILE) {
+    return path.resolve(process.env.CAPCLAW_RUNTIME_FILE);
+  }
+  const home = process.env.CAPCLAW_HOME || os.homedir();
+  return path.join(home, '.capclaw', 'runtime.json');
+}
+
+function readRuntimeFile() {
+  const filePath = getRuntimeFilePath();
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const data = JSON.parse(raw);
+    if (!data || typeof data.port !== 'number') return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+async function probeMcpHealth(port, timeoutMs = 1200) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/mcp/health`, {
+      method: 'GET',
+      signal: controller.signal,
+    });
+    if (!res.ok) return false;
+    const body = await res.json().catch(() => null);
+    return Boolean(body && body.ok);
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function findCandidateExePaths(lastKnownExePath = '') {
+  const candidates = [];
+  if (process.env.CAPCLAW_EXE_PATH) {
+    candidates.push(process.env.CAPCLAW_EXE_PATH);
+  }
+  if (lastKnownExePath) {
+    candidates.push(lastKnownExePath);
+  }
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+    candidates.push(
+      path.join(localAppData, 'Programs', 'capclaw', '开刻.exe'),
+      path.join(localAppData, 'Programs', 'capclaw', 'CapClaw.exe'),
+      path.join(localAppData, 'Programs', 'yuanyuan-client', '开刻.exe'),
+      path.join(programFiles, '开刻', '开刻.exe'),
+      path.join(programFiles, 'CapClaw', 'CapClaw.exe'),
+    );
+  } else if (process.platform === 'darwin') {
+    candidates.push(
+      '/Applications/开刻.app/Contents/MacOS/开刻',
+      '/Applications/CapClaw.app/Contents/MacOS/CapClaw',
+    );
+  }
+  return candidates.filter((p) => p && fs.existsSync(p));
+}
+
+async function discoverOrWakeSidecar() {
+  // 1. Check runtime.json first
+  const runtime = readRuntimeFile();
+  if (runtime && runtime.port && (await probeMcpHealth(runtime.port))) {
+    return { port: runtime.port, mcpEndpoint: `http://127.0.0.1:${runtime.port}/mcp` };
+  }
+
+  // 2. Scan first few ports in 5600..5639 in case runtime.json was stale
+  for (const port of DEFAULT_PORTS.slice(0, 8)) {
+    if (await probeMcpHealth(port, 400)) {
+      return { port, mcpEndpoint: `http://127.0.0.1:${port}/mcp` };
+    }
+  }
+
+  // 3. Auto-spawn CapClaw in background mode if executable is available
+  const exeCandidates = findCandidateExePaths(runtime?.exePath || '');
+  if (exeCandidates.length > 0 && process.env.CAPCLAW_DISABLE_AUTO_WAKE !== '1') {
+    const exePath = exeCandidates[0];
+    try {
+      const child = spawn(exePath, ['--background'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      child.unref();
+    } catch (err) {
+      process.stderr.write(`[capclaw-mcp-stdio] Failed to spawn ${exePath}: ${err.message}\n`);
+    }
+
+    const deadline = Date.now() + 15000;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 350));
+      const latest = readRuntimeFile();
+      if (latest && latest.port && (await probeMcpHealth(latest.port))) {
+        return { port: latest.port, mcpEndpoint: `http://127.0.0.1:${latest.port}/mcp` };
+      }
+    }
+  }
+
+  throw new Error(
+    '无法连接到开刻（CapClaw）本地服务。请先启动开刻桌面端（https://www.capclaw.cn），或设置 CAPCLAW_EXE_PATH 指向开刻可执行文件。',
+  );
+}
+
+let cachedEndpoint = null;
+let mcpSessionId = '';
+let mcpProtocolVersion = '2025-06-18';
+
+async function forwardJsonRpcLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (err) {
+    process.stdout.write(
+      `${JSON.stringify({
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32700, message: `Invalid JSON on stdin: ${err.message}` },
+      })}\n`,
+    );
+    return;
+  }
+
+  const isNotification = !Array.isArray(parsed) && parsed && parsed.id === undefined;
+
+  try {
+    if (!cachedEndpoint) {
+      cachedEndpoint = await discoverOrWakeSidecar();
+    }
+
+    let res;
+    try {
+      res = await fetch(cachedEndpoint.mcpEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(mcpSessionId ? { 'Mcp-Session-Id': mcpSessionId } : {}),
+          ...(mcpProtocolVersion ? { 'MCP-Protocol-Version': mcpProtocolVersion } : {}),
+        },
+        body: JSON.stringify(parsed),
+      });
+    } catch {
+      // Sidecar may have restarted on another port; rediscover once
+      cachedEndpoint = await discoverOrWakeSidecar();
+      res = await fetch(cachedEndpoint.mcpEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(mcpSessionId ? { 'Mcp-Session-Id': mcpSessionId } : {}),
+          ...(mcpProtocolVersion ? { 'MCP-Protocol-Version': mcpProtocolVersion } : {}),
+        },
+        body: JSON.stringify(parsed),
+      });
+    }
+
+    const respSession = res.headers.get('mcp-session-id');
+    if (respSession) mcpSessionId = respSession;
+    const respVersion = res.headers.get('mcp-protocol-version');
+    if (respVersion) mcpProtocolVersion = respVersion;
+
+    if (res.status === 202 || isNotification) {
+      return;
+    }
+
+    const text = await res.text();
+    if (text && text.trim()) {
+      process.stdout.write(`${text.trim()}\n`);
+    }
+  } catch (err) {
+    if (isNotification) return;
+    const id = !Array.isArray(parsed) && parsed ? parsed.id ?? null : null;
+    process.stdout.write(
+      `${JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        error: {
+          code: -32000,
+          message: err.message || String(err),
+        },
+      })}\n`,
+    );
+  }
+}
+
+export function startStdioBridge() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity,
+  });
+
+  let queue = Promise.resolve();
+  rl.on('line', (line) => {
+    queue = queue.then(() => forwardJsonRpcLine(line)).catch((err) => {
+      process.stderr.write(`[capclaw-mcp-stdio] Unexpected error: ${err.message}\n`);
+    });
+  });
+
+  rl.on('close', () => {
+    queue.finally(() => process.exit(0));
+  });
+}
+
+function handleCliInstallFlags(argv) {
+  const flagMap = {
+    '--install-dsh': 'dsh',
+    '--install-workbuddy': 'workbuddy',
+    '--install-claude': 'claude',
+    '--install-codex': 'codex',
+    '--install-all': 'all',
+  };
+  const matchedFlag = argv.find((arg) => Object.prototype.hasOwnProperty.call(flagMap, arg));
+  if (!matchedFlag) return false;
+
+  const require = createRequire(import.meta.url);
+  const { installHostPlugin, installAllHostPlugins } = require('../service/hostPluginInstaller.js');
+  const runtime = readRuntimeFile();
+  const port = runtime?.port || 5600;
+  const target = flagMap[matchedFlag];
+
+  const result = target === 'all'
+    ? installAllHostPlugins({ port })
+    : installHostPlugin(target, { port });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return true;
+}
+
+if (
+  import.meta.url === `file://${process.argv[1]?.replace(/\\/g, '/')}` ||
+  process.argv[1]?.endsWith('capclaw-mcp-stdio.mjs') ||
+  process.argv[1]?.endsWith('capclaw-mcp-stdio')
+) {
+  if (!handleCliInstallFlags(process.argv.slice(2))) {
+    startStdioBridge();
+  }
+}

package/bin/capclaw-plugin-install.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { installHostPlugin, installAllHostPlugins } = require('../service/hostPluginInstaller.js');
+
+const args = process.argv.slice(2);
+const hostArg = args.find((a) => !a.startsWith('-')) || 'all';
+
+const res = hostArg === 'all' ? installAllHostPlugins() : installHostPlugin(hostArg);
+process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);

package/host-plugins/claude/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "capclaw-video-editor",
+  "version": "1.0.0",
+  "description": "开刻（CapClaw）本地 AI 视频剪辑与画布编排插件（零拷贝素材导入、18 种确定性画布指令、宿主内置浏览器实时编辑、本地 WebCodecs 硬件加速合成导出）",
+  "author": {
+    "name": "CapClaw Team"
+  },
+  "skills": [
+    "./skills/capclaw-video-editor"
+  ],
+  "mcpServers": {
+    "capclaw-video-editor": {
+      "command": "node",
+      "args": [
+        "{{CAPCLAW_STDIO_PROXY_PATH}}"
+      ]
+    }
+  }
+}

package/host-plugins/claude/skills/capclaw-video-editor/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: capclaw-video-editor
+description: 使用开刻（CapClaw）本地视频剪辑引擎完成草稿管理、零拷贝本地素材导入、18 种确定性画布与时间线编辑、云端 AI 编排对话、宿主内置浏览器可视化精修及本地硬件加速视频合成导出。
+---
+
+# 开刻（CapClaw）Claude Code 视频剪辑技能
+
+通过 `capclaw-video-editor` MCP Server 提供的 7 个工具操作本地开刻视频草稿：
+
+1. **`manage_project`**：`list` / `get` / `create` / `rename` / `delete` 本地草稿。
+2. **`inspect_timeline`**：读取草稿画布尺寸与组件时间线详情。
+3. **`import_local_media`**：零拷贝导入本机视频/图片/音频文件（支持 `addToTimeline: true`）。
+4. **`apply_canvas_commands`**：执行 18 种公开画布指令（严禁调用内部指令 `ADD_ANNOTATION_RESULT` / `APPLY_WIDGET_VERSION` / `SWITCH_WIDGET_VERSION`）。
+5. **`ai_edit_turn`**：调用开刻云端 AI 画布助手将自然语言转换为画布指令并应用。
+6. **`open_in_editor`**：生成带一次性 `bootToken` Fragment 的 `editorUrl`，在 Claude Desktop 内置浏览器或本地桌面窗口中打开实时画布。
+7. **`export_video`**：触发已挂载前端执行本地 WebCodecs + FFmpeg 合成导出，返回 MP4 路径与 `fileUri`。
+
+## 操作守则
+
+- **先挂载后写画布/导出**：若 `inspect_timeline` 或 `manage_project` 显示 `mounted: false`，先调用 `open_in_editor` 在内置浏览器打开 `editorUrl`（或传 `autoOpenEditor: true`），待前端挂载就绪后再执行 `apply_canvas_commands` 或 `export_video`。
+- **导出防节流提示**：调用 `export_video` 时提醒用户保持编辑器面板可见，若遇 `CAPCLAW_SYNTHESIS_STALLED` 错误，恢复面板可见后重试即可。

package/host-plugins/codex/.codex-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "capclaw-video-editor",
+  "version": "1.0.0",
+  "description": "开刻（CapClaw）本地 AI 视频剪辑与画布编排插件（零拷贝素材导入、18 种确定性画布指令、宿主内置浏览器实时编辑、本地 WebCodecs 硬件加速合成导出）",
+  "author": "CapClaw Team",
+  "skills": [
+    "./skills/capclaw-video-editor"
+  ],
+  "mcpServers": {
+    "capclaw-video-editor": {
+      "command": "node",
+      "args": [
+        "{{CAPCLAW_STDIO_PROXY_PATH}}"
+      ]
+    }
+  }
+}

package/host-plugins/codex/skills/capclaw-video-editor/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: capclaw-video-editor
+description: 使用开刻（CapClaw）本地视频剪辑引擎完成草稿管理、零拷贝本地素材导入、18 种确定性画布与时间线编辑、云端 AI 编排对话、宿主内置浏览器可视化精修及本地硬件加速视频合成导出。当用户要求剪辑视频、配字幕、加转场/滤镜/特效/贴纸/BGM、切分或变速视频片段、或打开开刻编辑器时使用。
+---
+
+# 开刻（CapClaw）视频剪辑工作流指南
+
+开刻通过本机 Sidecar 提供 7 个正交 MCP 工具（服务名：`capclaw-video-editor`）：
+
+## 1. 7 个核心 MCP 工具
+
+1. **`manage_project`**：查询（`list` / `get`）、创建（`create`）、重命名（`rename`）、删除（`delete`）本地 PGlite 草稿（`Project`）。
+2. **`inspect_timeline`**：查看指定 `projectId` 的画布尺寸、总时长与全部轨道组件（若已在编辑器挂载则返回实时内存态，否则读取 PGlite）。
+3. **`import_local_media`**：通过零拷贝（symlink → hardlink → vlink）将本机视频/图片/音频文件秒级导入草稿，可选 `addToTimeline: true` 自动加入时间线。
+4. **`apply_canvas_commands`**：对已挂载草稿执行 **18 种公开确定性画布指令**（`UPDATE_WIDGET`, `ADD_WIDGET`, `DELETE_WIDGET`, `UPDATE_PAGE`, `REORDER_WIDGET`, `ADD_TRANSITION`, `ADD_GIF`, `ADD_FILTER`, `ADD_EFFECT`, `ADD_PARTICLE`, `ADD_AUDIO`, `BATCH_UPDATE`, `SET_ANIMATION`, `APPLY_EXISTING_ANIMATION`, `SPLIT_WIDGET`, `TRIM_WIDGET`, `SET_CLIP_SPEED`, `FREEZE_FRAME_SPLIT`）。
+5. **`ai_edit_turn`**：将自然语言编辑诉求发送给开刻云端 AI 画布助手，生成并自动应用画布指令。
+6. **`open_in_editor`**：签发一次性 60s 有效期的 `bootToken`（置于 URL Fragment `#capclawBridge=...&bootToken=...`），返回 `editorUrl` 与 `browserHandoff`。
+7. **`export_video`**：由已挂载的前端编辑器执行 WebCodecs + Pixi + FFmpeg 本地硬件加速合成导出，返回本地 MP4 路径与 `fileUri`。
+
+## 2. 「前端挂载即真源」黄金工作流
+
+开刻的画布状态更新（如 `SPLIT_WIDGET`、`TRIM_WIDGET`、`SET_CLIP_SPEED` 级联重排）与 WebCodecs 视频合成均由真实前端执行：
+
+1. **新建或选择草稿**：先调用 `manage_project(action="create" | "list")`。
+2. **挂载编辑器**：
+   - 在执行 `apply_canvas_commands`、`import_local_media(addToTimeline=true)`、`ai_edit_turn` 或 `export_video` 前，若目标 `projectId` 尚未挂载（`mounted: false`），请先调用 `open_in_editor` 并在宿主内置浏览器打开返回的 `editorUrl`（或在工具参数中传 `autoOpenEditor: true` 自动唤起桌面端窗口）。
+3. **导入素材与编辑**：
+   - 使用 `import_local_media` 导入本地素材；
+   - 使用 `apply_canvas_commands` 或 `ai_edit_turn` 精确调整组件、字幕、转场、动画与时间线切分。
+4. **导出成片**：
+   - 调用 `export_video({ projectId })`；导出期间请提醒用户**保持开刻编辑器面板处于可见状态**（避免 Chromium 后台节流 `requestAnimationFrame`）。

package/host-plugins/codex/skills/capclaw-video-editor/agents/openai.yaml

@@ -0,0 +1,9 @@
+interface:
+  display_name: "开刻 CapClaw 视频剪辑"
+  short_description: "使用开刻（CapClaw）在本地创建视频草稿、零拷贝导入素材、执行 18 种画布与时间线编辑指令，并在内置浏览器预览与导出 MP4。"
+  default_prompt: "使用开刻（CapClaw）帮我创建并剪辑一段视频草稿"
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "capclaw-video-editor"
+      description: "开刻本地 Sidecar MCP Server（7 个正交视频剪辑工具）"

package/host-plugins/dsh/cordis.patch.template.yml

@@ -0,0 +1,7 @@
+# DeepSeek Harness (dsh) Cordis MCP patch template for CapClaw
+# Target path: ~/.dsh/profiles/<profile>/cordis.patch.yml
+"@deepseek-ai/dsh-mcp-client":
+  servers:
+    capclaw-video-editor:
+      transport: streamable-http
+      url: "http://127.0.0.1:{{CAPCLAW_MCP_PORT}}/mcp"

package/host-plugins/dsh/skills/capclaw-video-editor/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: capclaw-video-editor
+description: 开刻（CapClaw）DeepSeek Harness (dsh) 本地视频剪辑技能。支持本地 PGlite 草稿管理、零拷贝素材导入、18 种确定性画布指令、云端 AI 编排对话以及唤起开刻桌面端窗口进行实时编辑与 WebCodecs 视频导出。
+---
+
+# 开刻（CapClaw）DeepSeek Harness (`dsh`) 视频剪辑指南
+
+## 1. 宿主特性说明（R1：桌面窗口挂载模式 E1）
+
+DeepSeek Harness (`dsh`) 为纯终端/Cordis 宿主，**不包含内置 WebView 浏览器**。因此：
+- 在需要执行画布指令（`apply_canvas_commands`、`import_local_media(addToTimeline=true)`、`ai_edit_turn`）或导出视频（`export_video`）时：
+  - 若目标 `projectId` 尚未挂载（`mounted: false`），请优先调用 `open_in_editor({ projectId, openDesktopWindow: true })`，或在调用编辑/导出工具时传入 `autoOpenEditor: true`，由开刻后台守护进程自动拉起本机桌面编辑器窗口（E1 模式）并等待挂载完成。
+  - 若本机未运行桌面窗口且未传 `autoOpenEditor: true`，工具将返回明确错误码 `CAPCLAW_EDITOR_NOT_MOUNTED`（不会静默降级到被 Chromium 节流的隐藏窗口）。
+
+## 2. 7 个正交 MCP 工具
+
+1. `manage_project`：`list` / `get` / `create` / `rename` / `delete` 本地草稿。
+2. `inspect_timeline`：查看草稿时间线与组件状态（未挂载时直接从 PGlite 读取，无需打开窗口）。
+3. `import_local_media`：零拷贝导入本地视频/图片/音频（仅导入素材库无需挂载窗口；若 `addToTimeline: true` 则需挂载窗口）。
+4. `apply_canvas_commands`：执行 18 种公开画布指令（可传 `autoOpenEditor: true`）。
+5. `ai_edit_turn`：调用云端 AI 画布助手生成并执行编辑指令（可传 `autoOpenEditor: true`）。
+6. `open_in_editor`：传 `openDesktopWindow: true` 直接唤起本机开刻桌面端窗口加载该草稿。
+7. `export_video`：触发已挂载的开刻桌面窗口执行本地 WebCodecs 合成导出（导出期间请保持开刻窗口未最小化）。

package/host-plugins/workbuddy/.codebuddy-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "capclaw-video-editor",
+  "version": "1.0.0",
+  "description": "开刻（CapClaw）本地 AI 视频剪辑专家插件：支持零拷贝素材导入、18 种确定性画布与时间线指令、WorkBuddy 内置浏览器实时可视化编辑及本地 WebCodecs 硬件加速视频合成导出。",
+  "author": {
+    "name": "CapClaw Team"
+  },
+  "categoryId": "06-ContentCreative",
+  "skills": [
+    "./skills/capclaw-video-editor"
+  ],
+  "agents": [
+    "./agents"
+  ],
+  "mcpServers": "./.mcp.json"
+}

package/host-plugins/workbuddy/.mcp.json

@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "capclaw-video-editor": {
+      "command": "node",
+      "args": [
+        "{{CAPCLAW_STDIO_PROXY_PATH}}"
+      ],
+      "x-workbuddy": {
+        "displayName": "开刻 CapClaw 视频剪辑引擎",
+        "description": "本地 PGlite 草稿库 + 零拷贝素材 + 18 种画布指令 + 内置浏览器协同编辑"
+      }
+    }
+  }
+}

package/host-plugins/workbuddy/agents/capclaw-editor.md

@@ -0,0 +1,28 @@
+---
+name: capclaw-editor
+description: 开刻（CapClaw）AI 视频剪辑专家，负责本地视频草稿编排、素材零拷贝导入、时间线精细剪辑、WorkBuddy 内置浏览器协同预览与本地 MP4 导出。
+tools:
+  - mcp__capclaw-video-editor__manage_project
+  - mcp__capclaw-video-editor__inspect_timeline
+  - mcp__capclaw-video-editor__import_local_media
+  - mcp__capclaw-video-editor__apply_canvas_commands
+  - mcp__capclaw-video-editor__ai_edit_turn
+  - mcp__capclaw-video-editor__open_in_editor
+  - mcp__capclaw-video-editor__export_video
+  - present_files
+---
+
+你是**开刻（CapClaw）视频剪辑专家**。你可以直接调用 `capclaw-video-editor` MCP 服务管理本地视频草稿、零拷贝导入本机音视频与图片素材、执行 18 种确定性画布指令，并利用 WorkBuddy 的 `present_files` 工具在右侧内置浏览器中打开开刻可视化编辑器或预览导出的 MP4 成片。
+
+## 核心工作流
+
+1. **创建或查看草稿**：调用 `manage_project`（`action: "create"` 或 `"list"`）。
+2. **在 WorkBuddy 内置浏览器挂载编辑器**：
+   - 调用 `open_in_editor({ projectId })` 获取 `browserHandoff.url`（或 `editorUrl`）；
+   - 立即调用 `present_files` 打开该 `browserHandoff.url`，让编辑器在 WorkBuddy 内置浏览器中完成回环桥握手与草稿挂载。
+3. **导入素材与画布编辑**：
+   - 使用 `import_local_media` 导入本地文件（可传 `addToTimeline: true`）；
+   - 使用 `apply_canvas_commands` 或 `ai_edit_turn` 修改字幕、贴纸、转场、滤镜、动画或切分/变速视频片段。
+4. **本地合成导出与预览**：
+   - 调用 `export_video({ projectId })`（提醒用户保持右侧编辑器面板可见，避免浏览器后台节流）；
+   - 导出完成后，将返回的 `fileUri`（`file:///...`）或 `exportedFilePath` 传给 `present_files` 供用户直接预览成片。

package/host-plugins/workbuddy/skills/capclaw-video-editor/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: capclaw-video-editor
+description: 开刻（CapClaw）WorkBuddy 视频剪辑与内置浏览器实时精修技能。用于创建本地视频草稿、零拷贝导入素材、执行 18 种画布指令、在 WorkBuddy 内置浏览器打开编辑器以及导出本地 MP4。
+---
+
+# 开刻（CapClaw）WorkBuddy 视频剪辑技能指南
+
+## 1. WorkBuddy 内置浏览器协同（`present_files`）
+
+- 当调用 `manage_project(action="create")` 或 `open_in_editor({ projectId })` 获得 `browserHandoff.url` / `editorUrl` 后：
+  - 使用 WorkBuddy 内置的 `present_files` 工具传入该 URL，即可在 WorkBuddy 右侧内置浏览器直接打开开刻画布编辑器。
+  - URL Fragment 中的 `#capclawBridge=http://127.0.0.1:<port>&bootToken=<token>` 会在前端初始化时自动完成一次性握手并剥离，随后上报 `project-mounted`。
+- 当调用 `export_video({ projectId })` 获得 `fileUri`（`file:///...mp4`）后：
+  - 使用 `present_files` 传入该 `fileUri` 即可唤起预览或系统播放器。
+
+## 2. 18 种公开画布指令（`apply_canvas_commands`）
+
+仅使用以下 18 种公开指令：
+`UPDATE_WIDGET`, `ADD_WIDGET`, `DELETE_WIDGET`, `UPDATE_PAGE`, `REORDER_WIDGET`, `ADD_TRANSITION`, `ADD_GIF`, `ADD_FILTER`, `ADD_EFFECT`, `ADD_PARTICLE`, `ADD_AUDIO`, `BATCH_UPDATE`, `SET_ANIMATION`, `APPLY_EXISTING_ANIMATION`, `SPLIT_WIDGET`, `TRIM_WIDGET`, `SET_CLIP_SPEED`, `FREEZE_FRAME_SPLIT`。
+
+## 3. 导出注意事项
+
+- `export_video` 依赖前端可见 DOM 驱动 `requestAnimationFrame` + WebCodecs 合成；导出期间请提醒用户不要最小化或切走右侧编辑器面板。

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@capclaw/mcp-stdio",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Official MCP stdio proxy and multi-host plugin installer for CapClaw (开刻) AI Video Editor",
+  "bin": {
+    "capclaw-mcp-stdio": "./bin/capclaw-mcp-stdio.mjs",
+    "capclaw-plugin-install": "./bin/capclaw-plugin-install.mjs"
+  },
+  "files": [
+    "bin/",
+    "service/",
+    "host-plugins/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "PROPRIETARY",
+  "homepage": "https://www.capclaw.cn"
+}

package/service/hostPluginInstaller.js

@@ -0,0 +1,432 @@
+/**
+ * 开刻（CapClaw）四宿主插件一键安装与自愈器（service/hostPluginInstaller.js）
+ *
+ * 支持的四大宿主：
+ * 1. OpenAI Codex (`codex`)：
+ *    - 技能目录：`~/.codex/skills/capclaw-video-editor/`
+ *    - 插件目录：`~/.codex/plugins/capclaw-video-editor/`
+ *    - MCP 配置：`~/.codex/config.toml` -> `[mcp_servers.capclaw-video-editor]` (stdio)
+ * 2. Claude Code / Claude Desktop (`claude`)：
+ *    - 技能目录：`~/.claude/skills/capclaw-video-editor/`
+ *    - MCP 配置：`~/.claude.json` -> `mcpServers["capclaw-video-editor"]` (stdio)
+ * 3. 腾讯 WorkBuddy (`workbuddy`)：
+ *    - 专家插件包：`~/.workbuddy/plugins/capclaw-video-editor/`（含 `.codebuddy-plugin/plugin.json`、包内 `.mcp.json` 含 `x-workbuddy`、`agents/`、`skills/`，遵循 C-4）
+ *    - 用户级 MCP 配置：`~/.workbuddy/mcp.json`（严格剥离 `x-workbuddy`，遵循 C-4）
+ * 4. DeepSeek Harness (`dsh`)：
+ *    - 技能目录：`~/.dsh/skills/capclaw-video-editor/SKILL.md`（遵循 R1，无内置浏览器回落 E1 桌面窗口）
+ *    - Cordis 补丁：`~/.dsh/profiles/<profile>/cordis.patch.yml` -> `@deepseek-ai/dsh-mcp-client` (`transport: streamable-http`，遵循 P0-3)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SERVER_KEY = 'capclaw-video-editor';
+const SUPPORTED_HOSTS = ['codex', 'claude', 'workbuddy', 'dsh'];
+
+function unpackAsarPathIfNeeded(targetPath) {
+  if (targetPath.includes('app.asar') && !targetPath.includes('app.asar.unpacked')) {
+    const unpacked = targetPath.replace('app.asar', 'app.asar.unpacked');
+    if (fs.existsSync(unpacked)) return unpacked;
+  }
+  return targetPath;
+}
+
+function resolveDefaultStdioProxyPath() {
+  return unpackAsarPathIfNeeded(path.resolve(__dirname, '..', 'bin', 'capclaw-mcp-stdio.mjs'));
+}
+
+function resolveHostPluginsRoot() {
+  return unpackAsarPathIfNeeded(path.resolve(__dirname, '..', 'host-plugins'));
+}
+
+function copyDirTemplateRecursive(srcDir, destDir, replacements = {}) {
+  if (!fs.existsSync(srcDir)) return;
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirTemplateRecursive(srcPath, destPath, replacements);
+    } else {
+      let content = fs.readFileSync(srcPath, 'utf8');
+      for (const [placeholder, val] of Object.entries(replacements)) {
+        content = content.split(placeholder).join(String(val));
+      }
+      fs.writeFileSync(destPath, content, 'utf8');
+    }
+  }
+}
+
+function readJsonSafe(filePath, fallback = {}) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : fallback;
+  } catch (_e) {
+    return fallback;
+  }
+}
+
+function writeJsonAtomic(filePath, data) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmpPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
+function escapeTomlString(str) {
+  return String(str || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function upsertCodexTomlMcpSection(existingToml, { stdioProxyPath, exePath = '' }) {
+  const blockLines = [
+    `[mcp_servers.${SERVER_KEY}]`,
+    'command = "node"',
+    `args = ["${escapeTomlString(stdioProxyPath)}"]`,
+  ];
+  if (exePath) {
+    blockLines.push(`[mcp_servers.${SERVER_KEY}.env]`);
+    blockLines.push(`CAPCLAW_EXE_PATH = "${escapeTomlString(exePath)}"`);
+  }
+  const newBlock = blockLines.join('\n');
+
+  const raw = String(existingToml || '');
+  // 移除已有的 [mcp_servers.capclaw-video-editor] 及紧随其后的 [mcp_servers.capclaw-video-editor.env]
+  const sectionPattern = new RegExp(
+    `\\[mcp_servers\\.${SERVER_KEY}(?:\\.env)?\\][\\s\\S]*?(?=\\n\\[|$)`,
+    'g',
+  );
+  const cleaned = raw.replace(sectionPattern, '').trim();
+  return cleaned ? `${cleaned}\n\n${newBlock}\n` : `${newBlock}\n`;
+}
+
+function removeCodexTomlMcpSection(existingToml) {
+  const raw = String(existingToml || '');
+  const sectionPattern = new RegExp(
+    `\\[mcp_servers\\.${SERVER_KEY}(?:\\.env)?\\][\\s\\S]*?(?=\\n\\[|$)`,
+    'g',
+  );
+  return `${raw.replace(sectionPattern, '').trim()}\n`;
+}
+
+function upsertDshCordisPatchYaml(existingYaml, { port = 5600 }) {
+  const targetUrl = `http://127.0.0.1:${Number(port) || 5600}/mcp`;
+  const raw = String(existingYaml || '');
+
+  if (!raw.trim()) {
+    return [
+      '# Managed by CapClaw Host Plugin Installer',
+      '"@deepseek-ai/dsh-mcp-client":',
+      '  servers:',
+      `    ${SERVER_KEY}:`,
+      '      transport: streamable-http',
+      `      url: "${targetUrl}"`,
+      '',
+    ].join('\n');
+  }
+
+  // 若已存在 capclaw-video-editor 条目，原地更新其 url 与 transport
+  if (raw.includes(`${SERVER_KEY}:`)) {
+    const updatedUrl = raw.replace(
+      /(capclaw-video-editor:\s*(?:\r?\n\s+[^\r\n]+)*?\r?\n\s+url:\s*["']?https?:\/\/(?:127\.0\.0\.1|localhost):)\d+(\/mcp["']?)/i,
+      `$1${Number(port) || 5600}$2`,
+    );
+    return updatedUrl;
+  }
+
+  // 若已有 "@deepseek-ai/dsh-mcp-client": 且含 servers:
+  if (raw.includes('dsh-mcp-client') && /\bservers:\s*\r?\n/.test(raw)) {
+    return raw.replace(
+      /(\bservers:\s*\r?\n)/,
+      `$1    ${SERVER_KEY}:\n      transport: streamable-http\n      url: "${targetUrl}"\n`,
+    );
+  }
+
+  return `${raw.trimEnd()}\n\n"@deepseek-ai/dsh-mcp-client":\n  servers:\n    ${SERVER_KEY}:\n      transport: streamable-http\n      url: "${targetUrl}"\n`;
+}
+
+function installCodexPlugin({
+  homeDir = os.homedir(),
+  stdioProxyPath = resolveDefaultStdioProxyPath(),
+  exePath = process.env.CAPCLAW_EXE_PATH || '',
+  templatesRoot = resolveHostPluginsRoot(),
+} = {}) {
+  const codexDir = path.join(homeDir, '.codex');
+  const pluginDest = path.join(codexDir, 'plugins', SERVER_KEY);
+  const skillDest = path.join(codexDir, 'skills', SERVER_KEY);
+  const configTomlPath = path.join(codexDir, 'config.toml');
+
+  const srcDir = path.join(templatesRoot, 'codex');
+  copyDirTemplateRecursive(srcDir, pluginDest, {
+    '{{CAPCLAW_STDIO_PROXY_PATH}}': stdioProxyPath.replace(/\\/g, '/'),
+  });
+  copyDirTemplateRecursive(path.join(srcDir, 'skills', SERVER_KEY), skillDest, {
+    '{{CAPCLAW_STDIO_PROXY_PATH}}': stdioProxyPath.replace(/\\/g, '/'),
+  });
+
+  const existingToml = fs.existsSync(configTomlPath) ? fs.readFileSync(configTomlPath, 'utf8') : '';
+  const updatedToml = upsertCodexTomlMcpSection(existingToml, { stdioProxyPath, exePath });
+  fs.mkdirSync(codexDir, { recursive: true });
+  fs.writeFileSync(configTomlPath, updatedToml, 'utf8');
+
+  return {
+    ok: true,
+    host: 'codex',
+    pluginDir: pluginDest,
+    skillDir: skillDest,
+    configPath: configTomlPath,
+  };
+}
+
+function installClaudePlugin({
+  homeDir = os.homedir(),
+  stdioProxyPath = resolveDefaultStdioProxyPath(),
+  exePath = process.env.CAPCLAW_EXE_PATH || '',
+  templatesRoot = resolveHostPluginsRoot(),
+} = {}) {
+  const claudeDir = path.join(homeDir, '.claude');
+  const pluginDest = path.join(claudeDir, 'plugins', SERVER_KEY);
+  const skillDest = path.join(claudeDir, 'skills', SERVER_KEY);
+  const claudeJsonPath = path.join(homeDir, '.claude.json');
+
+  const srcDir = path.join(templatesRoot, 'claude');
+  copyDirTemplateRecursive(srcDir, pluginDest, {
+    '{{CAPCLAW_STDIO_PROXY_PATH}}': stdioProxyPath.replace(/\\/g, '/'),
+  });
+  copyDirTemplateRecursive(path.join(srcDir, 'skills', SERVER_KEY), skillDest, {
+    '{{CAPCLAW_STDIO_PROXY_PATH}}': stdioProxyPath.replace(/\\/g, '/'),
+  });
+
+  const claudeConfig = readJsonSafe(claudeJsonPath, {});
+  if (!claudeConfig.mcpServers || typeof claudeConfig.mcpServers !== 'object') {
+    claudeConfig.mcpServers = {};
+  }
+  const serverEntry = {
+    type: 'stdio',
+    command: 'node',
+    args: [stdioProxyPath],
+  };
+  if (exePath) {
+    serverEntry.env = { CAPCLAW_EXE_PATH: exePath };
+  }
+  claudeConfig.mcpServers[SERVER_KEY] = serverEntry;
+  writeJsonAtomic(claudeJsonPath, claudeConfig);
+
+  return {
+    ok: true,
+    host: 'claude',
+    pluginDir: pluginDest,
+    skillDir: skillDest,
+    configPath: claudeJsonPath,
+  };
+}
+
+function installWorkBuddyPlugin({
+  homeDir = os.homedir(),
+  stdioProxyPath = resolveDefaultStdioProxyPath(),
+  exePath = process.env.CAPCLAW_EXE_PATH || '',
+  port = 5600,
+  useStreamableHttpInUserConfig = false,
+  templatesRoot = resolveHostPluginsRoot(),
+} = {}) {
+  const wbDir = path.join(homeDir, '.workbuddy');
+  const pluginDest = path.join(wbDir, 'plugins', SERVER_KEY);
+  const userMcpJsonPath = path.join(wbDir, 'mcp.json');
+
+  const srcDir = path.join(templatesRoot, 'workbuddy');
+  copyDirTemplateRecursive(srcDir, pluginDest, {
+    '{{CAPCLAW_STDIO_PROXY_PATH}}': stdioProxyPath.replace(/\\/g, '/'),
+  });
+
+  // 用户级 ~/.workbuddy/mcp.json：严格不写 x-workbuddy（C-4：x-workbuddy 仅在插件包内 .mcp.json 生效，写入用户配置时剥离）
+  const userMcpConfig = readJsonSafe(userMcpJsonPath, {});
+  if (!userMcpConfig.mcpServers || typeof userMcpConfig.mcpServers !== 'object') {
+    userMcpConfig.mcpServers = {};
+  }
+  if (useStreamableHttpInUserConfig) {
+    userMcpConfig.mcpServers[SERVER_KEY] = {
+      type: 'streamable-http',
+      url: `http://127.0.0.1:${Number(port) || 5600}/mcp`,
+    };
+  } else {
+    const entry = {
+      command: 'node',
+      args: [stdioProxyPath],
+    };
+    if (exePath) {
+      entry.env = { CAPCLAW_EXE_PATH: exePath };
+    }
+    userMcpConfig.mcpServers[SERVER_KEY] = entry;
+  }
+  // 确保剥离任何残留的 x-workbuddy
+  if (userMcpConfig.mcpServers[SERVER_KEY] && 'x-workbuddy' in userMcpConfig.mcpServers[SERVER_KEY]) {
+    delete userMcpConfig.mcpServers[SERVER_KEY]['x-workbuddy'];
+  }
+  writeJsonAtomic(userMcpJsonPath, userMcpConfig);
+
+  return {
+    ok: true,
+    host: 'workbuddy',
+    pluginDir: pluginDest,
+    configPath: userMcpJsonPath,
+  };
+}
+
+function installDshPlugin({
+  homeDir = os.homedir(),
+  port = 5600,
+  profile = 'default',
+  templatesRoot = resolveHostPluginsRoot(),
+} = {}) {
+  const dshDir = path.join(homeDir, '.dsh');
+  const skillDest = path.join(dshDir, 'skills', SERVER_KEY);
+  const profileDir = path.join(dshDir, 'profiles', profile);
+  const patchPath = path.join(profileDir, 'cordis.patch.yml');
+
+  const srcDir = path.join(templatesRoot, 'dsh');
+  copyDirTemplateRecursive(path.join(srcDir, 'skills', SERVER_KEY), skillDest, {
+    '{{CAPCLAW_MCP_PORT}}': String(Number(port) || 5600),
+  });
+
+  fs.mkdirSync(profileDir, { recursive: true });
+  const existingYaml = fs.existsSync(patchPath) ? fs.readFileSync(patchPath, 'utf8') : '';
+  const updatedYaml = upsertDshCordisPatchYaml(existingYaml, { port });
+  fs.writeFileSync(patchPath, updatedYaml, 'utf8');
+
+  return {
+    ok: true,
+    host: 'dsh',
+    skillDir: skillDest,
+    configPath: patchPath,
+  };
+}
+
+function installHostPlugin(host, options = {}) {
+  const cleanHost = String(host || '').trim().toLowerCase();
+  switch (cleanHost) {
+    case 'codex':
+      return installCodexPlugin(options);
+    case 'claude':
+      return installClaudePlugin(options);
+    case 'workbuddy':
+      return installWorkBuddyPlugin(options);
+    case 'dsh':
+      return installDshPlugin(options);
+    default:
+      throw new Error(`Unsupported host "${host}". Expected one of: ${SUPPORTED_HOSTS.join(', ')}`);
+  }
+}
+
+function installAllHostPlugins(options = {}) {
+  const results = {};
+  for (const host of SUPPORTED_HOSTS) {
+    results[host] = installHostPlugin(host, options);
+  }
+  return {
+    ok: true,
+    hosts: results,
+  };
+}
+
+function uninstallHostPlugin(host, { homeDir = os.homedir(), profile = 'default' } = {}) {
+  const cleanHost = String(host || '').trim().toLowerCase();
+  if (cleanHost === 'codex') {
+    const codexDir = path.join(homeDir, '.codex');
+    const configTomlPath = path.join(codexDir, 'config.toml');
+    if (fs.existsSync(configTomlPath)) {
+      const updated = removeCodexTomlMcpSection(fs.readFileSync(configTomlPath, 'utf8'));
+      fs.writeFileSync(configTomlPath, updated, 'utf8');
+    }
+    fs.rmSync(path.join(codexDir, 'plugins', SERVER_KEY), { recursive: true, force: true });
+    fs.rmSync(path.join(codexDir, 'skills', SERVER_KEY), { recursive: true, force: true });
+    return { ok: true, host: 'codex' };
+  }
+
+  if (cleanHost === 'claude') {
+    const claudeJsonPath = path.join(homeDir, '.claude.json');
+    if (fs.existsSync(claudeJsonPath)) {
+      const cfg = readJsonSafe(claudeJsonPath, {});
+      if (cfg.mcpServers && cfg.mcpServers[SERVER_KEY]) {
+        delete cfg.mcpServers[SERVER_KEY];
+        writeJsonAtomic(claudeJsonPath, cfg);
+      }
+    }
+    fs.rmSync(path.join(homeDir, '.claude', 'plugins', SERVER_KEY), { recursive: true, force: true });
+    fs.rmSync(path.join(homeDir, '.claude', 'skills', SERVER_KEY), { recursive: true, force: true });
+    return { ok: true, host: 'claude' };
+  }
+
+  if (cleanHost === 'workbuddy') {
+    const wbMcpPath = path.join(homeDir, '.workbuddy', 'mcp.json');
+    if (fs.existsSync(wbMcpPath)) {
+      const cfg = readJsonSafe(wbMcpPath, {});
+      if (cfg.mcpServers && cfg.mcpServers[SERVER_KEY]) {
+        delete cfg.mcpServers[SERVER_KEY];
+        writeJsonAtomic(wbMcpPath, cfg);
+      }
+    }
+    fs.rmSync(path.join(homeDir, '.workbuddy', 'plugins', SERVER_KEY), { recursive: true, force: true });
+    return { ok: true, host: 'workbuddy' };
+  }
+
+  if (cleanHost === 'dsh') {
+    const patchPath = path.join(homeDir, '.dsh', 'profiles', profile, 'cordis.patch.yml');
+    if (fs.existsSync(patchPath)) {
+      const raw = fs.readFileSync(patchPath, 'utf8');
+      const cleaned = raw.replace(
+        new RegExp(`\\s*${SERVER_KEY}:\\s*\\r?\\n\\s*transport:\\s*[^\\r\\n]+\\r?\\n\\s*url:\\s*[^\\r\\n]+`, 'g'),
+        '',
+      );
+      fs.writeFileSync(patchPath, cleaned, 'utf8');
+    }
+    fs.rmSync(path.join(homeDir, '.dsh', 'skills', SERVER_KEY), { recursive: true, force: true });
+    return { ok: true, host: 'dsh' };
+  }
+
+  throw new Error(`Unsupported host "${host}"`);
+}
+
+function getHostPluginStatus({ homeDir = os.homedir(), profile = 'default' } = {}) {
+  const codexToml = path.join(homeDir, '.codex', 'config.toml');
+  const claudeJson = path.join(homeDir, '.claude.json');
+  const wbPluginJson = path.join(homeDir, '.workbuddy', 'plugins', SERVER_KEY, '.codebuddy-plugin', 'plugin.json');
+  const dshPatch = path.join(homeDir, '.dsh', 'profiles', profile, 'cordis.patch.yml');
+
+  return {
+    codex: {
+      installed: fs.existsSync(codexToml) && fs.readFileSync(codexToml, 'utf8').includes(`[mcp_servers.${SERVER_KEY}]`),
+      configPath: codexToml,
+    },
+    claude: {
+      installed: Boolean(readJsonSafe(claudeJson, {})?.mcpServers?.[SERVER_KEY]),
+      configPath: claudeJson,
+    },
+    workbuddy: {
+      installed: fs.existsSync(wbPluginJson),
+      configPath: wbPluginJson,
+    },
+    dsh: {
+      installed: fs.existsSync(dshPatch) && fs.readFileSync(dshPatch, 'utf8').includes(SERVER_KEY),
+      configPath: dshPatch,
+    },
+  };
+}
+
+module.exports = {
+  SERVER_KEY,
+  SUPPORTED_HOSTS,
+  installCodexPlugin,
+  installClaudePlugin,
+  installWorkBuddyPlugin,
+  installDshPlugin,
+  installHostPlugin,
+  installAllHostPlugins,
+  uninstallHostPlugin,
+  getHostPluginStatus,
+  upsertCodexTomlMcpSection,
+  upsertDshCordisPatchYaml,
+};