agent-dealer 1.2.4 → 1.2.5

package/bundle/server/dist/adapters/muse-capability.js

@@ -0,0 +1,330 @@
+// packages/server/src/adapters/muse-capability.ts
+//
+// NOT-277: Muse Code auto-updates itself (expected, never fought). An update once silently stopped
+// granting developer sessions the shell/write tool, and every developer round after it surfaced
+// only as a generic `dirty_worktree` escalation. So whenever `muse --version` reports a version not
+// yet checked, one real developer-posture session is run whose only path to success is a shell
+// call; the result is cached per version (and persisted, so a restart does not re-bill it):
+//
+//  - capable      → recorded as the confirmed baseline, admission proceeds with no manual step;
+//  - missing      → developer admission blocked, message names old → new version + capability;
+//  - error        → the check could not complete: blocked with a distinct "could not verify"
+//                   message (fail closed), retried after a backoff;
+//  - in flight    → blocked while the one-time check runs (never assumed capable).
+//
+// The probe is a fresh `muse exec` of the on-disk binary (never the long-lived serve host, which can
+// still be the pre-update build). Checks are serialized: a version reported mid-probe is checked
+// once the running probe settles, and a verdict for a version no longer reported is discarded.
+// Messages name the exact update — the previously reported version → the current one.
+//
+// Deliberately NOT covered: NOT-177's security-enforcement evidence (`mcp_tool_allowlist_enforcement`,
+// `cron_tool_disable`, pinned in the runners' Muse config core) stays manually re-validated as before.
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DEVELOPER_ROLE_CEILING } from "@agent-dealer/shared";
+import { MUSE_CLI_ENV, resolveMuseBin } from "../cli-env.js";
+import { getDataDir } from "../db/index.js";
+/** A probe that could not complete is retried after this long (the block stays up meanwhile). */
+const ERROR_RETRY_MS = 10 * 60_000;
+const PROBE_TIMEOUT_MS = 5 * 60_000;
+const PROBE_MAX_MODEL_STEPS = 20;
+const STATE_FILE = "muse-capability.json";
+const CAPABILITY = "shell/write access";
+let state = null;
+/** At most one probe at a time (serialized); a newer version is chained after it settles. */
+let inFlight = null;
+/** Bumped whenever a check settles, so callers can tell a result landed mid-read. */
+let settledCount = 0;
+/** Bumped by resets so a probe started before a reset cannot write into the fresh state. */
+let generation = 0;
+let probeImpl = defaultMuseCapabilityProbe;
+/** Latest caller hook; a chained check reports through it too. */
+let settledHook = () => { };
+function statePath() {
+    return path.join(getDataDir(), STATE_FILE);
+}
+function loadState() {
+    if (state)
+        return state;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(statePath(), "utf8"));
+        const lastChecked = parsed.lastChecked && typeof parsed.lastChecked.version === "string" ? parsed.lastChecked : null;
+        const current = parsed.current && typeof parsed.current.version === "string"
+            ? { version: parsed.current.version, from: typeof parsed.current.from === "string" ? parsed.current.from : null }
+            : null;
+        state = {
+            confirmedVersion: typeof parsed.confirmedVersion === "string" ? parsed.confirmedVersion : null,
+            current,
+            lastChecked: lastChecked && lastChecked.version === current?.version ? lastChecked : null,
+        };
+    }
+    catch {
+        state = { confirmedVersion: null, current: null, lastChecked: null };
+    }
+    return state;
+}
+function saveState(next) {
+    state = next;
+    try {
+        fs.writeFileSync(statePath(), `${JSON.stringify(next, null, 2)}\n`);
+    }
+    catch (err) {
+        // In-memory state still gates this process; only restart persistence is lost.
+        console.warn(`[muse-capability] could not persist ${statePath()}: ${String(err)}`);
+    }
+}
+/** Record `version` as the one Muse now reports; a change remembers what it changed from. */
+function observe(version) {
+    const s = loadState();
+    if (s.current?.version === version)
+        return s;
+    const from = s.current?.version ?? s.confirmedVersion;
+    saveState({ ...s, current: { version, from: from !== version ? from : null }, lastChecked: null });
+    return state;
+}
+/** `Muse Code 1.3.0 (1.3.0-R3401.1)` → `1.3.0-R3401.1`; otherwise the last non-empty line. */
+export function parseMuseVersion(output) {
+    const paren = /\(([^()\s]+)\)\s*$/m.exec(output.trim());
+    if (paren)
+        return paren[1];
+    const last = output.trim().split("\n").map((l) => l.trim()).filter(Boolean).pop();
+    return last ?? null;
+}
+function transition(from, to) {
+    return from && from !== to ? `Muse Code updated ${from} → ${to}` : `Muse Code ${to}`;
+}
+function issueFor(checked, from) {
+    if (checked.status === "capable")
+        return [];
+    const head = transition(from, checked.version);
+    if (checked.status === "missing") {
+        return [
+            {
+                code: "runtime_capability",
+                message: `${head}: developer sessions no longer get ${CAPABILITY} (${checked.detail}) — ` +
+                    `developer admission blocked until a Muse Code version passes the check`,
+            },
+        ];
+    }
+    return [
+        {
+            code: "runtime_capability",
+            message: `Could not verify Muse Code developer ${CAPABILITY} after version change ` +
+                `(${from && from !== checked.version ? `${from} → ` : ""}${checked.version}): ` +
+                `${checked.detail} — developer admission blocked; the check retries automatically`,
+        },
+    ];
+}
+function verifyingIssue(version, from) {
+    return [
+        {
+            code: "runtime_capability",
+            message: `${transition(from, version)}: verifying developer ${CAPABILITY} ` +
+                `(one-time check for this version) — developer admission waits for the result`,
+        },
+    ];
+}
+/** Current version is unchecked, or its could-not-verify result is due a retry. */
+function checkDue(s) {
+    if (!s.current)
+        return false;
+    const checked = s.lastChecked;
+    if (!checked)
+        return true;
+    return checked.status === "error" && Date.now() - checked.checkedAt >= ERROR_RETRY_MS;
+}
+function startCheck(version) {
+    const gen = generation;
+    const promise = (async () => {
+        let result;
+        try {
+            result = await probeImpl(version);
+        }
+        catch (err) {
+            result = { status: "error", detail: err instanceof Error ? err.message : String(err) };
+        }
+        if (gen !== generation)
+            return;
+        const prev = loadState();
+        // Muse moved on while this probe ran: its verdict is about a build no longer reported, so it
+        // must not overwrite state for the newer one (which is checked next, below).
+        if (prev.current?.version !== version)
+            return;
+        const checked = { version, checkedAt: Date.now(), ...result };
+        saveState({
+            ...prev,
+            confirmedVersion: result.status === "capable" ? version : prev.confirmedVersion,
+            lastChecked: checked,
+        });
+        const from = prev.current.from;
+        if (result.status === "capable") {
+            console.log(`[muse-capability] ${transition(from, version)}: developer ${CAPABILITY} confirmed`);
+        }
+        else {
+            console.warn(`[muse-capability] ${issueFor(checked, from)[0].message}`);
+        }
+    })().finally(() => {
+        if (inFlight?.promise === promise)
+            inFlight = null;
+        if (gen !== generation)
+            return;
+        settledCount += 1;
+        const s = loadState();
+        if (!inFlight && s.current && s.current.version !== version && checkDue(s))
+            startCheck(s.current.version);
+        settledHook();
+    });
+    inFlight = { version, promise };
+}
+/**
+ * Capability issues for the currently reported Muse version. Never awaits the probe: a version not
+ * yet checked starts one background check and blocks until it settles. Checks are serialized — a
+ * version observed while another is being probed waits for that probe, then is checked once.
+ * `onSettled` lets the caller drop its health cache so admission unblocks as soon as the result is in.
+ */
+export function museCapabilityIssues(version, onSettled = () => { }) {
+    settledHook = onSettled;
+    const s = observe(version);
+    const from = s.current.from;
+    if (checkDue(s) && !inFlight)
+        startCheck(version);
+    if (s.lastChecked)
+        return issueFor(s.lastChecked, from); // incl. error retry: keep the block up
+    return verifyingIssue(version, from);
+}
+/**
+ * NOT-277: the Muse version developer work may run on outside the on-disk binary (i.e. on the
+ * long-lived serve host). `undefined` when no version has been observed yet — nothing to bind to;
+ * `null` when the reported version is not confirmed capable (only the on-disk binary, which
+ * admission gates on, may run work then); otherwise the reported, confirmed-capable version.
+ */
+export function museVersionRequiredForWork() {
+    const s = loadState();
+    if (!s.current)
+        return undefined;
+    const checked = s.lastChecked;
+    return checked?.status === "capable" && checked.version === s.current.version ? checked.version : null;
+}
+/** True while a capability check is running (callers use a short health-cache TTL meanwhile). */
+export function museCapabilityCheckInFlight() {
+    return inFlight !== null;
+}
+/**
+ * Changes each time a check settles. A health read that spans a settle must not cache what it
+ * read — it may be the "verifying" block the settle just superseded.
+ */
+export function museCapabilitySettleCount() {
+    return settledCount;
+}
+/** Tests: resolve once any in-flight capability check has settled. */
+export async function settleMuseCapabilityCheckForTests() {
+    while (inFlight)
+        await inFlight.promise;
+}
+/** Tests: replace the real `muse` probe. Pass `null` to restore it. */
+export function setMuseCapabilityProbeForTests(fn) {
+    probeImpl = fn ?? defaultMuseCapabilityProbe;
+}
+/** Tests: forget in-memory and persisted state; any in-flight probe result is discarded. */
+export function resetMuseCapabilityStateForTests() {
+    generation += 1;
+    inFlight = null;
+    state = null;
+    settledHook = () => { };
+    fs.rmSync(statePath(), { force: true });
+}
+/** Tests: backdate the last check so the error-retry path can be exercised without waiting. */
+export function ageMuseCapabilityCheckForTests(ms) {
+    const s = loadState();
+    if (s.lastChecked)
+        saveState({ ...s, lastChecked: { ...s.lastChecked, checkedAt: s.lastChecked.checkedAt - ms } });
+}
+/** `git hash-object` of a string — what `probe.sh` writes; not computable without running it. */
+function gitBlobSha1(content) {
+    return createHash("sha1").update(`blob ${Buffer.byteLength(content)}\0${content}`).digest("hex");
+}
+/** What the on-disk `muse` reports now (null when it cannot say). */
+function reportedMuseVersion() {
+    try {
+        const out = execFileSync(resolveMuseBin(), ["--version"], {
+            encoding: "utf8",
+            timeout: 30_000,
+            env: { ...process.env, ...MUSE_CLI_ENV },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return parseMuseVersion(out);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * One real developer session (same posture and model a developer round uses) in a throwaway
+ * git repo. Always a fresh `muse exec` of the on-disk binary — never the shared serve host, which
+ * may still be the pre-update build — and the binary must still report `version` afterwards, so
+ * the verdict is about the build that was probed. Its only path to success is running `sh probe.sh`, which writes a git blob hash of a
+ * fresh nonce to result.txt — the model cannot produce that value without a shell call, and the
+ * file only exists if the shell could write the workspace.
+ */
+export async function defaultMuseCapabilityProbe(version, opts = {}) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-muse-capability-"));
+    try {
+        execFileSync("git", ["init", "-q"], { cwd: dir, stdio: "ignore" });
+        const nonce = randomUUID();
+        fs.writeFileSync(path.join(dir, "probe.sh"), `#!/bin/sh\nprintf '%s' '${nonce}' | git hash-object --stdin > result.txt\n`);
+        const { runMuseDeveloperSession } = await import("../coordinator/muse-spawn.js");
+        const run = await runMuseDeveloperSession({
+            sessionId: randomUUID(),
+            runtime: "muse_code",
+            policy: DEVELOPER_ROLE_CEILING,
+            model: null,
+            maxModelSteps: PROBE_MAX_MODEL_STEPS,
+            prompt: "Dealer capability check. Using your shell tool, run exactly this command in the current " +
+                "directory: sh probe.sh\nDo not create or edit result.txt any other way. When the command " +
+                "has finished, reply with the single word DONE.",
+            cwd: dir,
+            timeoutMs: opts.timeoutMs ?? PROBE_TIMEOUT_MS,
+            logPath: path.join(dir, "probe.ndjson"),
+            execLaneOnly: true,
+        });
+        const after = reportedMuseVersion();
+        if (after !== version) {
+            return {
+                status: "error",
+                detail: `muse reported ${after ?? "no version"} after probing ${version} (changed during the check)`,
+            };
+        }
+        let written = null;
+        try {
+            written = fs.readFileSync(path.join(dir, "result.txt"), "utf8").trim();
+        }
+        catch {
+            written = null;
+        }
+        // A session that did not complete cleanly is never a verdict, even if the shell ran first.
+        if (run.timedOut)
+            return { status: "error", detail: `probe session on ${version} timed out` };
+        const failure = run.muse?.failure;
+        if (failure)
+            return { status: "error", detail: `probe session failed (${failure.kind}: ${failure.message})` };
+        if (run.exitCode !== 0)
+            return { status: "error", detail: `probe session exited ${run.exitCode}` };
+        if (written === gitBlobSha1(nonce))
+            return { status: "capable" };
+        return {
+            status: "missing",
+            detail: written === null
+                ? "probe session completed without running its shell command"
+                : "probe session completed but the shell command's output was not produced",
+        };
+    }
+    catch (err) {
+        return { status: "error", detail: `probe could not run: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}