@brutalsystems/muster 0.5.0 → 0.7.0

package/dist/run.js

@@ -4,40 +4,47 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { loadConfig } from "./config.js";
-import { runSchema, launchArgs, launchEnv, resolvePermissions, } from "./guard.js";
+import { runSchema, launchArgs, launchEnv, resolvePermissions, runtimeArgs, } from "./guard.js";
 import { Registry } from "./registry.js";
 import { LaunchLog } from "./log.js";
 import { hosts, selectHost } from "./hosts/index.js";
 import { processRef, isSame, stopTree, delay, descendants, } from "./identity/processes.js";
 import { resolveCodex } from "./identity/codex.js";
 import { resolveClaude } from "./identity/claude.js";
+import { openCodeEndpointOwnedBy, resolveOpenCode, } from "./identity/opencode.js";
 import { codexReachable } from "./reach/codex.js";
 import { claudeReachable } from "./reach/claude.js";
+import { openCodeReachable } from "./reach/opencode.js";
 import { assertClaudePolicy } from "./claude-policy.js";
 import { codexPolicyArgs } from "./codex-policy.js";
 import { CodexRpc } from "./codex-rpc.js";
-import { assignNames, resolvePeer } from "./naming.js";
+import { allocateLoopbackPort, OpenCodeHttp } from "./opencode-http.js";
+import { assertOpenCodeVersion, openCodeMcpNames, openCodeSessionLaunch, openCodeTaskLaunch, } from "./opencode-policy.js";
+import { assignNames, resolvePeer, runtimeName, } from "./naming.js";
+import { selectMcp, prepareMcp, mcpEnvironment } from "./mcp.js";
 export class Muster {
     config;
     home;
     env;
     drivers;
+    sourceEnv;
     registry;
     log;
     owned = new Set();
     closing = false;
     active = new Set();
-    constructor(config, home, env, drivers) {
+    constructor(config, home, env, drivers, sourceEnv) {
         this.config = config;
         this.home = home;
         this.env = env;
         this.drivers = drivers;
+        this.sourceEnv = sourceEnv;
         this.registry = new Registry(home);
         this.log = new LaunchLog(home);
     }
     static async create(opts = {}) {
         const env = launchEnv(opts.env ?? process.env), home = opts.home ?? join(env.HOME ?? homedir(), ".muster");
-        return new Muster(await loadConfig(home), home, env, opts.drivers ?? hosts());
+        return new Muster(await loadConfig(home), home, env, opts.drivers ?? hosts(), { ...(opts.env ?? process.env) });
     }
     run(input, requester = "cli") {
         if (this.closing)
@@ -60,7 +67,13 @@ export class Muster {
             (req.kind !== "session" || !["auto", "tmux"].includes(requestedHost)))
             throw new Error("--open requires a tmux session on macOS");
         const permissions = resolvePermissions(req, this.config);
-        const argv = launchArgs(req, this.config), driver = req.kind === "session"
+        const selectedMcp = selectMcp(req, this.config);
+        let argv = [];
+        if (req.runtime === "opencode")
+            runtimeArgs(req);
+        else
+            argv = launchArgs(req, this.config);
+        const driver = req.kind === "session"
             ? await selectHost(req.open ? "tmux" : requestedHost, this.drivers)
             : undefined;
         if (req.open &&
@@ -69,6 +82,8 @@ export class Muster {
         let policy = [];
         if (req.runtime === "claude")
             await assertClaudePolicy(this.env);
+        if (req.runtime === "opencode")
+            await assertOpenCodeVersion(this.env, "1.18.31", Date.now() + 4000);
         const reservation = await this.registry.reserve({ runtime: req.runtime, kind: req.kind, cwd: req.cwd, ...permissions }, this.config.max_concurrent);
         this.owned.add(reservation.launchId);
         let entry = reservation;
@@ -87,20 +102,53 @@ export class Muster {
                 requester,
                 ...(req.open ? { open: true, terminal } : {}),
                 args: req.args,
+                mcp: selectedMcp.map((s) => s.name),
                 ...permissions,
             });
+            const prepared = await prepareMcp(selectedMcp, mcpEnvironment(selectedMcp, this.env, this.sourceEnv), req.cwd, deadline);
+            let runtimeEnv = mcpEnvironment(prepared.servers, this.env, this.sourceEnv);
+            entry = await this.registry.update(entry.launchId, prepared.summary);
+            let bridgePath;
+            if (req.runtime === "claude" && prepared.servers.length) {
+                const dir = join(this.home, "mcp");
+                await mkdir(dir, { recursive: true, mode: 0o700 });
+                bridgePath = join(dir, entry.launchId + ".json");
+                entry = await this.registry.update(entry.launchId, {
+                    mcpConfigPath: bridgePath,
+                });
+                await writeFile(bridgePath, JSON.stringify(Object.fromEntries(prepared.servers.map((s) => [s.name, s.config]))), { mode: 0o600 });
+            }
+            if (req.runtime !== "opencode")
+                argv = launchArgs(req, this.config, prepared.servers, bridgePath);
             if (req.runtime === "codex") {
-                policy = await codexPolicyArgs(this.env, req.cwd, deadline);
+                policy = await codexPolicyArgs(runtimeEnv, req.cwd, deadline, prepared.servers);
                 argv.splice(1, 0, ...policy);
             }
+            else if (req.runtime === "opencode" && req.kind === "session") {
+                const port = await allocateLoopbackPort();
+                const inheritedMcpNames = await openCodeMcpNames(runtimeEnv, req.cwd, deadline);
+                const launch = await openCodeSessionLaunch(req, this.config, prepared.servers, inheritedMcpNames, port, runtimeEnv, req.cwd, deadline);
+                argv = launch.argv;
+                runtimeEnv = { ...runtimeEnv, ...launch.envPatch };
+                entry = await this.registry.update(entry.launchId, {
+                    server_url: launch.serverUrl,
+                    opencode_port: launch.port,
+                });
+            }
+            else if (req.runtime === "opencode" && req.kind === "task") {
+                const inheritedMcpNames = await openCodeMcpNames(runtimeEnv, req.cwd, deadline);
+                const launch = await openCodeTaskLaunch(req, this.config, prepared.servers, inheritedMcpNames, runtimeEnv, req.cwd, deadline);
+                argv = launch.argv;
+                runtimeEnv = { ...runtimeEnv, ...launch.envPatch };
+            }
             if (this.closing)
                 throw new Error("Launch cancelled: Muster is closing");
             if (req.kind === "task")
-                return await this.startTask(entry, argv);
+                return await this.startTask(entry, argv, runtimeEnv);
             const launched = await driver.launch({
                 argv,
                 cwd: req.cwd,
-                env: this.env,
+                env: runtimeEnv,
                 label: req.prompt.slice(0, 48),
                 deadline,
             });
@@ -113,9 +161,11 @@ export class Muster {
             await this.registry.update(entry.launchId, entry);
             let diagnostic = req.runtime === "claude"
                 ? "no Claude session registry found (check terminal for workspace trust or login prompts)"
-                : "no descendant runtime identity found";
+                : req.runtime === "opencode"
+                    ? "no OpenCode session matched the launch endpoint, cwd, and creation window"
+                    : "no descendant runtime identity found";
             if (req.runtime === "codex")
-                rpc = new CodexRpc(this.env, req.cwd, policy);
+                rpc = new CodexRpc(this.env, req.cwd);
             while (Date.now() < deadline) {
                 if (deadline - Date.now() < 25)
                     break;
@@ -149,15 +199,21 @@ export class Muster {
                                 return false;
                             }
                         })
-                        : await resolveClaude(root.pid, this.env, deadline);
+                        : req.runtime === "opencode"
+                            ? await resolveOpenCode(root.pid, entry.server_url, req.cwd, startedAt, deadline)
+                            : await resolveClaude(root.pid, this.env, deadline);
                     if (identity) {
                         diagnostic =
                             req.runtime === "codex"
                                 ? "thread id reserved but no rollout"
-                                : "registry exists but inbox socket is not accepting connections";
+                                : req.runtime === "opencode"
+                                    ? "OpenCode session exists but its endpoint status is not readable"
+                                    : "registry exists but inbox socket is not accepting connections";
                         let metadata;
                         if (req.runtime === "codex")
                             metadata = await codexReachable(rpc, identity.id, deadline);
+                        else if (req.runtime === "opencode")
+                            metadata = await openCodeReachable(new OpenCodeHttp(entry.server_url), identity, deadline);
                         else {
                             const claude = identity;
                             if (!(await claudeReachable(claude.socketPath, deadline)))
@@ -168,13 +224,17 @@ export class Muster {
                             throw new Error("readiness completed after launch deadline");
                         if (!(await isSame(root)) || !(await processRef(identity.pid)))
                             throw new Error("process exited before readiness completed");
-                        const runtime = req.runtime === "codex" ? "codex" : "claude-code";
+                        if (req.runtime === "opencode" &&
+                            !(await openCodeEndpointOwnedBy(root.pid, entry.server_url, deadline)))
+                            throw new Error("OpenCode endpoint listener is not owned by the launched process tree");
+                        const runtime = runtimeName(req.runtime);
                         const named = assignNames([
                             { runtime, uuid: identity.id, rawName: metadata.rawName },
                         ])[0];
                         const peer = {
                             kind: "session",
                             ...permissions,
+                            ...prepared.summary,
                             name: named.display,
                             canonical_id: named.canonicalId,
                             runtime,
@@ -182,7 +242,12 @@ export class Muster {
                             cwd: req.cwd,
                             ...(req.runtime === "codex"
                                 ? { thread_id: identity.id }
-                                : { session_id: identity.id }),
+                                : req.runtime === "opencode"
+                                    ? {
+                                        session_id: identity.id,
+                                        server_url: entry.server_url,
+                                    }
+                                    : { session_id: identity.id }),
                             pid: identity.pid,
                             host: driver.id,
                             capabilities: driver.capabilities(),
@@ -233,19 +298,20 @@ export class Muster {
             await rpc?.close();
         }
     }
-    async startTask(entry, argv) {
+    async startTask(entry, argv, env) {
         const dir = join(this.home, "tasks", entry.id);
         await mkdir(dir, { recursive: true, mode: 0o700 });
         const outputPath = join(dir, "output.txt"), exitPath = join(dir, "exit.json"), startPath = join(dir, "start"), specPath = join(dir, "launch.json");
         await writeFile(specPath, JSON.stringify({
             argv,
             cwd: entry.cwd,
-            env: this.env,
+            env,
             outputPath,
             exitPath,
             startPath,
             logHome: this.home,
             launchId: entry.launchId,
+            mcpConfigPath: entry.mcpConfigPath,
         }), { mode: 0o600 });
         const child = spawn(process.execPath, [
             fileURLToPath(new URL("../dist/task-worker.js", import.meta.url)),
@@ -273,6 +339,8 @@ export class Muster {
                 kind: "task",
                 permissions: entry.permissions,
                 sandbox: entry.sandbox,
+                mcp: entry.mcp ?? [],
+                ...(entry.mcp_warnings ? { mcp_warnings: entry.mcp_warnings } : {}),
                 id: entry.id,
                 runtime: entry.runtime,
                 state: "running",
@@ -293,6 +361,26 @@ export class Muster {
         }
     }
     async stopEntry(entry) {
+        try {
+            const openCodeSessionId = entry.peer?.session_id;
+            const abortDeadline = Date.now() + 1000;
+            if (entry.runtime === "opencode" &&
+                entry.root &&
+                entry.server_url &&
+                typeof openCodeSessionId === "string" &&
+                (await isSame(entry.root)) &&
+                (await openCodeEndpointOwnedBy(entry.root.pid, entry.server_url, abortDeadline)))
+                await new OpenCodeHttp(entry.server_url)
+                    .abort(openCodeSessionId, abortDeadline)
+                    .catch(() => { });
+            await this.stopEntryProcesses(entry);
+        }
+        finally {
+            if (entry.mcpConfigPath)
+                await rm(entry.mcpConfigPath, { force: true });
+        }
+    }
+    async stopEntryProcesses(entry) {
         if (!entry.root)
             return;
         if (!(await isSame(entry.root))) {
@@ -320,7 +408,7 @@ export class Muster {
             throw new Error(`Ambiguous durable id: ${exact.map((e) => e.runtime + ":" + e.id).join(", ")}`);
         const peers = all.filter((e) => e.kind === "session" && e.status === "running" && e.peer);
         const named = peers.map((e) => ({
-            runtime: e.runtime === "codex" ? "codex" : "claude-code",
+            runtime: runtimeName(e.runtime),
             uuid: e.id,
             rawName: String(e.peer.name),
             slug: String(e.peer.canonical_id)
@@ -356,6 +444,23 @@ export class Muster {
                 rpc = new CodexRpc(this.env, entry.cwd);
                 metadata = await codexReachable(rpc, entry.id, deadline);
             }
+            else if (entry.runtime === "opencode") {
+                if (!entry.server_url)
+                    throw new Error("session endpoint missing");
+                if (!(await isSame(entry.root)) ||
+                    !(await openCodeEndpointOwnedBy(entry.root.pid, entry.server_url, deadline)))
+                    throw new Error("session endpoint is not owned by the launch");
+                metadata = await openCodeReachable(new OpenCodeHttp(entry.server_url), {
+                    id: entry.id,
+                    pid: entry.root.pid,
+                    rawName: null,
+                    cwd: entry.cwd,
+                    serverUrl: entry.server_url,
+                }, deadline);
+                if (!(await isSame(entry.root)) ||
+                    !(await openCodeEndpointOwnedBy(entry.root.pid, entry.server_url, deadline)))
+                    throw new Error("session endpoint ownership changed during refresh");
+            }
             else {
                 const identity = await resolveClaude(entry.root.pid, this.env, deadline);
                 if (!identity ||
@@ -366,7 +471,7 @@ export class Muster {
             }
             const named = assignNames([
                 {
-                    runtime: entry.runtime === "codex" ? "codex" : "claude-code",
+                    runtime: runtimeName(entry.runtime),
                     uuid: entry.id,
                     rawName: metadata.rawName,
                 },
@@ -377,6 +482,9 @@ export class Muster {
                     state: metadata.state,
                     name: named.display,
                     canonical_id: named.canonicalId,
+                    ...(entry.runtime === "opencode"
+                        ? { server_url: entry.server_url }
+                        : {}),
                 },
             });
         }
@@ -396,6 +504,8 @@ export class Muster {
             if (kind && kind !== original.kind)
                 continue;
             const e = await this.refreshed(original);
+            if (e.mcpConfigPath && !["starting", "running"].includes(e.status))
+                await rm(e.mcpConfigPath, { force: true });
             if (e.kind === "session")
                 result.push({
                     ...e.peer,
@@ -417,6 +527,8 @@ export class Muster {
                 catch { }
                 result.push({
                     kind: "task",
+                    ...(e.mcp ? { mcp: e.mcp } : {}),
+                    ...(e.mcp_warnings ? { mcp_warnings: e.mcp_warnings } : {}),
                     ...(e.permissions
                         ? { permissions: e.permissions, sandbox: e.sandbox }
                         : {}),

package/dist/task-worker.js

@@ -33,6 +33,8 @@ async function finish(code, signal, error) {
     finished = true;
     try {
         await output.close();
+        if (spec.mcpConfigPath)
+            await rm(spec.mcpConfigPath, { force: true });
         await new LaunchLog(spec.logHome).write({
             event: "task_exit",
             launch_id: spec.launchId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/muster",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Launch instructed, reachable local agent sessions",
   "type": "module",
   "engines": {
@@ -62,5 +62,8 @@
     "CANONICAL_ID.md",
     "CONTRACT_PROVENANCE.md",
     "test/fixtures/canonical-id.json"
-  ]
+  ],
+  "allowScripts": {
+    "node-pty@1.1.0": true
+  }
 }

package/test/fixtures/canonical-id.json

@@ -31,8 +31,8 @@
     },
     {
       "case": "claude peers are qualified with their runtime",
-      "peers": [ { "runtime": "claude-code", "rawName": "cohort-api", "uuid": "5af69d42-2214-41d9-b13f-9c3177eb60ce" } ],
-      "expect": [ { "display": "cohort-api", "canonicalId": "claude-code:cohort-api.0ce" } ]
+      "peers": [ { "runtime": "claude-code", "rawName": "billing-api", "uuid": "5af69d42-2214-41d9-b13f-9c3177eb60ce" } ],
+      "expect": [ { "display": "billing-api", "canonicalId": "claude-code:billing-api.0ce" } ]
     },
     {
       "case": "collision: every colliding peer is suffixed, and only those",