@brutalsystems/muster 0.5.0 → 0.7.0

package/dist/identity/opencode.js

@@ -0,0 +1,86 @@
+import { realpath } from "node:fs/promises";
+import { OpenCodeHttp, OpenCodeProtocolError, } from "../opencode-http.js";
+import { command, delay, descendants, processRef } from "./processes.js";
+const POLL_INTERVAL_MS = 50;
+function rawName(session) {
+    return session.title.trim() === "" ? null : session.title;
+}
+export async function openCodeEndpointOwnedBy(rootPid, serverUrl, deadline) {
+    try {
+        const endpoint = new URL(serverUrl);
+        const port = Number(endpoint.port);
+        if (!Number.isInteger(port) || port <= 0 || deadline <= Date.now())
+            return false;
+        const family = new Set(await descendants(rootPid, deadline));
+        const output = await command("lsof", [
+            "-nP",
+            "-a",
+            `-iTCP@${endpoint.hostname}:${port}`,
+            "-sTCP:LISTEN",
+            "-Fp",
+        ], Math.max(1, Math.min(1000, deadline - Date.now())));
+        const listeners = output
+            .split("\n")
+            .filter((line) => /^p\d+$/.test(line))
+            .map((line) => Number(line.slice(1)));
+        return listeners.length > 0 && listeners.every((pid) => family.has(pid));
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveOpenCode(rootPid, serverUrl, cwd, createdAfter, deadline) {
+    const resolvedCwd = await realpath(cwd);
+    const client = new OpenCodeHttp(serverUrl);
+    let ownershipProven = false;
+    while (Date.now() < deadline) {
+        if (!(await processRef(rootPid)))
+            return;
+        if (!ownershipProven &&
+            !(await openCodeEndpointOwnedBy(rootPid, serverUrl, deadline))) {
+            const remaining = deadline - Date.now();
+            if (remaining > 0)
+                await delay(Math.min(POLL_INTERVAL_MS, remaining));
+            continue;
+        }
+        ownershipProven = true;
+        try {
+            const health = await client.health(deadline);
+            if (health.healthy) {
+                const sessions = await client.sessions(deadline);
+                if (!(await processRef(rootPid)))
+                    return;
+                const candidates = sessions.filter((session) => session.directory === resolvedCwd &&
+                    session.time.created >= createdAfter);
+                const statuses = candidates.length
+                    ? await client.statuses(deadline)
+                    : {};
+                if (!(await processRef(rootPid)))
+                    return;
+                if (!(await openCodeEndpointOwnedBy(rootPid, serverUrl, deadline))) {
+                    ownershipProven = false;
+                    continue;
+                }
+                const matches = candidates.filter((session) => Object.prototype.hasOwnProperty.call(statuses, session.id));
+                if (matches.length > 1)
+                    throw new Error("Multiple OpenCode sessions matched the launch endpoint, cwd, and creation window");
+                const match = matches[0];
+                if (match)
+                    return {
+                        id: match.id,
+                        pid: rootPid,
+                        rawName: rawName(match),
+                        cwd: resolvedCwd,
+                        serverUrl,
+                    };
+            }
+        }
+        catch (error) {
+            if (!(error instanceof OpenCodeProtocolError))
+                throw error;
+        }
+        const remaining = deadline - Date.now();
+        if (remaining > 0)
+            await delay(Math.min(POLL_INTERVAL_MS, remaining));
+    }
+}

package/dist/mcp-bridge.js

@@ -0,0 +1,91 @@
+// Claude has permission rules, but no MCP exposure allowlist. This stdio
+// connection exposes and dispatches only the operator-selected tools, including
+// when the upstream server changes its tool catalog after launch.
+import { readFile } from "node:fs/promises";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { mcpServerSchema, mcpName, mcpTransport } from "./mcp.js";
+async function main() {
+    const [path, name] = process.argv.slice(2);
+    if (!path || !name || !mcpName.safeParse(name).success)
+        throw new Error("Invalid MCP bridge arguments");
+    const definitions = JSON.parse(await readFile(path, "utf8"));
+    const config = mcpServerSchema.parse(definitions[name]);
+    const client = new Client({ name: "muster-tool-bridge", version: "1" }, { capabilities: {} });
+    const server = new Server({ name: `muster-${name}`, version: "1" }, { capabilities: { tools: {} } });
+    let shutdown;
+    const close = () => (shutdown ??= Promise.resolve().then(async () => {
+        await client.close().catch(() => { });
+        await server.close().catch(() => { });
+    }));
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
+        process.once(signal, () => {
+            void close().finally(() => process.exit(0));
+        });
+    process.stdin.once("end", () => {
+        void close();
+    });
+    process.stdin.once("close", () => {
+        void close();
+    });
+    server.onclose = () => {
+        void close();
+    };
+    client.onclose = () => {
+        void close();
+    };
+    const transport = mcpTransport(config, process.env, process.cwd());
+    const timer = setTimeout(() => {
+        void close().finally(() => process.exit(1));
+    }, config.startup_timeout_sec * 1000);
+    try {
+        await client.connect(transport);
+        if (shutdown) {
+            await close();
+            return;
+        }
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = [];
+        let cursor;
+        do {
+            const page = await client.listTools(cursor ? { cursor } : {});
+            tools.push(...page.tools.filter((t) => config.tools.includes(t.name)));
+            cursor = page.nextCursor;
+        } while (cursor);
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async ({ params }) => {
+        if (!config.tools.includes(params.name))
+            return {
+                isError: true,
+                content: [
+                    { type: "text", text: "Tool not enabled for this Muster launch" },
+                ],
+            };
+        return await client.callTool({
+            name: params.name,
+            arguments: params.arguments,
+        });
+    });
+    try {
+        await server.connect(new StdioServerTransport());
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}
+main().catch(() => {
+    process.stderr.write("Muster MCP connection failed; check the selected server configuration.\n");
+    process.exitCode = 1;
+});

package/dist/mcp.js

@@ -0,0 +1,207 @@
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+export const mcpName = z.string().regex(/^[a-zA-Z0-9_-]+$/);
+const environmentName = z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+export const mcpServerSchema = z
+    .object({
+    command: z.string().min(1).optional(),
+    args: z.array(z.string()).default([]),
+    url: z
+        .string()
+        .url()
+        .refine((s) => /^https?:\/\//.test(s), "MCP URL must use HTTP(S)")
+        .optional(),
+    env: z.record(z.string()).default({}),
+    env_vars: z.array(environmentName).default([]),
+    bearer_token_env_var: environmentName.optional(),
+    tools: z.array(mcpName).min(1),
+    required: z.boolean().default(false),
+    startup_timeout_sec: z.number().positive().max(60).default(10),
+})
+    .strict()
+    .superRefine((v, ctx) => {
+    if (!!v.command === !!v.url)
+        ctx.addIssue({
+            code: "custom",
+            message: "MCP server requires exactly one of command or url",
+        });
+    if (v.command && v.bearer_token_env_var)
+        ctx.addIssue({
+            code: "custom",
+            message: "bearer_token_env_var requires an HTTP server",
+        });
+    if (v.url &&
+        (v.args.length || Object.keys(v.env).length || v.env_vars.length))
+        ctx.addIssue({
+            code: "custom",
+            message: "args, env and env_vars require a stdio server",
+        });
+});
+export function selectMcp(req, config) {
+    // Personal defaults apply to sessions, not unattended one-shot tasks.
+    const names = req.mcp ?? (req.kind === "session" ? config.default_mcp : []);
+    return [...new Set(names)].map((name) => {
+        const server = Object.hasOwn(config.mcp_servers, name)
+            ? config.mcp_servers[name]
+            : undefined;
+        if (!server)
+            throw new Error(`Unknown MCP server: ${name}`);
+        return {
+            name,
+            config: server,
+            required: req.mcp !== undefined || server.required,
+        };
+    });
+}
+export function mcpEnvironment(servers, base, source) {
+    const env = { ...base };
+    for (const { config } of servers) {
+        for (const key of [
+            ...config.env_vars,
+            ...(config.bearer_token_env_var ? [config.bearer_token_env_var] : []),
+        ]) {
+            if (source[key] !== undefined)
+                env[key] = source[key];
+        }
+    }
+    return env;
+}
+function serverEnv(config, env) {
+    const result = { ...config.env };
+    for (const key of config.env_vars) {
+        if (env[key] === undefined)
+            throw new Error(`Missing MCP environment variable: ${key}`);
+        result[key] = env[key];
+    }
+    return result;
+}
+function headers(config, env) {
+    if (!config.bearer_token_env_var)
+        return {};
+    const value = env[config.bearer_token_env_var];
+    if (!value)
+        throw new Error("Missing MCP bearer token environment variable");
+    return { Authorization: `Bearer ${value}` };
+}
+export function mcpTransport(config, env, cwd) {
+    const transport = config.command
+        ? new StdioClientTransport({
+            command: config.command,
+            args: config.args,
+            env: { ...env, ...serverEnv(config, env) },
+            cwd,
+            stderr: "pipe",
+        })
+        : new StreamableHTTPClientTransport(new URL(config.url), {
+            requestInit: { headers: headers(config, env) },
+        });
+    if (transport instanceof StdioClientTransport)
+        transport.stderr?.on("data", () => { });
+    return transport;
+}
+export async function prepareMcp(selected, env, cwd, deadline) {
+    const servers = [], warnings = [];
+    for (const server of selected) {
+        const client = new Client({ name: "muster-preflight", version: "1" }, { capabilities: {} });
+        let timer;
+        let diagnostic = "startup or tool discovery failed (check executable, credentials and server configuration)";
+        try {
+            const timeout = Math.min(server.config.startup_timeout_sec * 1000, deadline - Date.now());
+            if (timeout <= 0)
+                throw new Error("deadline");
+            const transport = mcpTransport(server.config, env, cwd);
+            const discover = async () => {
+                await client.connect(transport);
+                const names = new Set();
+                let cursor;
+                do {
+                    const page = await client.listTools(cursor ? { cursor } : {});
+                    for (const tool of page.tools) {
+                        if (!mcpName.safeParse(tool.name).success)
+                            throw new Error("Unsupported tool name");
+                        names.add(tool.name);
+                    }
+                    cursor = page.nextCursor;
+                } while (cursor);
+                const missing = server.config.tools.filter((name) => !names.has(name));
+                if (missing.length) {
+                    diagnostic = `configured tools not found: ${missing.join(", ")}`;
+                    throw new Error("missing tools");
+                }
+                return [...names].filter((name) => !server.config.tools.includes(name));
+            };
+            const excludedTools = await Promise.race([
+                discover(),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("timeout")), timeout);
+                }),
+            ]);
+            servers.push({ ...server, excludedTools });
+        }
+        catch {
+            // Server errors may include tokens or environment values; never log them.
+            const message = `MCP server ${server.name}: ${diagnostic}`;
+            if (server.required)
+                throw new Error(message);
+            warnings.push(`${message}; skipped optional default`);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            await client.close().catch(() => { });
+        }
+    }
+    return {
+        servers,
+        summary: {
+            mcp: servers.map((s) => s.name),
+            ...(warnings.length ? { mcp_warnings: warnings } : {}),
+        },
+    };
+}
+export function codexMcpConfig(server) {
+    const c = server.config;
+    return {
+        ...(c.command
+            ? { command: c.command, args: c.args, env: c.env, env_vars: c.env_vars }
+            : {
+                url: c.url,
+                ...(c.bearer_token_env_var
+                    ? { bearer_token_env_var: c.bearer_token_env_var }
+                    : {}),
+            }),
+        enabled: true,
+        required: server.required,
+        enabled_tools: c.tools,
+        disabled_tools: [],
+        startup_timeout_sec: c.startup_timeout_sec,
+        default_tools_approval_mode: "approve",
+    };
+}
+export function claudeMcpConfig(servers, bridgePath) {
+    if (servers.length && !bridgePath)
+        throw new Error("Missing MCP bridge configuration");
+    return {
+        mcpServers: Object.fromEntries(servers.map(({ name, config }) => [
+            name,
+            {
+                type: "stdio",
+                command: process.execPath,
+                args: [
+                    fileURLToPath(new URL("../dist/mcp-bridge.js", import.meta.url)),
+                    bridgePath,
+                    name,
+                ],
+                env: Object.fromEntries([
+                    ...config.env_vars,
+                    ...(config.bearer_token_env_var
+                        ? [config.bearer_token_env_var]
+                        : []),
+                ].map((key) => [key, "${" + key + "}"])),
+            },
+        ])),
+    };
+}

package/dist/muster.js

@@ -13,7 +13,7 @@ const listSchema = z
     .strict();
 const idSchema = z.object({ id: z.string().min(1) }).strict();
 const help = `Usage:
-  muster run <codex|claude> --prompt TEXT [--cwd DIR] [--kind session|task] [--host ID] [--open] [--terminal APP] [-- RUNTIME_OPTIONS]
+  muster run <codex|claude|opencode> --prompt TEXT [--cwd DIR] [--kind session|task] [--host ID] [--open] [--terminal APP] [-- RUNTIME_OPTIONS]
   muster list [--kind session|task] [--format json|human]
   muster stop <id> [--format json|human]
   muster output <id>
@@ -23,6 +23,8 @@ run also accepts --format json|human, --permissions auto|deny|bypass,
 and --sandbox read-only|workspace-write|full-access before -- RUNTIME_OPTIONS.
 --open displays a tmux session on macOS. --terminal accepts auto (Terminal.app),
 terminal, iterm2, or ghostty, and requires --open.
+--mcp NAME is repeatable and replaces configured session defaults; --no-mcp
+clears them. Tasks use no MCP defaults; select servers explicitly.
 run, list and stop default to JSON. output prints raw task text.
 
 pty launches print their record and keep this process running. Ctrl-C stops the
@@ -54,7 +56,7 @@ async function main() {
             });
         });
     if (mcp) {
-        const server = new Server({ name: "muster", version: "0.5.0" }, { capabilities: { tools: {} } });
+        const server = new Server({ name: "muster", version: "0.6.0" }, { capabilities: { tools: {} } });
         server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: [
                 {
@@ -63,7 +65,10 @@ async function main() {
                     inputSchema: {
                         type: "object",
                         properties: {
-                            runtime: { type: "string", enum: ["codex", "claude"] },
+                            runtime: {
+                                type: "string",
+                                enum: ["codex", "claude", "opencode"],
+                            },
                             prompt: { type: "string", minLength: 1 },
                             cwd: { type: "string" },
                             kind: {
@@ -94,6 +99,11 @@ async function main() {
                                 enum: ["read-only", "workspace-write", "full-access"],
                                 description: "Defaults to config (read-only). Full access requires config authorization.",
                             },
+                            mcp: {
+                                type: "array",
+                                items: { type: "string", pattern: "^[a-zA-Z0-9_-]+$" },
+                                description: "Configured MCP server names. Omit for session defaults; [] disables all. Tasks have no defaults.",
+                            },
                             args: { type: "array", items: { type: "string" } },
                         },
                         required: ["runtime", "prompt"],
@@ -180,9 +190,17 @@ async function main() {
                 format: { type: "string" },
                 permissions: { type: "string" },
                 sandbox: { type: "string" },
+                mcp: { type: "string", multiple: true },
+                "no-mcp": { type: "boolean" },
             },
         });
-        const { format = "json", ...values } = parsed;
+        const { format = "json", "no-mcp": noMcp, ...values } = parsed;
+        if (noMcp !== undefined && command !== "run")
+            throw new Error("--no-mcp applies only to run");
+        if (noMcp && values.mcp)
+            throw new Error("--mcp and --no-mcp cannot be combined");
+        if (noMcp)
+            values.mcp = [];
         if (format !== "json" && format !== "human")
             throw new Error("format must be json or human");
         if (command === "output" && parsed.format !== undefined)

package/dist/naming.js

@@ -1,5 +1,6 @@
-/** Vendored from Tin Can src/naming.ts at fbaaea5842fd4a5c86849d7f51c8e16b8683b058 (MIT). */
-/** Peer naming per the handoff §7: slug for humans, canonical id for the log. */
+export function runtimeName(runtime) {
+    return runtime === "claude" ? "claude-code" : runtime;
+}
 export function slugify(raw) {
     return raw
         .toLowerCase()