@sagentlab/navarch-runtime 0.1.112 → 0.1.117

package/dist/cli.cjs

@@ -303,7 +303,10 @@ async function startCommand(flags) {
         // runSession checkpoints or retains the worktree before releasing its
         // capacity slot.
         runtimeShutdown.abort();
-        void capacity.waitForIdle().then(() => process.exit(CREDENTIALS_REJECTED_EXIT_CODE));
+        // Mirror warming can outlive its conversation's capacity slot. Wait for
+        // its killed process and private-cache cleanup before exiting too.
+        void Promise.all([capacity.waitForIdle(), conversationLoop.drain()])
+            .then(() => process.exit(CREDENTIALS_REJECTED_EXIT_CODE));
     }, browserProbe);
     updateCoordinatorRef.current = new update_coordinator_cjs_1.RuntimeUpdateCoordinator({
         config,

package/dist/config.cjs

@@ -10,6 +10,7 @@ exports.opencodeBlockedOnHost = opencodeBlockedOnHost;
 exports.loadRuntimeConfig = loadRuntimeConfig;
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
+const muse_cjs_1 = require("./adapters/muse.cjs");
 const sandbox_profile_cjs_1 = require("./sandbox-profile.cjs");
 /** Published image containing git, GitHub CLI, and the pinned Claude Code CLI. */
 exports.DEFAULT_SANDBOX_IMAGE = "ghcr.io/sagentlab/navarch-sandbox-agent:0.1.0";
@@ -25,6 +26,7 @@ exports.RUNTIME_AGENT_TYPES = [
     "opencode",
     "acp",
     "qoder",
+    "muse",
     "pi-local",
 ];
 function isRuntimeAgentType(value) {
@@ -116,10 +118,13 @@ function loadRuntimeConfig(env = process.env) {
         ? sandboxMode === "host" && !worktreeGuard
         : runtime === "antigravity"
             ? process.platform !== "win32" && !opencodeBlockedOnHost(sandboxMode, worktreeGuard)
-            : runtime !== "opencode" || !opencodeBlockedOnHost(sandboxMode, worktreeGuard));
+            : (runtime !== "opencode" && runtime !== "muse") || !opencodeBlockedOnHost(sandboxMode, worktreeGuard));
     if (requestedRuntimes.includes("pi-local") && runnableRuntimes.length === 0) {
         throw new Error("Pi (local) requires NAVARCH_SANDBOX_MODE=host and NAVARCH_WORKTREE_GUARD=off");
     }
+    if (requestedRuntimes.includes("muse") && runnableRuntimes.length === 0) {
+        throw new Error(muse_cjs_1.MUSE_HOST_GUARD_MESSAGE);
+    }
     if (requestedRuntimes.includes("antigravity") && runnableRuntimes.length === 0) {
         if (process.platform === "win32")
             throw new Error("Antigravity's private lease MCP relay requires a Linux or macOS worker; Windows is unsupported.");
@@ -168,6 +173,8 @@ function loadRuntimeConfig(env = process.env) {
         piExtraArgs: envList(env, "NAVARCH_PI_EXTRA_ARGS", []),
         qoderBin: env.NAVARCH_QODER_BIN ?? "qoder",
         qoderExtraArgs: envList(env, "NAVARCH_QODER_EXTRA_ARGS", []),
+        museBin: env.NAVARCH_MUSE_BIN ?? "muse",
+        museExtraArgs: envList(env, "NAVARCH_MUSE_EXTRA_ARGS", []),
         gitAuthorName: env.NAVARCH_GIT_AUTHOR_NAME ?? "sagentlab",
         gitAuthorEmail: env.NAVARCH_GIT_AUTHOR_EMAIL ?? "z@sagentlab.com",
         mcpConfigPath: env.NAVARCH_MCP_CONFIG_PATH ?? null,
@@ -195,6 +202,7 @@ function loadRuntimeConfig(env = process.env) {
         browserProbe: !["off", "false", "0"].includes(env.NAVARCH_BROWSER_PROBE ?? ""),
         naviWorkspaceChat: ["on", "true", "1"].includes(env.NAVARCH_NAVI_WORKSPACE_CHAT ?? ""),
         naviConversations: !["off", "false", "0"].includes(env.NAVARCH_NAVI_CONVERSATIONS ?? ""),
+        conversationMirror: !["off", "false", "0"].includes(env.NAVARCH_CONVERSATION_MIRROR ?? ""),
         // The server stops waiting for a capability advertisement after 90 s and
         // asks for a poll at least every 30 s; the floor only bounds control-plane load.
         conversationPollIntervalMs: Math.min(30_000, Math.max(1_000, envInt(env, "NAVARCH_CONVERSATION_POLL_MS", 5_000))),

package/dist/conversation/capability.cjs

@@ -40,7 +40,7 @@ function conversationCapability(config) {
 }
 /** Per-adapter support table for docs and diagnostics (host sandbox, guard on, feature enabled). */
 function conversationSupportMatrix() {
-    const agents = ["claude-code", "codex", "gemini", "antigravity", "opencode", "acp", "qoder", "pi-local", "pi"];
+    const agents = ["claude-code", "codex", "gemini", "antigravity", "opencode", "acp", "qoder", "muse", "pi-local", "pi"];
     return agents.map((agentType) => ({
         agentType,
         capability: conversationCapability({

package/dist/conversation/loop.cjs

@@ -7,6 +7,7 @@ const worktree_guard_cjs_1 = require("../worktree-guard.cjs");
 const capability_cjs_1 = require("./capability.cjs");
 const journal_cjs_1 = require("./journal.cjs");
 const turn_runner_cjs_1 = require("./turn-runner.cjs");
+const mirror_cjs_1 = require("./mirror.cjs");
 const workspace_cjs_1 = require("./workspace.cjs");
 const MAX_BACKOFF_MS = 60_000;
 /** After a turn, poll fast for a while: a follow-up is likely and the poll is the only delivery path. */
@@ -16,6 +17,8 @@ const SWEEP_INTERVAL_MS = 30_000;
 const PRUNE_INTERVAL_MS = 6 * 60 * 60_000;
 /** The server keeps idempotency records for 24 hours; keep ours longer. */
 const JOURNAL_RETENTION_MS = 48 * 60 * 60_000;
+/** A repository mirror nobody has asked about for this long is removed; the next conversation rebuilds it. */
+const MIRROR_RETENTION_MS = 14 * 24 * 60 * 60_000;
 /**
  * Polls for queued Navi conversation turns and runs each on this machine's
  * configured adapter. Polling is also the capability advertisement: this loop
@@ -34,6 +37,7 @@ class ConversationLoop {
     lastPruneAt = -Infinity;
     active = new Set();
     journal;
+    mirrors;
     log;
     now;
     outcomes = [];
@@ -42,6 +46,13 @@ class ConversationLoop {
         this.journal = options.journal ?? new journal_cjs_1.ConversationJournal(options.config.workspaceRoot);
         this.log = options.log ?? (0, logger_cjs_1.createLogger)("navi");
         this.now = options.now ?? Date.now;
+        this.mirrors = options.config.conversationMirror
+            ? new mirror_cjs_1.ConversationMirrors(options.config.workspaceRoot, {
+                ...(options.gitRunner ? { runner: options.gitRunner } : {}),
+                ...(options.shutdownSignal ? { signal: options.shutdownSignal } : {}),
+                log: this.log,
+            })
+            : null;
     }
     /** Outcomes of turns this process ran, newest last; used for latency reporting and tests. */
     get recentOutcomes() {
@@ -59,6 +70,7 @@ class ConversationLoop {
             return;
         }
         this.stopped = false;
+        this.mirrors?.resume();
         this.failures = 0;
         this.log.info(`Navi conversations advertised on the ${this.options.config.agentType} adapter (${this.options.config.naviWorkspaceChat ? "read-only + workspace" : "read-only"}).`);
         this.schedule(0);
@@ -68,12 +80,14 @@ class ConversationLoop {
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = null;
+        this.mirrors?.stop();
     }
     /** Stops new polls and waits for one already on the wire. Running turns finish on their own slots. */
     async drain() {
         this.stop();
         await this.polling;
         await this.housekeeping_;
+        await this.mirrors?.drain();
     }
     schedule(delayMs) {
         if (this.stopped)
@@ -173,6 +187,7 @@ class ConversationLoop {
         if (at - this.lastPruneAt >= PRUNE_INTERVAL_MS) {
             this.lastPruneAt = at;
             await this.journal.prune(JOURNAL_RETENTION_MS, this.options.config.workspaceRoot).catch(() => undefined);
+            await this.mirrors?.prune(MIRROR_RETENTION_MS, at).catch(() => undefined);
         }
     }
     async settle(journal) {
@@ -213,6 +228,7 @@ class ConversationLoop {
                 const workspace = await (0, workspace_cjs_1.prepareConversationWorkspace)({
                     workspaceRoot: config.workspaceRoot, conversationId, repositoryUrl, workingBranch, env, signal, mode,
                     ...(this.options.gitRunner ? { runner: this.options.gitRunner } : {}),
+                    ...(this.mirrors ? { mirrors: this.mirrors } : {}),
                 });
                 const guard = await (0, worktree_guard_cjs_1.prepareWorktreeGuard)({
                     workDir: workspace.metaDir,

package/dist/conversation/mirror.cjs

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationMirrors = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const sandbox_cjs_1 = require("../sandbox.cjs");
+/** Incremental fetch of an existing mirror; a full first clone runs in the background instead. */
+const MIRROR_FETCH_TIMEOUT_MS = 60_000;
+const MIRROR_CLONE_TIMEOUT_MS = 15 * 60_000;
+const LOCAL_CLONE_TIMEOUT_MS = 3 * 60_000;
+const MIRRORS_DIR = "conversation-mirrors";
+/**
+ * Machine-level bare mirrors that seed Navi conversation checkouts.
+ *
+ * A fresh network clone of a large repository took ~35 s per new conversation,
+ * which was nearly all of the first answer's latency. With a mirror, a new
+ * conversation costs one incremental `git fetch` from GitHub plus a local,
+ * local `git clone` without a second network transfer.
+ *
+ * - The fetch uses the machine's own git credentials on every new
+ *   conversation, so a machine that lost access still fails the turn instead
+ *   of answering from a stale copy.
+ * - Checkouts copy their objects, without hardlinks or alternates. Writable
+ *   chat must not be able to change another conversation's object inodes.
+ * - The first conversation of a repository on a machine keeps the direct
+ *   clone; the mirror is built afterwards in the background and published by
+ *   an atomic rename, so an interrupted build is never mistaken for a mirror.
+ */
+class ConversationMirrors {
+    options;
+    root;
+    runner;
+    /** Serializes git operations per mirror within this process. */
+    locks = new Map();
+    building = new Map();
+    warming = new AbortController();
+    paused = false;
+    constructor(workspaceRoot, options = {}) {
+        this.options = options;
+        this.root = node_path_1.default.join(workspaceRoot, MIRRORS_DIR);
+        this.runner = options.runner ?? sandbox_cjs_1.nodeCommandRunner;
+    }
+    /** Mirror location for a validated https repository URL. */
+    mirrorPath(url) {
+        return node_path_1.default.join(this.root, `${(0, node_crypto_1.createHash)("sha256").update(url).digest("hex").slice(0, 32)}.git`);
+    }
+    /**
+     * Refreshes the repository's mirror and clones `checkout` from it. Returns
+     * false (leaving no checkout behind) when there is no usable mirror, so the
+     * caller clones from the network instead.
+     */
+    async seedCheckout(options) {
+        const mirror = this.mirrorPath(options.url);
+        if (!(await this.usableMirror(mirror)))
+            return false;
+        return this.locked(mirror, () => this.withDiskLock(mirror, false, async () => {
+            if (!(await this.usableMirror(mirror)))
+                return false;
+            const fetched = await this.runner.run("git", ["--git-dir", mirror, "fetch", "--quiet", "--prune", "--no-tags", "--", options.url, "+refs/heads/*:refs/heads/*"], { cwd: this.root, env: options.env, timeoutMs: MIRROR_FETCH_TIMEOUT_MS, signal: options.signal });
+            if (fetched.code !== 0) {
+                if (options.signal?.aborted)
+                    return false;
+                // Lost access, or a damaged mirror. Either way it must not seed this
+                // conversation; the direct clone decides whether the turn can run and
+                // a successful one rebuilds the mirror.
+                this.options.log?.warn(`conversation mirror fetch failed with exit ${fetched.code}; cloning directly`);
+                await node_fs_1.promises.rm(mirror, { recursive: true, force: true }).catch(() => undefined);
+                return false;
+            }
+            const now = new Date();
+            await node_fs_1.promises.utimes(mirror, now, now).catch(() => undefined);
+            let branch = options.branch;
+            if (!branch) {
+                // Fetch updates refs, not the bare repository's symbolic HEAD. Query
+                // the current remote default instead of silently using its old value.
+                const remoteHead = await this.runner.run("git", ["ls-remote", "--symref", "--exit-code", "--", options.url, "HEAD"], { cwd: this.root, env: options.env, timeoutMs: MIRROR_FETCH_TIMEOUT_MS, signal: options.signal });
+                const ref = /^ref: (refs\/heads\/[A-Za-z0-9][A-Za-z0-9._/-]*)\tHEAD$/m.exec(remoteHead.stdout)?.[1];
+                if (remoteHead.code !== 0 || !ref || ref.includes(".."))
+                    return false;
+                branch = ref.slice("refs/heads/".length);
+                const updated = await this.runner.run("git", ["--git-dir", mirror, "symbolic-ref", "HEAD", ref], { cwd: this.root, env: options.env, timeoutMs: 30_000, signal: options.signal });
+                if (updated.code !== 0)
+                    return false;
+            }
+            const cloned = await this.runner.run("git", ["clone", "--quiet", "--local", "--no-hardlinks", "--no-tags", "--branch", branch, "--", mirror, options.checkout], 
+            // Only this clone reads a local path, and only the mirror this runtime built.
+            { cwd: node_path_1.default.dirname(options.checkout), env: { ...options.env, GIT_ALLOW_PROTOCOL: "file" }, timeoutMs: LOCAL_CLONE_TIMEOUT_MS, signal: options.signal });
+            if (cloned.code === 0) {
+                // The agent's `git fetch`/`git log origin/...` must see GitHub, not this machine's mirror path.
+                const repointed = await this.runner.run("git", ["-C", options.checkout, "remote", "set-url", "origin", options.url], { cwd: options.checkout, env: options.env, timeoutMs: 30_000, signal: options.signal });
+                if (repointed.code === 0)
+                    return true;
+            }
+            this.options.log?.warn(`conversation checkout from mirror failed with exit ${cloned.code}; cloning directly`);
+            await node_fs_1.promises.rm(options.checkout, { recursive: true, force: true }).catch(() => undefined);
+            return false;
+        }));
+    }
+    /**
+     * Builds the repository's mirror in the background if it does not exist.
+     * Called after a direct clone succeeded with the same credentials, so it
+     * never delays a turn and never runs for a repository this machine cannot read.
+     */
+    warm(url, env, signal) {
+        if (this.paused || signal?.aborted || this.options.signal?.aborted)
+            return Promise.resolve();
+        const mirror = this.mirrorPath(url);
+        const pending = this.building.get(mirror);
+        if (pending)
+            return pending;
+        const controller = new AbortController();
+        const signals = [this.warming.signal, signal, this.options.signal].filter((s) => !!s);
+        const abort = () => controller.abort();
+        for (const source of signals) {
+            source.addEventListener("abort", abort, { once: true });
+            if (source.aborted)
+                abort();
+        }
+        const build = this.locked(mirror, () => this.withDiskLock(mirror, undefined, async () => {
+            if (controller.signal.aborted || await this.usableMirror(mirror))
+                return;
+            const partial = await node_fs_1.promises.mkdtemp(`${mirror}.partial-`);
+            try {
+                const result = await this.runner.run("git", ["clone", "--quiet", "--bare", "--no-tags", "--", url, partial], { cwd: this.root, env, timeoutMs: MIRROR_CLONE_TIMEOUT_MS, signal: controller.signal });
+                if (controller.signal.aborted)
+                    return;
+                if (result.code !== 0 || !(await regularFile(node_path_1.default.join(partial, "HEAD")))) {
+                    throw new Error(`git clone --bare failed with exit ${result.code}`);
+                }
+                await node_fs_1.promises.rename(partial, mirror);
+            }
+            finally {
+                await node_fs_1.promises.rm(partial, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }))
+            // A credential helper can put secrets in stderr or spawn errors. Cache
+            // diagnostics must not copy those values into persistent runtime logs.
+            .catch(() => this.options.log?.warn("conversation mirror build failed; direct cloning remains available"))
+            .finally(() => {
+            for (const source of signals)
+                source.removeEventListener("abort", abort);
+            this.building.delete(mirror);
+        });
+        this.building.set(mirror, build);
+        return build;
+    }
+    resume() {
+        this.paused = false;
+        if (this.warming.signal.aborted)
+            this.warming = new AbortController();
+    }
+    stop() {
+        this.paused = true;
+        this.warming.abort();
+    }
+    async drain() {
+        this.stop();
+        await Promise.allSettled([...this.building.values()]);
+    }
+    /** Removes mirrors (and abandoned partial builds) no conversation has used for `maxAgeMs`. */
+    async prune(maxAgeMs, now = Date.now()) {
+        if (!(await directory(this.root)))
+            return;
+        const entries = await node_fs_1.promises.readdir(this.root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !/^[0-9a-f]{32}\.git(\.partial(?:-[A-Za-z0-9]+)?)?$/.test(entry.name))
+                continue;
+            const mirror = node_path_1.default.join(this.root, entry.name).replace(/\.partial(?:-[A-Za-z0-9]+)?$/, "");
+            if (this.locks.has(mirror))
+                continue;
+            await this.locked(mirror, () => this.withDiskLock(mirror, undefined, async () => {
+                const target = node_path_1.default.join(this.root, entry.name);
+                const stat = await node_fs_1.promises.lstat(target).catch(() => null);
+                if (!stat?.isDirectory() || now - stat.mtimeMs < maxAgeMs)
+                    return;
+                await node_fs_1.promises.rm(target, { recursive: true, force: true }).catch(() => undefined);
+            }));
+        }
+    }
+    async usableMirror(mirror) {
+        return await directory(this.root) && await directory(mirror) && await regularFile(node_path_1.default.join(mirror, "HEAD"));
+    }
+    /** Other runtime processes fall back to direct clones while this cache is busy.
+     * A crashed holder leaves a stale lock; never steal it based only on age. */
+    async withDiskLock(mirror, unavailable, work) {
+        await node_fs_1.promises.mkdir(this.root, { recursive: true, mode: 0o700 });
+        if (!(await directory(this.root)))
+            return unavailable;
+        const lock = `${mirror}.lock`;
+        try {
+            await node_fs_1.promises.mkdir(lock, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                return unavailable;
+            throw error;
+        }
+        try {
+            return await work();
+        }
+        finally {
+            await node_fs_1.promises.rm(lock, { recursive: true, force: true });
+        }
+    }
+    locked(mirror, work) {
+        const previous = this.locks.get(mirror) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(work);
+        const tail = next.catch(() => undefined);
+        this.locks.set(mirror, tail);
+        void tail.then(() => { if (this.locks.get(mirror) === tail)
+            this.locks.delete(mirror); });
+        return next;
+    }
+}
+exports.ConversationMirrors = ConversationMirrors;
+async function directory(file) {
+    return node_fs_1.promises.lstat(file).then((stat) => stat.isDirectory(), () => false);
+}
+async function regularFile(file) {
+    return node_fs_1.promises.lstat(file).then((stat) => stat.isFile(), () => false);
+}

package/dist/conversation/workspace.cjs

@@ -79,6 +79,8 @@ function conversationRoot(workspaceRoot, conversationId) {
  * The clone uses the machine's own git credentials (the same ones a local
  * `git clone` would use), never a Navarch server-side provider credential.
  * A repository this machine cannot read fails the turn instead of falling back.
+ * With `mirrors`, a new checkout is seeded from this machine's refreshed
+ * mirror of the repository instead of a full network clone (see mirror.cts).
  */
 async function prepareConversationWorkspace(options) {
     const url = validRepositoryUrl(options.repositoryUrl);
@@ -126,10 +128,15 @@ async function prepareConversationWorkspace(options) {
         GIT_CONFIG_KEY_0: "core.hooksPath",
         GIT_CONFIG_VALUE_0: process.platform === "win32" ? "NUL" : "/dev/null",
     };
-    const result = await runner.run("git", ["clone", "--quiet", "--filter=blob:none", "--no-tags", ...(branch ? ["--branch", branch] : []), "--", url, workspace.checkout], { cwd: root, env, timeoutMs: CLONE_TIMEOUT_MS, signal: options.signal });
-    if (result.code !== 0) {
-        await node_fs_1.promises.rm(workspace.checkout, { recursive: true, force: true }).catch(() => undefined);
-        throw new Error(`git clone failed with exit ${result.code}: ${result.stderr.slice(-500)}`);
+    const seeded = await options.mirrors?.seedCheckout({ url, branch, checkout: workspace.checkout, env, signal: options.signal }) ?? false;
+    if (!seeded) {
+        const result = await runner.run("git", ["clone", "--quiet", "--filter=blob:none", "--no-tags", ...(branch ? ["--branch", branch] : []), "--", url, workspace.checkout], { cwd: root, env, timeoutMs: CLONE_TIMEOUT_MS, signal: options.signal });
+        if (result.code !== 0) {
+            await node_fs_1.promises.rm(workspace.checkout, { recursive: true, force: true }).catch(() => undefined);
+            throw new Error(`git clone failed with exit ${result.code}: ${result.stderr.slice(-500)}`);
+        }
+        // This machine can read the repository: build the mirror for the next conversation.
+        void options.mirrors?.warm(url, env, options.signal);
     }
     await node_fs_1.promises.writeFile(marker, identity, { encoding: "utf8", mode: 0o600 });
     return workspace;

package/dist/exit-conditions.cjs

@@ -22,7 +22,7 @@ exports.mapExitCondition = mapExitCondition;
 exports.AGENT_AUTH_FAILURE_PREFIX = "Coding agent authentication failed";
 function agentAuthFailureReport(detail) {
     return `${exports.AGENT_AUTH_FAILURE_PREFIX}: ${detail} ` +
-        "Log the coding agent in again on this machine (`claude /login`, `codex login`, or an interactive `agy` session), then resume the agent.";
+        "Log the coding agent in again on this machine (`claude /login`, `codex login`, an interactive `agy` session, or open `muse` and run `/login`), then resume the agent.";
 }
 /**
  * Best-effort parse of `claude -p --output-format json` (or `stream-json`,

package/dist/muse-mcp-bridge.cjs

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bridgeMuseMcp = bridgeMuseMcp;
+exports.main = main;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+/**
+ * A tools-only MCP transport bridge. Muse receives only this executable and
+ * an expiring task-owned file path. Credentials never enter MSP commands or
+ * Muse's durable journal. No new listener, OAuth flow or persistent grant.
+ */
+async function bridgeMuseMcp(downstream, upstream) {
+    let initializeId;
+    let ending = false;
+    let failed = false;
+    let finish;
+    const done = new Promise((resolve) => { finish = resolve; });
+    const close = async () => {
+        if (ending)
+            return;
+        ending = true;
+        await Promise.allSettled([upstream.close(), downstream.close()]);
+        finish();
+    };
+    const fail = () => {
+        if (ending)
+            return;
+        failed = true;
+        // Upstream errors can contain endpoints, headers or provider response
+        // bodies. Never forward/log them to Muse or its retained transcript.
+        process.stderr.write("Navarch MCP bridge connection failed.\n");
+        void close();
+    };
+    const reject = (message, target) => {
+        if ("id" in message)
+            void target.send({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: "This Navarch bridge supports tools only" } }).catch(fail);
+    };
+    downstream.onmessage = (message) => {
+        if (!("method" in message)) {
+            reject(message, downstream);
+            return;
+        }
+        if (!["initialize", "notifications/initialized", "notifications/cancelled", "ping", "tools/list", "tools/call"].includes(message.method)) {
+            reject(message, downstream);
+            return;
+        }
+        if (message.method === "initialize" && "id" in message) {
+            initializeId = message.id;
+            // Do not advertise sampling, elicitation, roots, or any other route for
+            // an upstream server to ask the unattended model to approve something.
+            message = { ...message, params: { ...message.params, capabilities: {} } };
+        }
+        void upstream.send(message).catch(fail);
+    };
+    upstream.onmessage = (message) => {
+        let outgoing = message;
+        if ("method" in message && "id" in message) {
+            reject(message, upstream);
+            return;
+        }
+        if ("method" in message && !["notifications/tools/list_changed", "notifications/progress", "notifications/cancelled"].includes(message.method))
+            return;
+        if ("error" in message) {
+            outgoing = { jsonrpc: "2.0", id: message.id, error: { code: message.error.code, message: "Navarch MCP upstream request failed" } };
+        }
+        if ("result" in message && message.id === initializeId) {
+            const result = object(message.result);
+            if (!result || typeof result.protocolVersion !== "string") {
+                fail();
+                return;
+            }
+            const http = upstream;
+            http.setProtocolVersion?.(result.protocolVersion);
+            outgoing = { ...message, result: { ...result, capabilities: { ...(object(result.capabilities)?.tools ? { tools: object(result.capabilities).tools } : {}) } } };
+        }
+        void downstream.send(outgoing).catch(fail);
+    };
+    upstream.onerror = fail;
+    downstream.onerror = fail;
+    upstream.onclose = () => { void close(); };
+    downstream.onclose = () => { void close(); };
+    const onEnd = () => { void close(); };
+    process.stdin.once("end", onEnd);
+    process.once("SIGTERM", onEnd);
+    process.once("SIGINT", onEnd);
+    try {
+        await upstream.start();
+        await downstream.start();
+        await done;
+        if (failed)
+            throw new Error("Navarch MCP bridge connection failed");
+    }
+    finally {
+        await close();
+        process.stdin.removeListener("end", onEnd);
+        process.removeListener("SIGTERM", onEnd);
+        process.removeListener("SIGINT", onEnd);
+    }
+}
+async function main(args = process.argv.slice(2)) {
+    try {
+        const [configPath, name, digest] = args;
+        if (!configPath || !node_path_1.default.isAbsolute(configPath) || !name || !digest || !/^[a-f0-9]{64}$/.test(digest) || args.length !== 3)
+            throw new Error("Invalid bridge arguments");
+        const directory = await (0, promises_1.stat)(node_path_1.default.dirname(configPath));
+        if (!directory.isDirectory() || (directory.mode & 0o077) !== 0)
+            throw new Error("Non-private bridge directory");
+        const file = await (0, promises_1.open)(configPath, node_fs_1.constants.O_RDONLY | (node_fs_1.constants.O_NOFOLLOW ?? 0));
+        let content;
+        try {
+            const metadata = await file.stat();
+            if (!metadata.isFile() || (metadata.mode & 0o077) !== 0 || metadata.size > 1024 * 1024)
+                throw new Error("Non-private bridge file");
+            content = await file.readFile("utf8");
+        }
+        finally {
+            await file.close();
+        }
+        // Bind the transport/endpoint/headers to the exact configuration chosen
+        // by Navarch. A later file replacement cannot redirect a credential.
+        if ((0, node_crypto_1.createHash)("sha256").update(content).digest("hex") !== digest)
+            throw new Error("Bridge configuration changed");
+        const source = object(JSON.parse(content));
+        const server = object(source?.[name]);
+        if (!server)
+            throw new Error("Missing MCP server");
+        const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+        let upstream;
+        if (server.transport === "streamableHttp" && typeof server.url === "string") {
+            const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+            const endpoint = new URL(server.url);
+            if (!["http:", "https:"].includes(endpoint.protocol) || endpoint.username || endpoint.password)
+                throw new Error("Invalid MCP URL");
+            upstream = new StreamableHTTPClientTransport(endpoint, {
+                requestInit: { headers: server.headers },
+                // The SDK's SSE GET path does not inherit requestInit.redirect.
+                // Enforce the exact authorized endpoint for every HTTP method.
+                fetch: (input, init) => {
+                    const url = new URL(input);
+                    if (url.href !== endpoint.href)
+                        return Promise.reject(new Error("MCP endpoint changed"));
+                    return fetch(input, { ...init, redirect: "error" });
+                },
+            });
+        }
+        else if (server.transport === "stdio" && typeof server.command === "string") {
+            const { StdioClientTransport, getDefaultEnvironment } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+            upstream = new StdioClientTransport({ command: server.command, args: server.args,
+                env: { ...getDefaultEnvironment(), ...server.env }, stderr: "ignore" });
+        }
+        else
+            throw new Error("Unsupported MCP transport");
+        await bridgeMuseMcp(new StdioServerTransport(), upstream);
+    }
+    catch {
+        process.stderr.write("Navarch MCP bridge could not start; check its task-owned configuration and installed runtime.\n");
+        process.exitCode = 1;
+    }
+}