@martinloop/mcp 0.7.0 → 0.8.0

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -1,6 +1,8 @@
-import { type ChildProcess, type SpawnOptions } from "node:child_process";
+import type { ChildProcess, SpawnOptions } from "node:child_process";
 import { diffStatsFromNumstat } from "./runtime-support.js";
 import type { VerifierExecutionBinding } from "../core/index.js";
+import type { ExternalOutcomeEvidenceReference } from "../contracts/index.js";
+import { type ProcessTreeCleanupResult } from "./process-supervisor.js";
 export type SpawnLike = (command: string, args?: readonly string[], options?: SpawnOptions) => ChildProcess;
 export interface SubprocessResult {
     exitCode: number;
@@ -27,9 +29,11 @@ export interface SubprocessResult {
      */
     terminationReason?: string;
     launched: boolean;
+    cleanup: ProcessTreeCleanupResult;
 }
 export interface VerificationOutcome {
     passed: boolean;
+    processCloseState: "closed" | "not_required" | "failed";
     summary: string;
     steps: VerificationStepOutcome[];
     warnings?: string[];
@@ -44,10 +48,12 @@ export interface VerificationStepOutcome {
     timedOut: boolean;
     fastFail: boolean;
     detail?: string;
+    evidence?: ExternalOutcomeEvidenceReference;
 }
 export declare function runSubprocess(command: string, args: string[], options: {
     cwd: string;
     timeoutMs: number;
+    env?: NodeJS.ProcessEnv;
     spawnImpl?: SpawnLike;
     stdinData?: string;
     /**
@@ -68,14 +74,17 @@ export declare function runSubprocess(command: string, args: string[], options:
     onStdoutChunk?: (chunk: Buffer, terminate: (reason: string) => void) => void;
     /** Optional abort signal — kills the subprocess when aborted. */
     signal?: AbortSignal;
+    /** Require an owned process-tree sweep before successful completion. */
+    requireTreeClosureOnSuccess?: boolean;
 }): Promise<SubprocessResult>;
 export declare function runVerification(commands: string[], cwd: string, timeoutMs: number, verificationStack?: Array<{
     command: string;
     type: string;
     fastFail?: boolean;
-}>, spawnImpl?: SpawnLike, binding?: Omit<VerifierExecutionBinding, "commands">): Promise<VerificationOutcome>;
-export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<{
+}>, spawnImpl?: SpawnLike, binding?: Omit<VerifierExecutionBinding, "commands">, signal?: AbortSignal): Promise<VerificationOutcome>;
+export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike, requestedChangedFiles?: readonly string[]): Promise<{
     changedFiles?: string[];
+    patch?: string;
     diffStats?: ReturnType<typeof diffStatsFromNumstat>;
 }>;
 export declare function readGitChangedFiles(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<string[]>;

package/dist/vendor/adapters/cli-bridge.js

@@ -1,146 +1,23 @@
-import { spawn } from "node:child_process";
 import { basename, delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.js";
+import { spawnSupervisedProcess } from "./process-supervisor.js";
 const gitRepositoryRootCache = new Map();
 export async function runSubprocess(command, args, options) {
-    return new Promise((resolve) => {
-        let timedOut = false;
-        let outputCapped = false;
-        let terminationReason;
-        let settled = false;
-        let exited = false;
-        let outputBytes = 0;
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        const stdinMode = options.stdinData !== undefined ? "pipe" : "ignore";
-        const resolveOnce = (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            resolve({ ...result, timedOut, outputCapped, ...(terminationReason ? { terminationReason } : {}) });
-        };
-        let proc;
-        try {
-            const spawnPlan = createSpawnPlan(command, args, options.cwd, options.spawnImpl !== undefined);
-            proc = (options.spawnImpl ?? spawn)(spawnPlan.command, spawnPlan.args, {
-                cwd: options.cwd,
-                stdio: [stdinMode, "pipe", "pipe"],
-                env: process.env
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false, completed: false, crashed: true });
-            return;
-        }
-        const trackOutput = (chunks, chunk) => {
-            if (outputCapped || timedOut || terminationReason) {
-                return;
-            }
-            chunks.push(chunk);
-            outputBytes += chunk.byteLength;
-            if (options.maxOutputBytes !== undefined && outputBytes > options.maxOutputBytes) {
-                outputCapped = true;
-                proc.kill("SIGTERM");
-            }
-        };
-        const terminateEarly = (reason) => {
-            if (terminationReason || timedOut || outputCapped) {
-                return;
-            }
-            terminationReason = reason;
-            proc.kill("SIGTERM");
-        };
-        // Honour the harness abort signal — kill the subprocess immediately
-        if (options.signal !== undefined) {
-            const sig = options.signal;
-            if (sig.aborted) {
-                proc.kill("SIGTERM");
-            }
-            else {
-                const onAbort = () => { proc.kill("SIGTERM"); };
-                sig.addEventListener("abort", onAbort, { once: true });
-                proc.on("close", () => { sig.removeEventListener("abort", onAbort); });
-            }
-        }
-        proc.stdout?.on("data", (chunk) => {
-            if (outputCapped || timedOut || terminationReason) {
-                return;
-            }
-            trackOutput(stdoutChunks, chunk);
-            if (options.onStdoutChunk) {
-                try {
-                    options.onStdoutChunk(chunk, terminateEarly);
-                }
-                catch (error) {
-                    terminateEarly(`stdout inspector error: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        });
-        proc.stderr?.on("data", (chunk) => {
-            if (outputCapped || timedOut || terminationReason) {
-                return;
-            }
-            trackOutput(stderrChunks, chunk);
-        });
-        proc.stdin?.on("error", (error) => {
-            // Some CLIs exit before consuming stdin in tests and on fast-fail paths.
-            // Treat the closed pipe as a handled subprocess lifecycle condition.
-            if (error.code === "EPIPE") {
-                return;
-            }
-            stderrChunks.push(Buffer.from(`${error.message}\n`, "utf8"));
-        });
-        const timer = setTimeout(() => {
-            if (settled || exited || proc.exitCode !== null) {
-                return;
-            }
-            timedOut = true;
-            proc.kill("SIGTERM");
-        }, options.timeoutMs);
-        proc.on("exit", () => {
-            exited = true;
-        });
-        proc.on("error", (error) => {
-            clearTimeout(timer);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false, completed: false, crashed: true });
-        });
-        proc.on("close", (code) => {
-            clearTimeout(timer);
-            const completed = code !== null && !timedOut && !outputCapped && !terminationReason;
-            resolveOnce({
-                exitCode: code ?? 1,
-                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                stderr: Buffer.concat(stderrChunks).toString("utf8"),
-                launched: true,
-                completed,
-                crashed: !completed && !timedOut && !outputCapped && !terminationReason,
-            });
-        });
-        if (options.stdinData !== undefined && proc.stdin) {
-            try {
-                proc.stdin.end(options.stdinData, "utf8");
-            }
-            catch (error) {
-                const stdinError = error;
-                if (stdinError.code !== "EPIPE") {
-                    clearTimeout(timer);
-                    resolveOnce({
-                        exitCode: 1,
-                        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                        stderr: stdinError.message,
-                        launched: false,
-                        completed: false,
-                        crashed: true,
-                    });
-                }
-            }
-        }
+    const spawnPlan = createSpawnPlan(command, args, options.cwd, options.spawnImpl !== undefined);
+    return spawnSupervisedProcess(spawnPlan.command, spawnPlan.args, {
+        cwd: options.cwd,
+        timeoutMs: options.timeoutMs,
+        ...(options.env ? { env: options.env } : {}),
+        ...(options.spawnImpl ? { spawnImpl: options.spawnImpl } : {}),
+        ...(options.stdinData !== undefined ? { stdinData: options.stdinData } : {}),
+        ...(options.maxOutputBytes !== undefined ? { maxOutputBytes: options.maxOutputBytes } : {}),
+        ...(options.onStdoutChunk ? { onStdoutChunk: options.onStdoutChunk } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.requireTreeClosureOnSuccess ? { requireTreeClosureOnSuccess: true } : {})
     });
 }
-export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl, binding) {
+export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl, binding, signal) {
     const steps = verificationStack && verificationStack.length > 0
         ? verificationStack.map((step) => ({
             command: step.command,
@@ -150,12 +27,29 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     const executionBinding = {
         runId: binding?.runId ?? "unbound",
         workspaceId: binding?.workspaceId ?? "unbound",
+        ...(binding?.attemptId ? { attemptId: binding.attemptId } : {}),
         cwd: binding?.cwd ?? cwd,
+        ...(binding?.runsRoot ? { runsRoot: binding.runsRoot } : {}),
+        ...(binding?.executionProfile ? { executionProfile: binding.executionProfile } : {}),
+        ...(binding?.allowedNetworkDomains?.length ? { allowedNetworkDomains: [...binding.allowedNetworkDomains] } : {}),
         commands: steps.map((step) => step.command),
     };
+    const verifierEnv = {
+        ...process.env,
+        MARTIN_RUN_ID: executionBinding.runId,
+        MARTIN_WORKSPACE_ID: executionBinding.workspaceId,
+        ...(executionBinding.attemptId ? { MARTIN_ATTEMPT_ID: executionBinding.attemptId } : {}),
+        MARTIN_VERIFIER_CWD: executionBinding.cwd,
+        ...(executionBinding.runsRoot ? { MARTIN_RUNS_DIR: executionBinding.runsRoot } : {}),
+        ...(executionBinding.executionProfile ? { MARTIN_EXECUTION_PROFILE: executionBinding.executionProfile } : {}),
+        ...(executionBinding.allowedNetworkDomains?.length
+            ? { MARTIN_ALLOWED_NETWORK_DOMAINS: JSON.stringify(executionBinding.allowedNetworkDomains) }
+            : {}),
+    };
     if (steps.length === 0) {
         return {
             passed: false,
+            processCloseState: "not_required",
             summary: "No verification commands specified; execution is not VERIFIED.",
             steps: [],
             warnings: ["Execution completed without verifier evidence."],
@@ -165,6 +59,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     const failedSteps = [];
     const stepOutcomes = [];
     const warnings = [];
+    let processCloseState = "not_required";
     for (const step of steps) {
         let bin;
         let args;
@@ -193,8 +88,17 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         if (!bin) {
             continue;
         }
-        const result = await runSubprocess(bin, args, { cwd, timeoutMs, spawnImpl });
+        const result = await runSubprocess(bin, args, {
+            cwd,
+            timeoutMs,
+            env: verifierEnv,
+            spawnImpl,
+            ...(signal ? { signal } : {}),
+            requireTreeClosureOnSuccess: true
+        });
         const detail = truncate(result.stderr.trim() || result.stdout.trim(), 500);
+        processCloseState = combineProcessCloseState(processCloseState, result.cleanup.state);
+        const evidence = parseExternalOutcomeEvidenceReference(result.stdout);
         stepOutcomes.push({
             command: step.command,
             launched: result.launched,
@@ -203,11 +107,23 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
             exitCode: result.exitCode,
             timedOut: result.timedOut,
             fastFail: step.fastFail,
-            ...(detail ? { detail } : {})
+            ...(detail ? { detail } : {}),
+            ...(evidence ? { evidence } : {})
         });
+        if (result.cleanup.state === "failed") {
+            return {
+                passed: false,
+                processCloseState,
+                summary: `Verifier process-tree closure failed: ${step.command}`,
+                steps: stepOutcomes,
+                binding: executionBinding,
+                warnings: [result.cleanup.message]
+            };
+        }
         if (result.timedOut) {
             return {
                 passed: false,
+                processCloseState,
                 summary: `Verification timed out: ${step.command}`,
                 steps: stepOutcomes,
                 binding: executionBinding,
@@ -220,7 +136,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
                 warnings.push(`Verifier never launched: ${step.command}`);
             }
             if (step.fastFail) {
-                return { passed: false, summary, steps: stepOutcomes, binding: executionBinding, ...(warnings.length ? { warnings } : {}) };
+                return { passed: false, processCloseState, summary, steps: stepOutcomes, binding: executionBinding, ...(warnings.length ? { warnings } : {}) };
             }
             failedSteps.push(step.command);
         }
@@ -228,6 +144,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     if (failedSteps.length > 0) {
         return {
             passed: false,
+            processCloseState,
             summary: `Failed steps: ${failedSteps.join(", ")}`,
             steps: stepOutcomes,
             binding: executionBinding,
@@ -236,30 +153,93 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     }
     return {
         passed: true,
+        processCloseState,
         summary: `All ${String(steps.length)} verification step(s) passed.`,
         steps: stepOutcomes,
         binding: executionBinding,
         ...(warnings.length ? { warnings } : {})
     };
 }
-export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl) {
+function parseExternalOutcomeEvidenceReference(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        const evidence = parsed.evidence;
+        if (evidence?.kind !== "external_outcome"
+            || typeof evidence.contractId !== "string"
+            || typeof evidence.path !== "string"
+            || typeof evidence.sha256 !== "string"
+            || !/^[a-f0-9]{64}$/u.test(evidence.sha256))
+            return undefined;
+        return {
+            kind: "external_outcome",
+            contractId: evidence.contractId,
+            path: evidence.path,
+            sha256: evidence.sha256,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function combineProcessCloseState(current, next) {
+    if (current === "failed" || next === "failed")
+        return "failed";
+    if (current === "closed" || next === "closed")
+        return "closed";
+    return "not_required";
+}
+export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl, requestedChangedFiles) {
     if (!resolveGitRepositoryRoot(repoRoot)) {
         return {};
     }
-    const changedFilesResult = await runSubprocess("git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot, timeoutMs, spawnImpl });
-    const numstatResult = await runSubprocess("git", ["diff", "--numstat", "HEAD"], { cwd: repoRoot, timeoutMs, spawnImpl });
-    const changedFiles = changedFilesResult.exitCode === 0
-        ? changedFilesResult.stdout
-            .split(/\r?\n/u)
-            .map((entry) => entry.trim())
-            .filter(Boolean)
-        : [];
-    const diffStats = numstatResult.exitCode === 0 ? diffStatsFromNumstat(numstatResult.stdout) : undefined;
+    const observedChangedFiles = requestedChangedFiles
+        ? [...requestedChangedFiles]
+        : await readGitChangedFiles(repoRoot, timeoutMs, spawnImpl);
+    const changedFiles = observedChangedFiles.filter(isSafeRepoRelativeGitPath);
+    const patchParts = [];
+    const numstatParts = [];
+    const nullDevice = process.platform === "win32" ? "NUL" : "/dev/null";
+    for (const file of changedFiles) {
+        const trackedPatch = await runSubprocess("git", ["diff", "--binary", "--no-ext-diff", "HEAD", "--", file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        const trackedNumstat = await runSubprocess("git", ["diff", "--numstat", "HEAD", "--", file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        if (trackedPatch.exitCode === 0 && trackedPatch.stdout.length > 0) {
+            patchParts.push(trackedPatch.stdout);
+            if (trackedNumstat.exitCode === 0 && trackedNumstat.stdout.length > 0) {
+                numstatParts.push(trackedNumstat.stdout);
+            }
+            continue;
+        }
+        // Git does not include untracked files in `git diff HEAD`. Diff each such
+        // path against the null tree so the parent runtime receives its content,
+        // not merely a synthetic filename-only patch.
+        const untrackedPatch = await runSubprocess("git", ["diff", "--binary", "--no-ext-diff", "--no-index", "--", nullDevice, file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        if ((untrackedPatch.exitCode === 0 || untrackedPatch.exitCode === 1) && untrackedPatch.stdout.length > 0) {
+            patchParts.push(untrackedPatch.stdout);
+        }
+        const untrackedNumstat = await runSubprocess("git", ["diff", "--numstat", "--no-index", "--", nullDevice, file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        if ((untrackedNumstat.exitCode === 0 || untrackedNumstat.exitCode === 1) && untrackedNumstat.stdout.length > 0) {
+            numstatParts.push(untrackedNumstat.stdout);
+        }
+    }
+    const patch = patchParts.join("\n");
+    const numstat = numstatParts.join("\n");
+    const diffStats = numstat.length > 0 ? diffStatsFromNumstat(numstat) : undefined;
     return {
         ...(changedFiles.length > 0 ? { changedFiles } : {}),
+        ...(patch.length > 0 ? { patch } : {}),
         ...(diffStats ? { diffStats } : {})
     };
 }
+function isSafeRepoRelativeGitPath(file) {
+    if (file.length === 0 || file.includes("\u0000") || isAbsolute(file)) {
+        return false;
+    }
+    const segments = file.replace(/\\/gu, "/").split("/");
+    return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
 export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
     if (!resolveGitRepositoryRoot(repoRoot)) {
         return [];

package/dist/vendor/adapters/codex-cli.d.ts

@@ -16,8 +16,8 @@ export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOption
  *
  * Provider identity remains `codex` even when doctor/preflight selected an
  * absolute native binary or npm shim. The selected binary's cached capability
- * profile builds both the real argv and stdin transport, while the spawn router
- * sends only the Codex subprocess to that exact executable. Git/verifier
- * subprocesses retain their normal commands.
+ * profile builds both the real argv and stdin transport. The generic adapter's
+ * execution-command boundary sends only the Codex subprocess to that exact
+ * executable, while Git/verifier subprocesses retain normal OS-owned spawning.
  */
 export declare function createCodexCliAdapter(options?: CodexCliAdapterOptions): import("../core/index.js").MartinAdapter;

package/dist/vendor/adapters/codex-cli.js

@@ -1,26 +1,13 @@
-import { spawn } from "node:child_process";
 import { createAgentCliAdapter } from "./claude-cli.js";
 import { buildCodexExecArgs, buildCodexStdin, isCodexAutonomyResolutionVerifiedByLaunchProbe, probeCodexCapabilities } from "./codex-launcher.js";
-import { createSpawnPlan } from "./cli-bridge.js";
-function createCodexSpawnRouter(input) {
-    if (input.injectedSpawn) {
-        return (command, args = [], options) => input.injectedSpawn?.(command === "codex" ? input.selectedBinary : command, args, options);
-    }
-    return (command, args = [], options) => {
-        const executable = command === "codex" ? input.selectedBinary : command;
-        const cwd = typeof options?.cwd === "string" ? options.cwd : input.workingDirectory;
-        const plan = createSpawnPlan(executable, [...args], cwd, false);
-        return spawn(plan.command, plan.args, options ?? {});
-    };
-}
 /**
  * Capability-driven Codex CLI adapter.
  *
  * Provider identity remains `codex` even when doctor/preflight selected an
  * absolute native binary or npm shim. The selected binary's cached capability
- * profile builds both the real argv and stdin transport, while the spawn router
- * sends only the Codex subprocess to that exact executable. Git/verifier
- * subprocesses retain their normal commands.
+ * profile builds both the real argv and stdin transport. The generic adapter's
+ * execution-command boundary sends only the Codex subprocess to that exact
+ * executable, while Git/verifier subprocesses retain normal OS-owned spawning.
  */
 export function createCodexCliAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
@@ -39,16 +26,12 @@ export function createCodexCliAdapter(options = {}) {
     const sandbox = options.sandbox ?? "workspace-write";
     const extraArgs = options.extraArgs ?? [];
     const launchModel = options.model;
-    const spawnImpl = createCodexSpawnRouter({
-        selectedBinary,
-        workingDirectory,
-        ...(options.spawnImpl ? { injectedSpawn: options.spawnImpl } : {})
-    });
     return createAgentCliAdapter({
         // Keep semantic provider identity stable for usage parsing, pricing,
-        // diagnostics, and adapter metadata. The spawn router maps this to the
-        // exact selected binary at process launch time.
+        // diagnostics, and adapter metadata. executionCommand selects the exact
+        // binary without disguising production OS spawning as a test injection.
         command: "codex",
+        executionCommand: selectedBinary,
         adapterIdSuffix: "codex",
         model: options.model,
         label: options.label ?? "Codex CLI adapter",
@@ -58,7 +41,10 @@ export function createCodexCliAdapter(options = {}) {
         providerExecutionTimeoutMs: options.providerExecutionTimeoutMs,
         verifyTimeoutMs: options.verifyTimeoutMs,
         supportsJsonOutput: false,
-        spawnImpl,
+        streamingUsageCap: true,
+        streamingTokenCap: true,
+        streamingUsageDetailsIncludedInTotals: true,
+        spawnImpl: options.spawnImpl,
         argsBuilder: (prompt) => buildCodexExecArgs({
             command: selectedBinary,
             workingDirectory,