@bivy/bivy 0.7.0-staging.93 → 0.7.0-staging.95

package/dist/harness/mcp-config.js

@@ -3,12 +3,13 @@
 // Universal Agent Harness — MCP config rewriting.
 //
 // The one piece of MCP governance that is unavoidably per-agent is *where* the
-// config lives — but the shape is near-universal. Claude Code, Codex, Cursor,
-// Windsurf, and most MCP hosts use the same `{ mcpServers: { name: { command,
-// args, env } } }` object (stdio servers) plus optional remote (url) servers.
-// This module rewrites that object so every stdio server launches through the
-// Bivy MCP proxy instead of directly — turning each agent's own MCP config into
-// the injection point, with no agent-specific code beyond the file location.
+// config lives — and, for a couple of hosts, the shape. Claude Code, Cursor,
+// Windsurf, and most MCP hosts use `{ mcpServers: { name: { command, args, env
+// } } }` (stdio) plus optional remote (url) servers. OpenCode is the JSON
+// outlier: `{ mcp: { name: { type: "local", command: [bin, ...args],
+// environment } } }` (see opencode.ai/config.json). This module rewrites both
+// shapes so every stdio server launches through the Bivy MCP proxy instead of
+// directly — turning each agent's own MCP config into the injection point.
 //
 // Pure functions, no I/O — unit-tested in test/harness-mcp-config.test.ts. The
 // file-location table for each agent is data (see agentMcpConfigTargets) that
@@ -109,6 +110,88 @@ export function withBivyToolsServer(config, spec, name = "bivy") {
         return { config, added: false };
     return { config: { ...config, mcpServers: { ...servers, [name]: spec } }, added: true };
 }
+/** Convert a universal stdio server spec into OpenCode's local-server shape. */
+export function toOpenCodeLocalServer(spec) {
+    const command = [spec.command ?? "", ...(spec.args ?? [])].filter((s, i) => i === 0 || s !== undefined);
+    // Drop a leading empty command if somehow absent — callers always pass one.
+    const argv = command[0] ? command : command.slice(1);
+    const out = { type: "local", command: argv };
+    if (spec.env && Object.keys(spec.env).length)
+        out.environment = { ...spec.env };
+    return out;
+}
+/** True when an OpenCode local server already launches through the Bivy proxy. */
+export function isOpenCodeProxied(spec, launcher) {
+    if (!Array.isArray(spec.command) || spec.command.length === 0)
+        return false;
+    if (spec.command[0] !== launcher.command)
+        return false;
+    return spec.command.includes(PROXY_MARKER);
+}
+/**
+ * Rewrite every local stdio server in `config.mcp` to launch through the proxy:
+ *
+ *   original:  { type: "local", command: ["mcp-fs", "--root", "/w"], environment: {...} }
+ *   rewritten: { type: "local",
+ *                command: ["bivy", "mcp-proxy", "--bivy-mcp", "--server", "<name>", "--",
+ *                          "mcp-fs", "--root", "/w"],
+ *                environment: {...} }
+ *
+ * Remote servers and already-proxied locals are left untouched (reported in
+ * `skipped`). Idempotent. Does not mutate the input.
+ */
+export function routeOpenCodeThroughProxy(config, launcher) {
+    const rewritten = [];
+    const skipped = [];
+    const servers = config.mcp ?? {};
+    const nextServers = {};
+    for (const [name, spec] of Object.entries(servers)) {
+        if (!spec || typeof spec !== "object") {
+            nextServers[name] = spec;
+            skipped.push(name);
+            continue;
+        }
+        if (!Array.isArray(spec.command) || spec.command.length === 0 || typeof spec.command[0] !== "string" || !spec.command[0]) {
+            // Remote/url server, enabled-only stub, or malformed — can't wrap via stdio proxy.
+            nextServers[name] = spec;
+            skipped.push(name);
+            continue;
+        }
+        if (isOpenCodeProxied(spec, launcher)) {
+            nextServers[name] = spec;
+            skipped.push(name);
+            continue;
+        }
+        const prefix = launcher.argsPrefix ?? [];
+        const orig = spec.command;
+        nextServers[name] = {
+            ...spec,
+            type: "local",
+            command: [launcher.command, ...prefix, PROXY_MARKER, "--server", name, "--", ...orig],
+        };
+        rewritten.push(name);
+    }
+    return {
+        config: { ...config, mcp: nextServers },
+        rewritten,
+        skipped,
+    };
+}
+/**
+ * Insert the Bivy tools server under OpenCode's `mcp.<name>` (default "bivy").
+ * Idempotent: an existing entry of that name is left untouched.
+ */
+export function withOpenCodeBivyToolsServer(config, spec, name = "bivy") {
+    const servers = config.mcp ?? {};
+    if (servers[name])
+        return { config, added: false };
+    return { config: { ...config, mcp: { ...servers, [name]: spec } }, added: true };
+}
+/** Basename check for OpenCode project config files we inject into. */
+export function isOpenCodeConfigFile(filePath) {
+    const base = nodePath.basename(filePath).toLowerCase();
+    return base === "opencode.json" || base === ".opencode.json" || base === "opencode.jsonc" || base === ".opencode.jsonc";
+}
 /** JSON MCP-config file candidates for an agent, most-specific (safest) first. */
 export function agentMcpConfigTargets(agentId, ctx) {
     const ws = (...parts) => nodePath.join(ctx.workspace, ...parts);

package/dist/harness/mcp-inject.js

@@ -9,12 +9,13 @@
 // session-scoped (workspace-local files preferred) so a failure or a concurrent
 // session can't corrupt config: we snapshot the exact bytes and restore them.
 //
-// Only JSON configs are handled (Claude, Gemini, OpenCode, generic .mcp.json).
-// TOML/YAML-config agents are skipped — they still run and are governed by the
-// FS + network channels. Unit-tested in test/harness-mcp-inject.test.ts.
+// JSON configs (Claude, Gemini, generic .mcp.json) use the universal
+// `mcpServers` shape; OpenCode's project `opencode.json` uses its own `mcp`
+// shape (see routeOpenCodeThroughProxy). TOML/YAML (Codex, Goose) go through
+// the format-specific writers. Unit-tested in test/harness-mcp-inject.test.ts.
 import fs from "node:fs";
 import path from "node:path";
-import { agentMcpConfigTargets, bivyToolsServerSpec, routeThroughProxy, withBivyToolsServer, } from "./mcp-config.js";
+import { agentMcpConfigTargets, bivyToolsServerSpec, isOpenCodeConfigFile, routeOpenCodeThroughProxy, routeThroughProxy, toOpenCodeLocalServer, withBivyToolsServer, withOpenCodeBivyToolsServer, } from "./mcp-config.js";
 import { injectTomlMcp, injectYamlMcp, insertTomlServer } from "./mcp-config-formats.js";
 /** The proxy launcher Bivy injects — `bivy mcp-proxy …`. */
 export function bivyProxyLauncher(bivyCommand = "bivy") {
@@ -23,7 +24,9 @@ export function bivyProxyLauncher(bivyCommand = "bivy") {
 /**
  * Inject the proxy into a single JSON config file. Returns a restore thunk
  * (a no-op if the file was absent, unreadable, non-JSON, or had no stdio
- * servers to route). Never throws.
+ * servers to route). OpenCode project configs (`opencode.json`) use the
+ * OpenCode `mcp` shape; everything else uses the universal `mcpServers` shape.
+ * Never throws.
  */
 export function injectJsonMcpConfig(filePath, launcher) {
     let original;
@@ -40,7 +43,9 @@ export function injectJsonMcpConfig(filePath, launcher) {
     catch {
         return { injected: false, restore: () => { } };
     }
-    const result = routeThroughProxy(parsed, launcher);
+    const result = isOpenCodeConfigFile(filePath)
+        ? routeOpenCodeThroughProxy(parsed, launcher)
+        : routeThroughProxy(parsed, launcher);
     if (result.rewritten.length === 0)
         return { injected: false, restore: () => { } };
     // Preserve the file's indentation feel by re-serializing with 2 spaces; the
@@ -116,7 +121,9 @@ export function injectMcpConfigFile(filePath, launcher) {
  * servers a file already has), this CREATES the config when absent so an agent
  * that ships no MCP config still gets the tool. Handles the most-specific JSON
  * config (session-local for claude/gemini/opencode/generic) and Codex's TOML
- * (`~/.codex/config.toml` — Codex has no project-local option). restore() deletes
+ * (`~/.codex/config.toml` — Codex has no project-local option). OpenCode gets
+ * its native `{ mcp: { bivy: { type: "local", command: [...] } } }` shape — the
+ * universal `mcpServers` key is rejected by OpenCode's schema. restore() deletes
  * a file it created and rewrites the exact original bytes of one it modified.
  * Idempotent (a `bivy` server already present is a no-op, so concurrent sessions
  * sharing a global config don't double up). Best-effort; never throws. Goose YAML
@@ -131,6 +138,7 @@ export function injectBivyToolsForSession(agentId, ctx, bivyCommand = "bivy") {
         return { injected: [], restore: () => { } };
     const spec = bivyToolsServerSpec({ sessionId: ctx.sessionId, endpoint: ctx.endpoint, bivyCommand });
     const ext = path.extname(target).toLowerCase();
+    const openCode = agentId === "opencode" || isOpenCodeConfigFile(target);
     const existed = fs.existsSync(target);
     let original;
     if (existed) {
@@ -142,7 +150,22 @@ export function injectBivyToolsForSession(agentId, ctx, bivyCommand = "bivy") {
         }
     }
     let nextContent;
-    if (ext === ".json") {
+    if (ext === ".json" && openCode) {
+        let parsed = {};
+        if (original !== undefined) {
+            try {
+                parsed = JSON.parse(original);
+            }
+            catch {
+                return { injected: [], restore: () => { } };
+            }
+        }
+        const { config, added } = withOpenCodeBivyToolsServer(parsed, toOpenCodeLocalServer(spec));
+        if (!added)
+            return { injected: [], restore: () => { } };
+        nextContent = `${JSON.stringify(config, null, 2)}\n`;
+    }
+    else if (ext === ".json") {
         let parsed = {};
         if (original !== undefined) {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.7.0-staging.93",
+  "version": "0.7.0-staging.95",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",