@brutalsystems/muster 0.6.0 → 0.7.1

package/dist/run.js

@@ -4,19 +4,23 @@ 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;
@@ -64,7 +68,11 @@ export class Muster {
             throw new Error("--open requires a tmux session on macOS");
         const permissions = resolvePermissions(req, this.config);
         const selectedMcp = selectMcp(req, this.config);
-        let argv = launchArgs(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;
@@ -74,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;
@@ -96,7 +106,7 @@ export class Muster {
                 ...permissions,
             });
             const prepared = await prepareMcp(selectedMcp, mcpEnvironment(selectedMcp, this.env, this.sourceEnv), req.cwd, deadline);
-            const runtimeEnv = mcpEnvironment(prepared.servers, this.env, this.sourceEnv);
+            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) {
@@ -108,11 +118,29 @@ export class Muster {
                 });
                 await writeFile(bridgePath, JSON.stringify(Object.fromEntries(prepared.servers.map((s) => [s.name, s.config]))), { mode: 0o600 });
             }
-            argv = launchArgs(req, this.config, prepared.servers, bridgePath);
+            if (req.runtime !== "opencode")
+                argv = launchArgs(req, this.config, prepared.servers, bridgePath);
             if (req.runtime === "codex") {
                 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")
@@ -133,7 +161,9 @@ 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);
             while (Date.now() < deadline) {
@@ -169,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)))
@@ -188,7 +224,10 @@ 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];
@@ -203,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(),
@@ -318,6 +362,17 @@ 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 {
@@ -353,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)
@@ -389,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 ||
@@ -399,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,
                 },
@@ -410,6 +482,9 @@ export class Muster {
                     state: metadata.state,
                     name: named.display,
                     canonical_id: named.canonicalId,
+                    ...(entry.runtime === "opencode"
+                        ? { server_url: entry.server_url }
+                        : {}),
                 },
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/muster",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "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",