opencode-idea 0.0.17 → 0.0.19

package/src/ide-launcher.js

@@ -12,50 +12,110 @@
 // unavailable; this module only requests opening/activating the project.
 
 import { spawn } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 
-/** Default macOS app name for IntelliJ IDEA. */
+/** 兜底 macOS 应用名：调用方没给 app 时用它。 */
 export const DEFAULT_IDE_APP = 'IntelliJ IDEA';
 
 /**
- * Can this platform launch the IDE at all?
+ * 每个 IDE 选项值对应的 macOS 应用名。
  *
- * Launching goes through macOS `open -a`, which is the only launcher this
- * plugin implements. On Windows there is no `open` command, so a spawn there
- * fails with ENOENT — silently, as a rejected promise that resolves `false`.
- * Rather than pretend, other platforms resolve no app at all and the caller
- * asks the user to open the IDE by hand.
- *
- * A function, not a constant: the answer is read when a command runs, so tests
- * can simulate another platform by replacing it. A constant would be bound at
- * import time and never re-read.
+ * 只包含受支持的 IDE（见 `ide-projects.js` 的 `SUPPORTED_IDES`）—— 应用名由项目
+ * 配置决定，不再由用户在 `openInIde` 里自由指定，所以这里是一张封闭的表。
  */
-export function autoLaunchSupported() {
-  return process.platform === 'darwin';
-}
-
-/** Aliases accepted by the `openInIde` option. */
 export const IDE_APPS = {
   idea: 'IntelliJ IDEA',
-  intellij: 'IntelliJ IDEA',
-  'intellij-idea': 'IntelliJ IDEA',
+  pycharm: 'PyCharm',
 };
 
 /**
- * Resolve the `openInIde` option to a macOS app name, or `undefined` to disable.
+ * 该 IDE 的 macOS 应用名，`undefined` 表示"不能自动拉起"。
  *
- * `undefined` covers two distinct reasons, and the caller tells them apart via
- * `autoLaunchSupported()`: the user turned launching off, or this platform has
- * no launcher. They deserve different user-facing wording.
+ * `undefined` 有两种原因，调用方用 `autoLaunchSupported()` 区分：这个平台没有
+ * 启动器，或这个 IDE 不在支持列表里。两者给用户的建议不同，不能混为一谈。
  *
- * @param {boolean | string | undefined} value
+ * @param {string} app
  * @param {{ platform?: string }} [options]
  * @returns {string | undefined}
  */
-export function resolveIdeApp(value, { platform = process.platform } = {}) {
+export function appNameFor(app, { platform = process.platform } = {}) {
   if (platform !== 'darwin') return undefined;
-  if (value === false) return undefined;
-  if (typeof value !== 'string') return DEFAULT_IDE_APP;
-  return IDE_APPS[value.toLowerCase()] ?? value;
+  return IDE_APPS[app];
+}
+
+/**
+ * 各平台上看"装了哪些 IDE"的目录。
+ *
+ * macOS 那两个位置是**实测**的（这台机器上就是这么装的）；Windows / Linux 列的是各自最
+ * 常见的安装位置（Toolbox 默认 + 系统级目录），**未在真机上验证过** —— 探错的后果只是少一
+ * 行提示、让模型照常问用户，不会挡住任何选择，所以先按常见值给出来。
+ */
+function ideInstallDirs(platform = process.platform) {
+  const home = homedir();
+  if (platform === 'darwin') return ['/Applications', join(home, 'Applications')];
+  if (platform === 'win32') {
+    const local = process.env.LOCALAPPDATA ?? join(home, 'AppData', 'Local');
+    return [
+      join(local, 'Programs', 'JetBrains'),
+      join(local, 'JetBrains', 'Toolbox', 'apps'),
+      'C:\\Program Files\\JetBrains',
+    ];
+  }
+  return [join(home, '.local', 'share', 'JetBrains', 'Toolbox', 'apps'), '/opt', '/usr/local'];
+}
+
+/**
+ * 本机装了哪些受支持的 IDE（`IDE_APPS` 的键）。
+ *
+ * 按**安装目录**判断，不看进程 —— 用 `ps aux` 之类探进程只能发现"正在运行"的 IDE，装了
+ * 但没打开就会漏（实测踩过：PyCharm 明明装着，进程探测报"未发现"）。一次目录读取就够，
+ * 比模型自己去跑命令快几个数量级。
+ *
+ * 返回空数组表示"**没探测出来**"，不能当成"没装"：调用方要么照常问用户，要么在提示里说明
+ * 是"没找到"。
+ *
+ * @param {{ platform?: string, dirs?: string[] }} [options] 仅供测试注入。
+ * @returns {string[]}
+ */
+export function detectInstalledIdes(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const dirs = options.dirs ?? ideInstallDirs(platform);
+  /** @type {Set<string>} */
+  const found = new Set();
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      // 目录不存在（例如没有 ~/Applications）就是没装，继续看下一个。
+      continue;
+    }
+    for (const entry of entries) {
+      const bundle = entry.endsWith('.app') ? entry.slice(0, -'.app'.length) : entry;
+      for (const [app, label] of Object.entries(IDE_APPS)) {
+        // `IntelliJ IDEA.app` 精确匹配；`PyCharm CE.app`、`PyCharm 2026.2`、Toolbox 的
+        // `PyCharm` 目录都是产品名开头，按前缀匹配。
+        if (bundle === label || bundle.startsWith(label)) found.add(app);
+      }
+    }
+  }
+  return [...found];
+}
+
+/**
+ * 这个平台有没有自动拉起 IDE 的能力？
+ *
+ * 只有 macOS 实现了启动（`open -a`）。Windows 上没有 `open` 命令，spawn 会以
+ * ENOENT 失败——表现为一个静默 resolve 成 `false` 的 promise。与其假装能启动，
+ * 不如让调用方直接告诉用户手动打开 IDE。
+ *
+ * 写成函数而不是常量：答案在命令真正执行时读取，测试才能用替换它的方式模拟
+ * 其它平台；常量会在 import 时定死，之后再也不重读。
+ */
+export function autoLaunchSupported() {
+  return process.platform === 'darwin';
 }
 
 /**

package/src/ide-projects.js

@@ -0,0 +1,262 @@
+// IDE 项目集合：一个 OpenCode 会话（root 项目）可以接入多个 JetBrains 项目 ——
+// root 本身，加上 root 下任意层级的子目录；每个项目可以被**不同的** IDE 打开
+// （root 用 IDEA、modelserver 用 PyCharm 是常态）。
+//
+// 这个模块只做纯数据：持久化标记的解析/序列化、工具前缀（= MCP server 名）的派生、
+// 以及新增子项目前的校验。所有 I/O、探测、注册都留在 plugin.js，所以这里全部是
+// 可以直接测的纯函数。
+//
+// ## 命名规则
+//
+// 工具前缀就是 MCP server 名，由项目的**层级**决定，与 IDE 产品无关：
+//
+//   * root  → `ide`        root 用 IDEA 还是 PyCharm，它都叫 `ide_*`
+//   * 子项目 → 目录名       `modelserver` → `modelserver_*`
+//
+// 为什么不叫 `idea_*`：那会把"root 项目"和"IntelliJ IDEA 这个产品"绑死，而
+// 「root 用 PyCharm 打开、子项目用 IDEA 打开」是完全合理的组合。
+//
+// ## 为什么前缀必须严格控制字符集
+//
+// 前缀会变成工具名的一部分（`modelserver_search_symbol`），模型要照着调。目录名
+// 里但凡有空格、点、大写或非 ASCII，工具名就会变得难写、难赌 —— 跨平台还可能
+// 产生"同名不同目录"。所以不规范的目录名**一律拒绝**（见 validateSubproject），
+// 由用户改目录名，插件绝不自动改名或消歧。
+
+import { basename, sep } from 'node:path';
+
+/** root 项目的 MCP server 名。与 IDE 产品解耦，见文件头。 */
+export const ROOT_SERVER_NAME = 'ide';
+
+/** `ctx.options.ides` 允许的取值；未知值会被忽略。 */
+export const SUPPORTED_IDES = ['idea', 'pycharm'];
+
+/** 每个 IDE 选项值对应的显示名（提示词里写给模型看）。 */
+export const IDE_LABELS = {
+  idea: 'IntelliJ IDEA',
+  pycharm: 'PyCharm',
+};
+
+/**
+ * 每个 IDE 的 MCP 端口。
+ *
+ * **固定值,不开放配置**:JetBrains 给内置 MCP server 分配的就是这个端口,跨版本、
+ * 跨项目都不变(IDEA 的 MCP 在 64342,它的内置服务是 63342;PyCharm 的 MCP 在 64462,
+ * 内置服务是 63343)。既然"哪个 IDE 在哪个端口"是产品常量,插件就不需要"扫描候选端口
+ * 找归属":探哪个端口由项目的 IDE 唯一决定,不经过任何用户配置。
+ *
+ * 导出成**可变对象**而不是冻结字面量:测试要把它们指到假端口上(见
+ * `tests/plugin.test.js` 的 `fakeCtx`),运行时没有任何人写它。
+ */
+export const IDE_PORTS = {
+  idea: 64342,
+  pycharm: 64462,
+};
+
+/**
+ * 子项目目录名（= 工具前缀）必须匹配的形状。
+ *
+ * 小写字母或数字开头，其后只允许小写字母、数字、`-`、`_`。上限 48 是硬约束之一
+ * 的保守取值：工具名要在模型提示里反复出现，越短越好。
+ */
+export const SUBPROJECT_PREFIX = /^[a-z0-9][a-z0-9_-]{0,47}$/;
+
+/** 持久化标记里存的版本号，用于将来识别旧结构。 */
+export const MARK_VERSION = 2;
+
+/**
+ * @typedef {{ path: string, app: string }} IdeProject
+ * @typedef {{ root: IdeProject, children: IdeProject[] }} IdeConfig
+ */
+
+/** 这个 root 的持久化标记 key。 */
+export function markKeyFor(rootPath) {
+  return `project/${rootPath}`;
+}
+
+/** @param {unknown} entry @returns {boolean} */
+function isProjectEntry(entry) {
+  return (
+    entry !== null &&
+    typeof entry === 'object' &&
+    typeof (/** @type {IdeProject} */ (entry).path) === 'string' &&
+    typeof (/** @type {IdeProject} */ (entry).app) === 'string'
+  );
+}
+
+/**
+ * 解析持久化的标记值。
+ *
+ * 兼容 v1：旧版本存的是布尔 `true`（只表示"root 已接入"，没有 IDE 与子项目信息），
+ * 这里把它读成"root 用 idea 的 v1 配置"。任何无法识别的形状都当作**未配置**
+ * （`undefined`），因为一个读不懂的配置比没有配置更危险。
+ *
+ * @param {unknown} raw 从 `ctx.storage` 读到的原始值
+ * @param {string} rootPath
+ * @returns {IdeConfig | undefined}
+ */
+export function parseMark(raw, rootPath) {
+  if (raw === true) return { root: { path: rootPath, app: 'idea' }, children: [] };
+  if (raw === null || typeof raw !== 'object') return undefined;
+  const record = /** @type {{ root?: unknown, children?: unknown }} */ (raw);
+  if (!isProjectEntry(record.root)) return undefined;
+  const root = /** @type {IdeProject} */ (record.root);
+  const children = Array.isArray(record.children)
+    ? record.children.filter(isProjectEntry).map((entry) => {
+        const child = /** @type {IdeProject} */ (entry);
+        return { path: child.path, app: child.app };
+      })
+    : [];
+  return { root: { path: root.path, app: root.app }, children };
+}
+
+/** @param {IdeConfig} config @returns {Record<string, unknown>} */
+export function serializeMark(config) {
+  return {
+    version: MARK_VERSION,
+    root: { path: config.root.path, app: config.root.app },
+    children: config.children.map((child) => ({ path: child.path, app: child.app })),
+  };
+}
+
+/**
+ * 一个项目对应的 MCP server 名（= 工具前缀）。
+ *
+ * @param {string} path
+ * @param {string} rootPath
+ */
+export function serverNameFor(path, rootPath) {
+  return path === rootPath ? ROOT_SERVER_NAME : basename(path);
+}
+
+/**
+ * 展开成"项目 + 前缀"的平铺列表，顺序固定：root 在最前，子项目按登记顺序。
+ *
+ * @param {IdeConfig} config
+ * @returns {Array<{ path: string, app: string, server: string, isRoot: boolean }>}
+ */
+export function listProjects(config) {
+  const root = {
+    path: config.root.path,
+    app: config.root.app,
+    server: ROOT_SERVER_NAME,
+    isRoot: true,
+  };
+  const children = config.children.map((child) => ({
+    path: child.path,
+    app: child.app,
+    server: serverNameFor(child.path, config.root.path),
+    isRoot: false,
+  }));
+  return [root, ...children];
+}
+
+/** 当前配置里所有项目的工具前缀（带下划线），例如 `["ide_", "modelserver_"]`。 */
+export function toolPrefixes(config) {
+  return listProjects(config).map((project) => `${project.server}_`);
+}
+
+/**
+ * 校验：把 `absPath` 登记为 root 的子项目是否合法。
+ *
+ * 全部规则都是**拒绝**，不做任何自动修正 —— 与插件其它地方一致：静默改一个名字，
+ * 等于把用户的目录和模型看到的工具名对不上，而且没人会发现。
+ *
+ * @param {IdeConfig} config
+ * @param {string} absPath 待登记的绝对路径
+ * @returns {{ ok: true } | { ok: false, code: string, message: string }}
+ */
+export function validateSubproject(config, absPath) {
+  const rootPath = config.root.path;
+  const prefix = rootPath.endsWith(sep) ? rootPath : `${rootPath}${sep}`;
+  if (!absPath.startsWith(prefix)) {
+    return {
+      ok: false,
+      code: 'outside-root',
+      message: `必须位于 root 项目（${rootPath}）之下`,
+    };
+  }
+  const name = basename(absPath);
+  if (!SUBPROJECT_PREFIX.test(name)) {
+    return {
+      ok: false,
+      code: 'invalid-name',
+      message: `目录名 \`${name}\` 不能作为工具前缀:要求 ^[a-z0-9][a-z0-9_-]{0,47}$,即以小写字母或数字开头,只含小写字母、数字、- 和 _`,
+    };
+  }
+  if (name === ROOT_SERVER_NAME) {
+    return {
+      ok: false,
+      code: 'reserved',
+      message: `\`${ROOT_SERVER_NAME}\` 是 root 项目保留的工具前缀,请在别处使用这个目录名`,
+    };
+  }
+  const existing = config.children.find((child) => child.path === absPath);
+  if (existing) {
+    return { ok: false, code: 'already-registered', message: `\`${name}\` 已经登记过了` };
+  }
+  const clash = config.children.find((child) => basename(child.path) === name);
+  if (clash) {
+    return {
+      ok: false,
+      code: 'duplicate-prefix',
+      message: `工具前缀 \`${name}\` 已被 ${clash.path} 占用;两个子项目不能同名,请重命名其中一个目录`,
+    };
+  }
+  return { ok: true };
+}
+
+/**
+ * 加入一个子项目，返回新配置（不改入参）。
+ *
+ * @param {IdeConfig} config
+ * @param {string} absPath
+ * @param {string} app
+ * @returns {IdeConfig}
+ */
+export function withSubproject(config, absPath, app) {
+  return {
+    root: { ...config.root },
+    children: [...config.children.map((child) => ({ ...child })), { path: absPath, app }],
+  };
+}
+
+/**
+ * 从参数文本里切出子项目路径。
+ *
+ * 斜杠命令的参数是**整串**（`input.prompt.text`），不分词，所以这里自己切：
+ * 取第一个空白分隔的片段。多给的部分是错的，宁可报错也不要猜。
+ *
+ * @param {unknown} text
+ * @returns {{ ok: true, path: string } | { ok: false, message: string }}
+ */
+export function parseSubprojectArgument(text) {
+  const raw = typeof text === 'string' ? text.trim() : '';
+  if (raw === '') return { ok: false, message: '缺少子项目路径参数' };
+  const parts = raw.split(/\s+/);
+  if (parts.length > 1) {
+    return {
+      ok: false,
+      message: `只接受一个参数(子项目路径),收到 ${parts.length} 个:\`${raw}\``,
+    };
+  }
+  return { ok: true, path: parts[0] };
+}
+
+/**
+ * 从参数文本里切出 IDE 名。
+ *
+ * `/open-in-ide pycharm` 是"AI 不配合时的直通逃生口"：正常流程由 AI 向用户提问后
+ * 调工具写回，带参只是保险。空串表示"没给"，由调用方决定是提问还是用默认值。
+ *
+ * @param {unknown} text
+ * @returns {{ ok: true, app: string | undefined } | { ok: false, message: string }}
+ */
+export function parseIdeArgument(text) {
+  const raw = typeof text === 'string' ? text.trim().toLowerCase() : '';
+  if (raw === '') return { ok: true, app: undefined };
+  if (!SUPPORTED_IDES.includes(raw)) {
+    return { ok: false, message: `不支持的 IDE \`${raw}\`,可选:${SUPPORTED_IDES.join(' / ')}` };
+  }
+  return { ok: true, app: raw };
+}

package/src/mcp/enhance.js

@@ -8,52 +8,134 @@
 //   * native  -> `idea.js`      (always present; the IDE owns the catalog)
 //   * plugin  -> this file      (present only if the user installed the plugin)
 //
-// The companion plugin (https://github.com/syllr/idea-mcp-enhance) fills the gaps
-// the bundled server leaves in run configuration handling: the bundled server can
-// only START an existing configuration — it cannot create one, stop one, restart
-// one, or say what is currently running.
+// The companion plugin (https://github.com/syllr/idea-mcp-enhance) fills gaps the
+// bundled server leaves in two places:
+//
+//   * run configuration — the bundled server can only START an existing
+//     configuration; it cannot create one, stop one, restart one, or say what is
+//     currently running;
+//   * deployment — the bundled server has nothing at all for the IDE's
+//     Deployment settings or for moving files to/from a server.
+//
+// The two are kept as separate groups everywhere (here, in the capability
+// functions, and in the guidance), because they are NOT the same precondition:
+// deployment additionally needs `com.jetbrains.plugins.webDeployment`, which
+// exists only in Ultimate. One boolean covering both would let a deployment tool
+// answer "are the run-lifecycle tools here?".
 //
 // Consequence of the split, and the reason it matters: a stock IDE serves a
 // SHORTER catalog than an enhanced one. Nothing here may be assumed — every use
-// has to be gated on the tools really being in the request (`servingRunLifecycleTools`).
+// has to be gated on the tools really being in the request.
 
 /**
- * The enhance plugin's tool names as OpenCode reports them.
+ * The enhance plugin's **run-lifecycle** tool names, as **suffixes**.
+ *
+ * OpenCode namespaces an MCP server's tools with the server name, and each
+ * project is registered under its own prefix (root = `ide`, a subproject = its
+ * directory name). So the wire name is `<prefix><suffix>` — for example
+ * `ide_rerun_run_configuration` or `modelserver_rerun_run_configuration`.
  *
- * OpenCode namespaces an MCP server's tools with the server name, and this
- * plugin registers the IDE server as `idea`, so the wire names are the enhance
- * plugin's own tool names (`list_running_configurations`, ...) carrying an
- * `idea_` prefix.
+ * 存后缀而不是完整名字：同一个工具在每个项目前缀下各有一份，写死任何一个前缀都会
+ * 让别的项目查不到它。
  *
  * Keep in sync with `RunLifecycleSchemas.kt` in the enhance repository — the
- * names are its contract, and there is no runtime way to discover "which plugin
- * provided this tool": MCP carries no such marker.
+ * suffixes are its contract, and there is no runtime way to discover "which
+ * plugin provided this tool": MCP carries no such marker.
  */
-export const CREATE_SHELL_RUN_CONFIGURATION_TOOL = 'idea_create_shell_run_configuration';
-export const LIST_RUNNING_CONFIGURATIONS_TOOL = 'idea_list_running_configurations';
-export const STOP_RUN_CONFIGURATION_TOOL = 'idea_stop_run_configuration';
-export const RERUN_RUN_CONFIGURATION_TOOL = 'idea_rerun_run_configuration';
+export const CREATE_SHELL_RUN_CONFIGURATION_SUFFIX = 'create_shell_run_configuration';
+export const LIST_RUNNING_CONFIGURATIONS_SUFFIX = 'list_running_configurations';
+export const STOP_RUN_CONFIGURATION_SUFFIX = 'stop_run_configuration';
+export const RERUN_RUN_CONFIGURATION_SUFFIX = 'rerun_run_configuration';
 
 /** All of them, in the order the guidance lists them: create, see, stop, restart. */
-export const RUN_LIFECYCLE_TOOLS = [
-  CREATE_SHELL_RUN_CONFIGURATION_TOOL,
-  LIST_RUNNING_CONFIGURATIONS_TOOL,
-  STOP_RUN_CONFIGURATION_TOOL,
-  RERUN_RUN_CONFIGURATION_TOOL,
+export const RUN_LIFECYCLE_SUFFIXES = [
+  CREATE_SHELL_RUN_CONFIGURATION_SUFFIX,
+  LIST_RUNNING_CONFIGURATIONS_SUFFIX,
+  STOP_RUN_CONFIGURATION_SUFFIX,
+  RERUN_RUN_CONFIGURATION_SUFFIX,
+];
+
+/**
+ * The enhance plugin's **deployment** tool names, as suffixes — same contract and
+ * same reason for suffixes as {@link RUN_LIFECYCLE_SUFFIXES}.
+ *
+ * Keep in sync with `DeploymentSchemas.kt` in the enhance repository.
+ *
+ * The four are gated together on one plugin (`com.jetbrains.plugins.webDeployment`,
+ * Ultimate only) rather than on version drift, so they usually appear or vanish as
+ * a set — the guidance still names them one by one, because "usually" is not
+ * "always" and a named tool the model cannot call is only a failed call.
+ */
+export const LIST_DEPLOYMENT_SERVERS_SUFFIX = 'list_deployment_servers';
+export const UPLOAD_TO_DEPLOYMENT_SUFFIX = 'upload_to_deployment';
+export const DOWNLOAD_FROM_DEPLOYMENT_SUFFIX = 'download_from_deployment';
+export const GET_DEPLOYMENT_TASK_STATUS_SUFFIX = 'get_deployment_task_status';
+
+/** All of them: look at the servers, upload, download, then poll a transfer. */
+export const DEPLOYMENT_SUFFIXES = [
+  LIST_DEPLOYMENT_SERVERS_SUFFIX,
+  UPLOAD_TO_DEPLOYMENT_SUFFIX,
+  DOWNLOAD_FROM_DEPLOYMENT_SUFFIX,
+  GET_DEPLOYMENT_TASK_STATUS_SUFFIX,
 ];
 
 /**
- * Which of the enhance plugin's tools this request actually carries.
+ * Does this request carry the tool called `suffix` under `prefix`?
+ *
+ * A malformed or missing snapshot answers "no": assuming a tool exists is the one
+ * mistake that cannot be walked back once the model has read the guidance.
  *
- * A subset rather than a boolean, because the enhance plugin is versioned
- * independently: an older release can ship fewer of these tools, and guidance
- * must never name one the model cannot call.
+ * Exported because the guidance asks this twice. The capability flags (below) ask
+ * "does this request have the tool somewhere" (any project will do); the command
+ * list next to each tool asks "under WHICH prefix", and that answer must be exact —
+ * 提示词里点名一个模型调不到的命令,是这个模块唯一要防的失败。
+ *
+ * @param {Record<string, unknown> | undefined} tools
+ * @param {string} prefix 该项目的工具前缀（含下划线）。
+ * @param {string} suffix
+ */
+export const servesTool = (tools, prefix, suffix) =>
+  Boolean(tools) && typeof tools === 'object' && `${prefix}${suffix}` in tools;
+
+/**
+ * Which of the enhance plugin's tools **this project's prefix** carries in this
+ * request.
+ *
+ * 返回布尔组合而不是名字列表：提示词要的是"这段能不能写",而且每个项目各算各的
+ * —— 一个项目装了 enhance、另一个没装是可能的。
+ *
+ * 客户端版本差异同理：enhance 版本独立发布，旧版可能少几个工具，所以逐个判断,
+ * 提示词绝不能点名一个模型调不到的工具。
  *
  * @param {Record<string, unknown> | undefined} tools This request's tool record
  *   (`event.tools` from the `context` hook).
- * @returns {string[]} The present ones, in {@link RUN_LIFECYCLE_TOOLS} order.
+ * @param {string} prefix 该项目的工具前缀（含下划线）。
+ */
+export function runLifecycleCapabilities(tools, prefix) {
+  return {
+    canCreateRunConfiguration: servesTool(tools, prefix, CREATE_SHELL_RUN_CONFIGURATION_SUFFIX),
+    canListRunningConfigurations: servesTool(tools, prefix, LIST_RUNNING_CONFIGURATIONS_SUFFIX),
+    canStopRunConfiguration: servesTool(tools, prefix, STOP_RUN_CONFIGURATION_SUFFIX),
+    canRerunRunConfiguration: servesTool(tools, prefix, RERUN_RUN_CONFIGURATION_SUFFIX),
+  };
+}
+
+/**
+ * Same question for the deployment group, and the same answer shape — see
+ * {@link runLifecycleCapabilities}.
+ *
+ * The names repeat the tool's subject rather than the group (`canUploadToDeployment`,
+ * not `canUpload`): the guidance is one document about two groups, and a flag whose
+ * owner is unclear is how the wrong section gets the wrong text.
+ *
+ * @param {Record<string, unknown> | undefined} tools
+ * @param {string} prefix 该项目的工具前缀（含下划线）。
  */
-export function servingRunLifecycleTools(tools) {
-  if (!tools || typeof tools !== 'object') return [];
-  return RUN_LIFECYCLE_TOOLS.filter((name) => name in tools);
+export function deploymentCapabilities(tools, prefix) {
+  return {
+    canListDeploymentServers: servesTool(tools, prefix, LIST_DEPLOYMENT_SERVERS_SUFFIX),
+    canUploadToDeployment: servesTool(tools, prefix, UPLOAD_TO_DEPLOYMENT_SUFFIX),
+    canDownloadFromDeployment: servesTool(tools, prefix, DOWNLOAD_FROM_DEPLOYMENT_SUFFIX),
+    canGetDeploymentTaskStatus: servesTool(tools, prefix, GET_DEPLOYMENT_TASK_STATUS_SUFFIX),
+  };
 }

package/src/mcp/idea-tool-defaults.js

@@ -9,8 +9,8 @@
 //
 // ## Why an argument can be owned at all
 //
-// `idea_build_project` is the only way a model can learn whether the code it just
-// wrote compiles, and its verdict depends on file freshness the model cannot see:
+// `<prefix>build_project`(每个项目前缀各一份,例如 `ide_build_project`)是模型判断
+// 刚写的代码能否编译的唯一手段,而它的结论依赖模型看不到的文件新鲜度:
 // an INCREMENTAL build compares against the IDE's own view of the files and
 // recompiles only what that view calls dirty. When the edit happened OUTSIDE the
 // IDE, the view can still be clean and the build becomes a no-op that reports
@@ -47,18 +47,25 @@
 /**
  * Arguments this plugin sets on every call, and therefore must not advertise.
  *
- * @type {ReadonlyArray<{ tool: string, argument: string, value: unknown }>}
+ * 工具用**后缀**标识，不写完整名字：同一个 IDE 工具会以每个项目的前缀各出现一次
+ * (`ide_build_project` / `modelserver_build_project` / ...)，写死 `idea_...` 会让
+ * 多项目场景里只有 root 被命中，子项目那几份原样漏过去 —— 那正是这个模块要避免的
+ * "schema 说一套、调用做另一套"。
+ *
+ * @type {ReadonlyArray<{ suffix: string, argument: string, value: unknown }>}
  */
 export const FORCED_ARGUMENTS = [
   {
-    tool: 'idea_build_project',
+    suffix: 'build_project',
     argument: 'rebuild',
     value: true,
   },
 ];
 
-/** The IDE tool whose verdict must not depend on the IDE's view of file freshness. */
-export const BUILD_PROJECT_TOOL = 'idea_build_project';
+/** 由前缀集合拼出这张表涉及的**全部**真实工具名。 */
+export function forcedToolNames(prefixes) {
+  return prefixes.flatMap((prefix) => FORCED_ARGUMENTS.map((owned) => `${prefix}${owned.suffix}`));
+}
 
 /**
  * Set every owned argument on one call.
@@ -75,15 +82,17 @@ export const BUILD_PROJECT_TOOL = 'idea_build_project';
  *
  * @param {unknown} tool Effective tool name for this call (`event.tool`).
  * @param {unknown} input Mutable argument draft for this call (`event.input`).
+ * @param {readonly string[]} prefixes 本会话所有项目的工具前缀（`ide_` 等）。
  * @returns {boolean} Whether `input` was modified.
  */
-export function applyIdeaToolDefaults(tool, input) {
+export function applyIdeToolDefaults(tool, input, prefixes) {
   if (typeof tool !== 'string') return false;
   if (input === null || typeof input !== 'object') return false;
 
   let changed = false;
   for (const owned of FORCED_ARGUMENTS) {
-    if (owned.tool !== tool) continue;
+    const matches = prefixes.some((prefix) => tool === `${prefix}${owned.suffix}`);
+    if (!matches) continue;
     if (input[owned.argument] === owned.value) continue;
     input[owned.argument] = owned.value;
     changed = true;
@@ -131,6 +140,9 @@ export function removeSchemaProperty(schema, name) {
  * function of what it is given — which is also what makes it testable without a
  * runtime.
  *
+ * 每个项目前缀各处理一遍：同一个 IDE 工具会在工具表里以多份出现，漏掉任何一份都会
+ * 让那一份的 schema 继续广告这个旋钮。
+ *
  * Safe to run when the IDE is absent: `get` returns undefined for a tool that is
  * not registered, and OpenCode replays the transform after every MCP catalog
  * refresh, so the tools are adjusted once they appear.
@@ -139,16 +151,19 @@ export function removeSchemaProperty(schema, name) {
  *   get: (id: string) => { input?: unknown } | undefined,
  *   update: (id: string, update: (tool: { input?: unknown }) => void) => void,
  * }} editor
+ * @param {readonly string[]} prefixes
  */
-export function hideForcedArguments(editor) {
-  for (const owned of FORCED_ARGUMENTS) {
-    const tool = editor.get(owned.tool);
+export function hideForcedArguments(editor, prefixes) {
+  for (const name of forcedToolNames(prefixes)) {
+    const owned = FORCED_ARGUMENTS.find((entry) => name.endsWith(entry.suffix));
+    if (!owned) continue;
+    const tool = editor.get(name);
     if (!tool) continue;
     const next = removeSchemaProperty(tool.input, owned.argument);
     if (next === tool.input) continue;
     // Assign the whole schema: the editor documents that schemas are replaced,
     // not mutated in place.
-    editor.update(owned.tool, (draft) => {
+    editor.update(name, (draft) => {
       draft.input = next;
     });
   }