opencode-idea 0.0.10 → 0.0.12

package/src/mcp/idea.js

@@ -6,11 +6,10 @@
 //   * The IDE exposes a local MCP server. IntelliJ 2026.2+ exposes the modern
 //     Streamable-HTTP endpoint at `http://127.0.0.1:<port>/stream`; older builds
 //     only had the legacy SSE endpoint at `/sse`.
-//   * OpenCode V2's remote MCP client speaks ONLY Streamable HTTP, so the plugin
-//     registers `/stream` (see `serverConfig`). The legacy `/sse` endpoint is
-//     unusable from OpenCode (POST returns 405 → "Error POSTing to endpoint").
-//   * The project a call targets is selected by the HTTP header
-//     `IJ_MCP_SERVER_PROJECT_PATH`.
+//   * The project a call targets is selected by the project path: the HTTP
+//     header `IJ_MCP_SERVER_PROJECT_PATH` for the remote transport, or the
+//     `IJ_MCP_SERVER_PROJECT_PATH` environment variable for the stdio bridge
+//     (see `serverConfig` / `stdioServerConfig`).
 //   * Availability probe: a single `initialize` POST to `/stream` succeeds when
 //     the MCP server is up. We do NOT check whether a specific project is open —
 //     the user triggers `/open-in-idea` for the project they want, so "server is
@@ -18,6 +17,15 @@
 
 export const PROJECT_HEADER = 'IJ_MCP_SERVER_PROJECT_PATH';
 
+/** Environment variable the IDE's stdio bridge uses to select the project. */
+export const PROJECT_ENV = 'IJ_MCP_SERVER_PROJECT_PATH';
+
+/** Environment variable the IDE's stdio bridge uses to reach the running server. */
+export const PORT_ENV = 'IJ_MCP_SERVER_PORT';
+
+/** Argument that puts the IDE launcher into its stdio MCP bridge mode. */
+export const STDIO_ARG = 'stdioMcpServer';
+
 /** OpenCode MCP server name registered for the IDE. */
 export const IDEA_SERVER_NAME = 'idea';
 
@@ -44,16 +52,73 @@ const CALL_TIMEOUT_MS = 15000;
  *
  * @param {number} port
  * @param {string} projectPath
+ * @param {{ executionTimeoutMs?: number }} [options]
  */
-export function serverConfig(port, projectPath) {
-  return {
+export function serverConfig(port, projectPath, options = {}) {
+  /** @type {Record<string, unknown>} */
+  const config = {
     type: 'remote',
     url: `http://127.0.0.1:${port}${MCP_STREAM_PATH}`,
     headers: { [PROJECT_HEADER]: projectPath },
     codemode: false,
   };
+  return withExecutionTimeout(config, options);
+}
+
+/**
+ * Build the OpenCode MCP server config for the IDE's **stdio bridge**.
+ *
+ * The IDE launcher (`<App>.app/Contents/MacOS/<binary>`) with the
+ * `stdioMcpServer` argument runs a small proxy that speaks MCP over
+ * stdin/stdout and connects to the running IDE MCP server selected by the
+ * environment. That makes the client side a child-process pipe instead of a
+ * Streamable-HTTP stream, so it does not suffer the idle-close that the remote
+ * transport does. The project and port are carried in the environment, matching
+ * what the remote config carries in a header and URL.
+ *
+ * @param {string} executable absolute path to the IDE launcher
+ * @param {number} port IDE MCP port to bridge to
+ * @param {string} projectPath project root the bridge should target
+ * @param {{ executionTimeoutMs?: number }} [options]
+ */
+export function stdioServerConfig(executable, port, projectPath, options = {}) {
+  /** @type {Record<string, unknown>} */
+  const config = {
+    type: 'local',
+    // OpenCode's `LocalConfig.command` is a STRING ARRAY holding the executable
+    // followed by its arguments (`client.ts` does `const [command, ...args] =
+    // config.command`). There is no separate `args` field — passing one, or a
+    // bare string command, fails schema validation and the server never spawns.
+    command: [executable, STDIO_ARG],
+    environment: {
+      [PROJECT_ENV]: projectPath,
+      [PORT_ENV]: String(port),
+    },
+    codemode: false,
+  };
+  return withExecutionTimeout(config, options);
 }
 
+/**
+ * Attach OpenCode's per-server execution timeout to an MCP config.
+ *
+ * OpenCode defaults this to **12 hours**. The IDE's stdio bridge never answers a
+ * call whose upstream IDE connection has dropped (it logs on stderr but sends no
+ * JSON-RPC response), so without a cap a call made after the IDE died would sit
+ * unresolved for the whole default. A finite cap turns that permanent hang into
+ * an ordinary timeout error.
+ *
+ * @param {Record<string, unknown>} config
+ * @param {{ executionTimeoutMs?: number }} options
+ */
+function withExecutionTimeout(config, options) {
+  if (typeof options.executionTimeoutMs === 'number') {
+    return { ...config, timeout: { execution: options.executionTimeoutMs } };
+  }
+  return config;
+}
+
+
 /**
  * Is an IDE MCP server listening on `port`? One Streamable-HTTP `initialize`
  * POST decides it: any 2xx JSON reply means the server is up.
@@ -81,7 +146,7 @@ export async function probePort(port, options = {}) {
         params: {
           protocolVersion: PROTOCOL_VERSION,
           capabilities: {},
-          clientInfo: { name: 'opencode-idea', version: '0.0.10' },
+          clientInfo: { name: 'opencode-idea', version: '0.0.12' },
         },
       }),
       signal: controller.signal,
@@ -132,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.10' },
+        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;