opencode-idea 0.0.11 → 0.0.12

package/README.md

@@ -1,12 +1,15 @@
 # opencode-idea
 
-OpenCode 插件,面向 JetBrains 项目 (IntelliJ IDEA / PyCharm / WebStorm 等),做三件事:
+OpenCode 插件,面向 JetBrains 项目 (IntelliJ IDEA / PyCharm / WebStorm 等),做两件事:
 
 1. **接入 IDE MCP** —— 用 `/open-in-idea` 把当前项目在 IntelliJ IDEA 中打开,并把这个 IDE 的 MCP 服务 (60 个工具:
    检索、读、改、构建、重构、调试、数据库……)注册进 OpenCode。
 2. **优先使用 IDE 工具** —— IDE 可用时,向模型注入"项目内操作优先使用 IDEA MCP"的系统提示引导 + 能力映射;IDE 不可用时回退原生工具
    (正常回退,无需声明)。
-3. **注入 IDE 环境变量** —— 从 IDE 集成终端读取它实际运行的环境,注入每个 OpenCode shell。
+
+> **项目命令走 IDE 终端**:跑 `java` / `python` / `npm` 这类项目命令时,引导模型用 `idea_execute_terminal_command`
+> (`executeInShell: true`)而不是原生 shell —— 它在 IDE 集成终端里执行,**天然继承用户在 IDE 里配好的 JDK / Node / Python 版本**
+> (含 fnm / SDKMAN 这类靠 shell init 切版本的场景)。详见「项目命令执行」。
 
 非 JetBrains 项目完全不受影响。 **手动接入**:插件启动不探测、不连接 IDE,只有跑 `/open-in-idea` 才接入。跑过一次后,该**项目**
 被「标记」(持久化在 `ctx.storage`,重启 OpenCode 后仍在):之后插件在后台**每 5s 探活**该 IDE——**掉线就注销 `idea` MCP**(杀掉不会自愈的
@@ -18,14 +21,15 @@ stdio 僵尸桥 + 移除 `idea_*` 工具,让模型调不到、**不会挂起**),
 ```text
 setup(启动, 每项目一次):
   a. 读项目标记(ctx.storage: project/<项目路径>; OpenCode 重启后仍生效)
-  b. 读 IDE 集成终端环境 → 通过 shell create.before 钩子注入每个 shell(null: 未连 IDE 时为空)
-  c. 注册 /open-in-idea 与 /close-in-idea 命令 + session context 钩子 + tool execute.after 钩子
+  b. 注册 /open-in-idea 与 /close-in-idea 命令 + session context 钩子 + tool execute.after 钩子
   不探测、不注册 MCP
 
 /open-in-idea(手动触发, 阻塞到就绪):
   1. 写项目标记 = true + 同步内存缓存;注册 `idea-run-config` skill
   2. 探测本地 JetBrains IDE MCP 服务(/stream)
-  3. 未就绪 → open -a "IntelliJ IDEA" <项目目录>(复用已运行实例),然后轮询等到 MCP 就绪(冷启动约数十秒,上限 60s)
+     - 已就绪 → 再问 IDE「当前项目是否已打开」(`get_project_modules`,带项目路径)
+       · 已打开 → 不重复 open;未打开 → open -a 打开
+     - 未就绪(冷启动)→ open -a 拉起,再轮询等到就绪(上限 60s)
   4. **先注销旧的 idea MCP(杀掉旧的 stdio 桥子进程),再重新注册**
      (`idea stdioMcpServer`,env 带项目路径 + 端口;每项目一个子进程)
      —— 每次执行都重建,因为断掉的桥不会自愈、也不能靠 refresh 复活
@@ -57,12 +61,14 @@ setup(启动, 每项目一次):
 
 在会话里输入 `/open-in-idea`:
 
-1. 先探测 `/stream`;已就绪 → 直接进入下一步;
-2. 未就绪 → 用 `open -a "IntelliJ IDEA" <项目目录>` 拉起或激活 IDEA —— **复用已运行的实例**(不会重复开新实例),然后
-   **轮询等到 MCP 就绪**(冷启动约数十秒,上限 60s);
-3. 等不到(例如 IDE 里 MCP 服务未开启)→ 提示在 IDEA 的 `Settings → MCP Server` 开启 MCP 服务并启用 **Brave Mode**,用户设置好后
+1. **让运行中的 IDEA 实例打开/激活当前项目**:`open -a "IntelliJ IDEA" <项目目录>` —— **复用已运行的实例**(不会重复开新实例),
+   项目已打开时只把它切到前台。**无论 MCP 是否已就绪都会执行这一步**:端点能应答只说明 IDEA 在运行(可能开的是**别的**项目),
+   不代表当前项目已打开;
+2. 再探测 `/stream`;已就绪 → 直接进入下一步;
+3. 未就绪 → 说明 IDEA 是冷启动,继续用 `open -a` 拉起并**轮询等到 MCP 就绪**(冷启动约数十秒,上限 60s);
+4. 等不到(例如 IDE 里 MCP 服务未开启)→ 提示在 IDEA 的 `Settings → MCP Server` 开启 MCP 服务并启用 **Brave Mode**,用户设置好后
    再次执行 `/open-in-idea`;
-4. 就绪后 **先注销旧的 `idea` MCP(杀掉旧的 stdio 桥子进程)→ 再重新注册**(每次执行都重建,因为断掉的桥不会自愈),然后重读
+5. 就绪后 **先注销旧的 `idea` MCP(杀掉旧的 stdio 桥子进程)→ 再重新注册**(每次执行都重建,因为断掉的桥不会自愈),然后重读
    IDE 环境、启用系统引导,并**等到 `idea_*` 工具进入注册表**才返回。
 
 > **通知不触发 AI 干活**:默认 `feedback: "message"` 把结果作为一条 **标注清楚的通知**发到会话里 —— 用户看到干净的通知气泡
@@ -118,20 +124,26 @@ IDE MCP 只能 **查**(`get_run_configurations`)和 **执行**(`execute_run_conf
 `setup` 时(读回标记)就会注册。未标记的项目不受影响。文档放在 `skills/<id>/SKILL.md`(每个 skill 一个目录,`name` /
 `description` 走 YAML frontmatter),由 `src/skill/loader.js` 扫描加载 —— **加新 skill 只需加一个目录,不用改代码**。
 
-## 环境变量注入
+## 项目命令执行 (IDE 终端)
+
+跑项目相关的命令时,模型使用 **`idea_execute_terminal_command`**,而不是 OpenCode 原生 shell。判据是**命令是否依赖项目的
+工具链 / 运行时 / 依赖环境**,而不是语言或工具名:
 
-**唯一来源:IDE 集成终端**(`execute_terminal_command printenv`)。它反映 IDE 实际运行的环境 —— 这些环境往往在 .idea
-配置里读不到。
+- **走 IDE 终端**:任何会调用项目工具链的命令 —— Java / Python / Node / Go 的运行时,以及 Maven / Gradle、uv / pip /
+  poetry、cargo、bundler、make / cmake、包管理器、构建、测试、代码生成等。
+- **走原生 shell**:纯操作系统级的通用命令(`ls` / `cat` / `cp` / `mkdir` / `git` 等)。
 
-抽取的变量 (`src/mcp/ide-env.js` 的 `SDK_ENV_KEYS`):`JAVA_HOME` / `JRE_HOME` / `JDK_HOME` / `VIRTUAL_ENV` / `PYTHONPATH` /
-`PYTHONHOME` / `GOROOT` / `GOPATH` / `GOBIN` / `NODE_PATH` / `NVM_BIN` / `NVM_DIR` / `MAVEN_HOME` / `M2_HOME` /
-`GRADLE_HOME` / `SDKMAN_DIR` / `CONDA_PREFIX`。
+原因:
 
-- 注入通过 V2 的 `shell` `create.before` 钩子:只补这些变量 + 前置 PATH,不覆盖你原有的 PATH。
-- 需要 IDE MCP 可达 + **Brave Mode**;拿不到时环境为空 (不影响其他功能)。
+- **`executeInShell: true`**(必开):命令在用户真实 shell(`zsh`/`bash`)里执行,**继承 IDE 集成终端的环境** —— 也就是用户在
+  IDE 里配好的 JDK / Node / Python / Go / Maven / uv 等。原生 shell 未必能拿到同一套版本,尤其是 fnm / SDKMAN / pyenv 这类
+  "选择写在 shell init 里"的版本管理器,靠几个环境变量复现不出来。
+- `timeout`(毫秒)按预期耗时给足;`maxLinesCount` 控制返回行数,超 2000 行会截断。
+- `reuseExistingTerminalWindow: true` 复用同一个 IDE 终端窗口,不刷屏。
+- 返回 `command_exit_code` + `command_output`;`cd` **不跨调用保留**,多步操作用 `&&` 串在一条命令里。
+- 需要 IDE 里开启 **Brave Mode**,否则每条命令都要用户确认一次。
 
-> 与 [opencode-env-loader](https://github.com/syllr/opencode-env-loader) 的关系:两者独立。env-loader 负责
-> `.opencode/env-loader/*` 的 **人工** KEY=VALUE 覆盖;本插件负责从 **IDE 实际环境**推导。可以同时使用。
+引导文本由 `src/ide-guidance.js` 注入(`### 终端` 段),只在 IDE MCP 可用时生效。
 
 ## 前置条件
 
@@ -232,7 +244,6 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
       "package": "opencode-idea",
       "options": {
         "ports": [64342], // IDE MCP 端口;默认 [64342]
-        "injectEnv": true,
         "injectGuidance": true, // IDE 可用时向系统提示注入「优先使用 IDEA MCP」引导
         "openInIde": "idea", // false 关闭;或任意 macOS 应用名(如 "IntelliJ IDEA")
         "transport": "stdio", // "stdio"(默认,本地桥,不会空闲断流)| "http"(远程 Streamable HTTP)
@@ -255,7 +266,6 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
 | 选项                  | 类型                 | 默认        | 说明                                                                                    |
 | --------------------- | -------------------- | ----------- | --------------------------------------------------------------------------------------- |
 | `ports`               | `number[]`           | `[64342]`   | 依次探测的 IDE MCP 端口                                                                 |
-| `injectEnv`           | `boolean`            | `true`      | 是否注入 IDE 终端环境变量                                                               |
 | `injectGuidance`      | `boolean`            | `true`      | IDE 可用时是否向系统提示注入「优先使用 IDEA MCP」引导                                   |
 | `openInIde`           | `boolean \| string`  | `"idea"`    | 拉起哪个 IDE;`false` 关闭,`"idea"` 映射到 IntelliJ IDEA                                 |
 | `transport`           | `"stdio" \| "http"`  | `"stdio"`   | `stdio` 注册 IDE 自带的 stdio 桥(本地子进程,不会空闲断流);`http` 用远程 Streamable HTTP |
@@ -301,13 +311,15 @@ export { default } from "/Users/yutao/Projects/opencode-idea/src/index.js";
 - skill 定义的字段名**以 schema 为准**,不要照官方文档:`Skill.Info` 需要 `path` (AbsolutePath),文档里写的 `location`
   不存在 —— 用错会让 `ctx.skill.transform` 抛 `SchemaError`,而**任何 transform 失败都会禁用整个插件**(0.0.6 就是这样丢了
   `/open-in-idea`)。同理,`Skill.Info` 的完整字段是 `id` / `name` / `description?` / `autoinvoke?` / `path` / `content`。
-- 环境变量依赖 `execute_terminal_command` + Brave Mode;拿不到时环境为空。
+- 项目命令走 `idea_execute_terminal_command` + **Brave Mode**;没开 Brave Mode 时每条命令都要用户确认一次。
 - 一批用不到的 IDEA MCP 工具被硬编码隐藏 (`src/plugin.js` 的 `HIDDEN_IDEA_TOOLS`,共 31 个):VCS (`idea_git_status` /
   `idea_get_repositories`,版本控制走原生 `git`)、Router 派发工具 (`idea_execute_tool`,未启用 router-only 时冗余)、Debugger
   (全部 `idea_xdebug_*`)、Dev Kit MCP、Inspection KTS MCP、解释器环境 MCP、以及数据库的建/改数据源 (数据源由用户在
-  IDEA 里配置,AI 只读和查询)。`idea_execute_terminal_command` 也不暴露给模型 —— 它只由插件内部读取 IDE 环境,而那是插件直接调
-  MCP,不经过模型工具表。
-- 探测只确认「MCP 服务是否在监听」,不校验「当前项目是否已在 IDE 打开」;MCP 关闭时会用一次短探测并立即给出设置提示。
+  IDEA 里配置,AI 只读和查询)。**`idea_execute_terminal_command` 不隐藏**:项目命令要在 IDE 环境里跑,模型需要它。
+- 探测只确认「MCP 服务是否在监听」;**「当前项目是否已在 IDE 打开」靠一次项目作用域的 MCP 调用判断**
+  (`get_project_modules`,带 `IJ_MCP_SERVER_PROJECT_PATH`):返回模块 = 已打开 → 跳过 `open -a`;报
+  `Unable to determine the target project` = 未打开 → `open -a` 打开。MCP 关闭时会用一次短探测并立即给出设置提示。
+  项目刚打开时的短暂"项目未就绪"由工具失败分类兜底(「IDE 在、但项目没打开」→ 重新打开并让模型重试)。
 - IDE **2026.2+** 提供官方 stdio 桥 (`idea stdioMcpServer`),插件默认用它注册。stdio 是子进程管道,不像 Streamable HTTP 那样
   会空闲断流;但它**启动时要求 IDE MCP 已在监听**,所以 `/open-in-idea` 必须先等就绪再注册(冷启动约数十秒)。`transport: "http"`
   可切回远程 Streamable HTTP(OpenCode 会因连接关闭把 server 置 failed 并移除工具,不自动重连)。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-idea",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "OpenCode plugin that connects to JetBrains IDE MCP servers and prefers IDE tools when the current project is open in the IDE",
   "main": "src/index.js",
   "type": "module",
@@ -9,9 +9,7 @@
     "src/index.js",
     "src/plugin.js",
     "src/mcp/idea.js",
-    "src/mcp/ide-env.js",
     "src/project.js",
-    "src/env.js",
     "src/ide-launcher.js",
     "src/ide-guidance.js",
     "src/skill/loader.js",

package/src/ide-guidance.js

@@ -60,6 +60,17 @@ export function buildIdeGuidance(projectPath) {
     `- \`idea_get_run_configurations\`:读项目级 \`.run/*.run.xml\`(增删改直接改文件);传 \`filePath\` 可列该文件的运行入口。`,
     `- \`idea_execute_run_configuration\`:跑已有配置;Shell Script 要 \`EXECUTE_IN_TERMINAL: false\`;覆盖参数(\`programArguments\` / \`workingDirectory\` / \`envs\`)需配置支持 \`supportsDynamicLaunchOverrides\`。`,
     ``,
+    `### 终端`,
+    `- \`idea_execute_terminal_command\`:**项目内的一切命令执行都用它**,不要用原生 \`shell\`。`,
+    `  判据是"命令是否依赖项目的工具链 / 运行时 / 依赖环境",不是语言或工具名 —— Java、Python、Node、Go 之外,`,
+    `  Maven / Gradle、uv / pip / poetry、cargo、bundler、make / cmake、包管理器与构建、测试、代码生成等,全都算。`,
+    `  例外:纯操作系统级的通用命令(\`ls\` / \`cat\` / \`cp\` / \`mkdir\` / \`git\` 等)用原生 \`shell\` 即可。`,
+    `  记不清就不确定时:只要命令会调用项目的工具链,就用它,不要退回原生 \`shell\`。`,
+    `  - 必须 \`executeInShell: true\`:在用户真实 shell 里执行,**天然继承 IDE 里配好的运行时环境**(JDK / Node / Python / Go / Maven / uv 等及各版本管理器);原生 shell 可能用错版本。`,
+    `  - 按预期耗时传 \`timeout\`(毫秒),长任务给足;必要时传 \`maxLinesCount\` 控制返回行数。`,
+    `  - 连续命令传 \`reuseExistingTerminalWindow: true\`,复用同一个 IDE 终端窗口。`,
+    `  - 结果带 \`command_exit_code\` 与 \`command_output\`;\`cd\` 不跨调用保留,多步时在一条命令里用 \`&&\`。`,
+    ``,
     `### 数据库 (数据源由用户在 IDE 里配置:不要自己建/改,不要向用户索取数据库凭据)`,
     `- \`idea_list_database_connections\`:先看有没有现成数据源;每条给 \`id\` / \`dbms\` / \`jdbcUrl\` / \`readOnly\` / \`isDDL\`。`,
     `- \`idea_test_database_connection\`(\`id\`):\`hasProblems\` 为 \`NO\` 才算通,另带 DBMS / 驱动版本与 ping。`,

package/src/mcp/idea.js

@@ -146,7 +146,7 @@ export async function probePort(port, options = {}) {
         params: {
           protocolVersion: PROTOCOL_VERSION,
           capabilities: {},
-          clientInfo: { name: 'opencode-idea', version: '0.0.11' },
+          clientInfo: { name: 'opencode-idea', version: '0.0.12' },
         },
       }),
       signal: controller.signal,
@@ -197,34 +197,43 @@ export async function callTool(port, projectPath, name, args = {}, options = {})
   const fetchImpl = options.fetchImpl ?? fetch;
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? CALL_TIMEOUT_MS);
-  const post = (payload) =>
+  const post = (payload, sessionId) =>
     fetchImpl(`http://127.0.0.1:${port}${MCP_STREAM_PATH}`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
         Accept: 'application/json, text/event-stream',
         [PROJECT_HEADER]: projectPath,
+        ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {}),
       },
       body: JSON.stringify(payload),
       signal: controller.signal,
     });
   try {
-    await post({
+    const initialized = await post({
       jsonrpc: '2.0',
       id: 1,
       method: 'initialize',
       params: {
         protocolVersion: PROTOCOL_VERSION,
         capabilities: {},
-        clientInfo: { name: 'opencode-idea', version: '0.0.11' },
+        clientInfo: { name: 'opencode-idea', version: '0.0.12' },
       },
     });
-    const response = await post({
-      jsonrpc: '2.0',
-      id: 2,
-      method: 'tools/call',
-      params: { name, arguments: args },
-    });
+    // The IDE's Streamable-HTTP endpoint binds follow-up requests to the session
+    // created by `initialize`: without echoing its `Mcp-Session-Id` header the
+    // server rejects the call with "Bad Request: Server not initialized"
+    // (verified against IntelliJ IDEA 2026.2.3).
+    const sessionId = initialized.headers?.get?.('mcp-session-id') ?? undefined;
+    const response = await post(
+      {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/call',
+        params: { name, arguments: args },
+      },
+      sessionId,
+    );
     if (!response.ok) return undefined;
     const message = await parseToolResponse(response);
     if (!message || message.error) return undefined;

package/src/plugin.js

@@ -1,28 +1,29 @@
 // opencode-idea — OpenCode plugin entry.
 //
 // For a project the user opted into IDEA this plugin:
-//   1. injects the IDE integrated-terminal environment (JAVA_HOME / GOROOT /
-//      Node / Maven / ...) into every OpenCode shell;
-//   2. registers the IDE MCP server with OpenCode — by default as the IDE's
+//   1. registers the IDE MCP server with OpenCode — by default as the IDE's
 //      stdio bridge (`idea stdioMcpServer`), scoped to the project through
 //      `IJ_MCP_SERVER_PROJECT_PATH` — injects direct-call guidance for IDEA MCP
 //      tools, and updates only IDEA MCP tool descriptions;
-//   3. registers the `/open-in-idea` command, which opens the current project
+//   2. registers the `/open-in-idea` command, which opens the current project
 //      in IntelliJ IDEA (reusing a running instance), loads the IDE
 //      capabilities immediately, and marks the project as an IDEA project;
 //      `/close-in-idea` clears that mark;
-//   4. registers the `idea-run-config` skill (marked projects only), which
+//   3. registers the `idea-run-config` skill (marked projects only), which
 //      teaches the model how to manage `.run/*.run.xml` run configurations — a
 //      capability the IDE MCP server does not expose.
 //
 // A project that was never marked is left untouched. Everything is manual:
-// setup does NOT probe or connect the IDE (only the IDE-terminal env is read
-// when a probe is requested). `/open-in-idea` probes, opens the IDE, and loads
-// the IDE MCP + guidance on demand.
+// setup does NOT probe or connect the IDE. `/open-in-idea` probes, opens the
+// IDE, and loads the IDE MCP + guidance on demand.
 //
 // `/open-in-idea` opens the project in the IDE, waits until its MCP endpoint is
 // ready, registers `idea` (stdio, project-scoped) and marks the project in
 // `ctx.storage`; `/close-in-idea` unregisters the server and clears the mark.
+// A live endpoint alone does NOT mean our project is open there (the running IDE
+// may have a different project open), so the open flow asks the IDE directly —
+// one project-scoped MCP call — and runs `open -a` only when the project is not
+// open yet.
 // The mark gates the IDEA skills and the failure-driven recovery. After a manual
 // open, an `idea_*` call that fails because the IDE MCP is not usable (the server
 // dropped, or the project is not open in the IDE) re-runs the open flow; a plain
@@ -39,13 +40,12 @@
 import {
   DEFAULT_PORTS,
   IDEA_SERVER_NAME,
+  callTool,
   findIdePort,
   serverConfig,
   stdioServerConfig,
 } from './mcp/idea.js';
-import { readIdeTerminalEnv } from './mcp/ide-env.js';
 import { currentProjectPath } from './project.js';
-import { applyEnv, mergeEnv } from './env.js';
 import {
   createLaunchGuard,
   DEFAULT_IDE_APP,
@@ -106,9 +106,18 @@ const IDEA_READY_TOOL_IDS = new Set(['idea_read_file', 'idea_apply_patch']);
  * - Inspection KTS MCP: inspection.kts authoring helpers (PSI tree, API docs,
  *   examples, run). Also IntelliJ Platform plugin-development only.
  * - Python Environment MCP: Python interpreter detection and configuration.
- *   Hidden; the IDE-injected shell env already carries the SDK paths.
+ *   Hidden; project commands run through the IDE terminal instead, which is
+ *   already launched with the IDE's real environment.
  * - Database data sources: connections are configured by the user in the IDE,
  *   so the AI only reads and queries them; create/edit stay hidden.
+ *
+ * NOT hidden: `idea_execute_terminal_command`. Project commands must run with
+ * the SDKs the user configured in the IDE (JDK, Node, Python, ...), so the model
+ * uses the IDE's integrated terminal for them. `executeInShell: true` runs the
+ * command in the user's real shell (`zsh`/`bash`), which inherits the IDE
+ * environment — including version managers such as fnm / SDKMAN whose selection
+ * lives in shell init and cannot be reconstructed from a handful of variables.
+ * Requires Brave Mode in the IDE; without it the IDE asks for confirmation.
  */
 export const HIDDEN_IDEA_TOOLS = [
   // VCS
@@ -116,11 +125,6 @@ export const HIDDEN_IDEA_TOOLS = [
   'idea_get_repositories',
   // Router
   'idea_execute_tool',
-  // Terminal: the plugin reads the IDE env through its own direct MCP call
-  // (`src/mcp/ide-env.js`), so the model never needs this tool. Measured value for
-  // the agent is nil: ~60s hard cutoff with no way to read the terminal buffer,
-  // and the native shell already keeps the output tail plus a full-output file.
-  'idea_execute_terminal_command',
   // Debugger
   'idea_xdebug_control_session',
   'idea_xdebug_evaluate_expression',
@@ -333,7 +337,6 @@ export default {
    *   location?: unknown,
    *   options?: {
    *     ports?: number[],
-   *     injectEnv?: boolean,
    *     openInIde?: boolean | string,
    *     launchCooldownMs?: number,
    *     launchMaxAttempts?: number,
@@ -402,7 +405,6 @@ export default {
 
     const options = ctx.options || {};
     const ports = asArray(options.ports, DEFAULT_PORTS);
-    const injectEnv = options.injectEnv !== false;
     const injectGuidance = options.injectGuidance !== false;
     const ideApp = resolveIdeApp(options.openInIde);
     // Transport for the IDE MCP server. `stdio` (default) registers the IDE's
@@ -435,13 +437,10 @@ export default {
       cooldownMs: asPositiveNumber(options.launchCooldownMs, DEFAULT_LAUNCH_COOLDOWN_MS),
       maxAttempts: asPositiveNumber(options.launchMaxAttempts, DEFAULT_LAUNCH_MAX_ATTEMPTS),
     });
-    let currentEnv = { env: {}, prependPath: [] };
 
     /** @type {Array<{ dispose: () => Promise<void> | void }>} */
     let registrations = [];
     /** @type {{ dispose: () => Promise<void> | void } | undefined} */
-    let shellRegistration;
-    /** @type {{ dispose: () => Promise<void> | void } | undefined} */
     let sessionRegistration;
     /** @type {{ dispose: () => Promise<void> | void } | undefined} */
     let toolRegistration;
@@ -573,22 +572,10 @@ export default {
       const port = probeIde ? await findIdePort(ports, { timeoutMs: mcpProbeTimeoutMs }) : undefined;
       const isJetBrains = markCache === true || port !== undefined;
       if (!isJetBrains) {
-        currentEnv = { env: {}, prependPath: [] };
         await deactivateIde();
         return false;
       }
 
-      // Environment: read from the IDE integrated terminal, the single source
-      // of truth for the environment the IDE actually runs with (version-managed
-      // Node, goenv Go, SDKMAN Java, Maven, ...). Only available once the IDE is
-      // connected, which is why the manual `/open-in-idea` drives it.
-      const terminal = port === undefined ? {} : await readIdeTerminalEnv(port, projectPath);
-      currentEnv = mergeEnv([{ env: terminal }]);
-
-      if (injectEnv && !shellRegistration) {
-        shellRegistration = await ctx.shell.hook('create.before', (input) => applyEnv(input, currentEnv));
-      }
-
       // Always tear the server down and register it again. A stdio bridge whose
       // IDE connection dropped becomes a permanent zombie: the child process is
       // still alive, so OpenCode keeps reporting it as connected, never restarts
@@ -635,6 +622,35 @@ export default {
       return undefined;
     };
 
+    /**
+     * Is `projectPath` actually OPEN in the IDE that serves `port`?
+     *
+     * A live endpoint only means the IDE is RUNNING — it may have a different
+     * project open (or sit on the Welcome screen), while everything we do is
+     * scoped to THIS project. So ask the IDE directly with one project-scoped
+     * call: the server resolves the project from `IJ_MCP_SERVER_PROJECT_PATH`
+     * BEFORE running the tool, and for a project that is not open it fails with
+     * "Unable to determine the target project ..." — the same shape
+     * `classifyIdeaFailure` maps to `project`. Any other outcome (a real result,
+     * or an unrelated tool error) means the project WAS resolved, i.e. open.
+     *
+     * A transport failure (`undefined`) counts as "not confirmed open", so the
+     * caller still asks the IDE to open the project: `open -a` is idempotent,
+     * and the only cost is a redundant focus.
+     *
+     * @param {number} port
+     */
+    const isProjectOpen = async (port) => {
+      const result = await callTool(port, projectPath, 'get_project_modules', {}).catch(() => undefined);
+      if (!result) return false;
+      if (result.isError !== true) return true;
+      const text = (result.content ?? [])
+        .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join('\n');
+      return classifyIdeaFailure({ message: text }) !== 'project';
+    };
+
     // Re-entrant: repeat invocations share one open request so the IDE is not
     // spawned twice while the application is starting.
     /** @type {Promise<IdeCommandResult> | undefined} */
@@ -659,6 +675,14 @@ export default {
         if (serving !== undefined) {
           guard.reset();
           launchNoticeSent = false;
+          // The endpoint being up proves only that the IDE is RUNNING — it may
+          // have a DIFFERENT project open. Ask the IDE whether THIS project is
+          // open, and only request an open when it is not: for an already-open
+          // project the IDE runs a short reopen-then-dispose cycle on a
+          // redundant open event, so skipping it is a real saving.
+          if (ideApp && !(await isProjectOpen(serving))) {
+            await openInIde(projectPath, { app: ideApp });
+          }
           return { status: 'connected', port: serving, unavailableNoticeSent: false };
         }
         if (!ideApp) return { status: 'disabled' };
@@ -937,13 +961,6 @@ export default {
     return async () => {
       disposed = true;
       if (heartbeatTimer) clearInterval(heartbeatTimer);
-      if (shellRegistration) {
-        try {
-          await shellRegistration.dispose();
-        } catch {
-          // best effort
-        }
-      }
       if (sessionRegistration) {
         try {
           await sessionRegistration.dispose();

package/src/env.js

@@ -1,39 +0,0 @@
-// Merges environment sources and applies them to a shell `create.before`
-// invocation.
-
-import path from 'node:path';
-
-/**
- * Merge env sources. Later sources win. `prependPath` entries are collected in
- * order and applied ahead of the existing PATH.
- *
- * @param {Array<{ env?: Record<string, string>, prependPath?: string[] }>} sources
- * @returns {{ env: Record<string, string>, prependPath: string[] }}
- */
-export function mergeEnv(sources) {
-  const env = {};
-  const prependPath = [];
-  for (const source of sources) {
-    Object.assign(env, source.env ?? {});
-    prependPath.push(...(source.prependPath ?? []));
-  }
-  return { env, prependPath: [...new Set(prependPath)] };
-}
-
-/**
- * Apply a merged env to a shell invocation's `env` in place.
- *
- * @param {{ env: Record<string, string | undefined> }} input
- * @param {{ env: Record<string, string>, prependPath: string[] }} merged
- * @param {{ pathKey?: string }} [options]
- */
-export function applyEnv(input, merged, options = {}) {
-  const pathKey = options.pathKey ?? 'PATH';
-  for (const [key, value] of Object.entries(merged.env)) {
-    if (value !== undefined) input.env[key] = value;
-  }
-  if (merged.prependPath.length === 0) return;
-  const current = input.env[pathKey] ?? process.env[pathKey] ?? '';
-  const parts = [...merged.prependPath, ...current.split(path.delimiter).filter(Boolean)];
-  input.env[pathKey] = [...new Set(parts)].join(path.delimiter);
-}

package/src/mcp/ide-env.js

@@ -1,101 +0,0 @@
-// Reads the IDE terminal environment over MCP and extracts the SDK-related
-// variables. The IDE terminal is the single source of truth for the environment
-// the IDE actually runs with (version-managed Node, goenv Go, SDKMAN Java, ...).
-
-import { callTool } from './idea.js';
-
-/** SDK-related variables worth mirroring into OpenCode's shell environment. */
-export const SDK_ENV_KEYS = [
-  'JAVA_HOME',
-  'JRE_HOME',
-  'JDK_HOME',
-  'VIRTUAL_ENV',
-  'PYTHONPATH',
-  'PYTHONHOME',
-  'GOROOT',
-  'GOPATH',
-  'GOBIN',
-  'NODE_PATH',
-  'NVM_BIN',
-  'NVM_DIR',
-  'MAVEN_HOME',
-  'M2_HOME',
-  'GRADLE_HOME',
-  'SDKMAN_DIR',
-  'CONDA_PREFIX',
-];
-
-/**
- * Read SDK env from the IDE integrated terminal via `execute_terminal_command`.
- * Requires the IDE MCP to be reachable and Brave Mode enabled (else the IDE
- * waits for a confirmation and this returns `{}`).
- *
- * @param {number} port
- * @param {string} projectPath
- * @param {typeof fetch} [fetchImpl]
- * @returns {Promise<Record<string, string>>}
- */
-export async function readIdeTerminalEnv(port, projectPath, fetchImpl = fetch) {
-  const result = await callTool(
-    port,
-    projectPath,
-    'execute_terminal_command',
-    { command: 'printenv', executeInShell: true, timeout: 8000, maxLinesCount: 800 },
-    { fetchImpl, timeoutMs: 15000 },
-  ).catch(() => undefined);
-  if (!result || result.isError) return {};
-  const text = (result.content ?? [])
-    .filter((part) => part.type === 'text' && typeof part.text === 'string')
-    .map((part) => part.text)
-    .join('\n');
-  return extractSdkEnv(parseCommandOutput(text));
-}
-
-/**
- * Parse the `execute_terminal_command` payload. It is JSON with a
- * `command_output` field; fall back to treating the text as raw env output.
- *
- * @param {string} text
- * @returns {Record<string, string>}
- */
-export function parseCommandOutput(text) {
-  try {
-    const parsed = JSON.parse(text);
-    if (parsed && typeof parsed.command_output === 'string') return parsePrintenv(parsed.command_output);
-  } catch {
-    // not JSON — treat as raw printenv output
-  }
-  return parsePrintenv(text);
-}
-
-/**
- * Parse `KEY=VALUE` lines (printenv output) into an object.
- *
- * @param {string} text
- * @returns {Record<string, string>}
- */
-export function parsePrintenv(text) {
-  const env = {};
-  for (const line of text.split('\n')) {
-    const index = line.indexOf('=');
-    if (index <= 0) continue;
-    const key = line.slice(0, index).trim();
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
-    env[key] = line.slice(index + 1);
-  }
-  return env;
-}
-
-/**
- * Keep only the SDK-related variables.
- *
- * @param {Record<string, string>} env
- * @returns {Record<string, string>}
- */
-export function extractSdkEnv(env) {
-  const out = {};
-  for (const key of SDK_ENV_KEYS) {
-    if (env[key]) out[key] = env[key];
-  }
-  return out;
-}