@martinloop/mcp 0.2.7 → 0.3.1

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

@@ -6,16 +6,60 @@ export interface SubprocessResult {
     stdout: string;
     stderr: string;
     timedOut: boolean;
+    /**
+     * True when the subprocess was terminated early because its combined
+     * stdout+stderr exceeded `maxOutputBytes` — a circuit breaker against
+     * runaway agent sessions that would otherwise burn far more cost/tokens
+     * than the loop budget allows before MartinLoop can observe the final
+     * (post-hoc) usage report. See `claude-cli.ts` execute() for how this
+     * cap is derived from the remaining loop budget.
+     */
+    outputCapped: boolean;
+    /**
+     * Set to the inspector's reason string when an `onStdoutChunk` callback
+     * requested early termination (e.g. a streaming usage/cost circuit breaker
+     * that detected the agent is on track to blow through its budget). Distinct
+     * from `outputCapped`, which fires on raw byte volume rather than parsed
+     * semantic content.
+     */
+    terminationReason?: string;
+    launched: boolean;
 }
 export interface VerificationOutcome {
     passed: boolean;
     summary: string;
+    steps: VerificationStepOutcome[];
+    warnings?: string[];
+}
+export interface VerificationStepOutcome {
+    command: string;
+    launched: boolean;
+    exitCode?: number;
+    timedOut: boolean;
+    fastFail: boolean;
+    detail?: string;
 }
 export declare function runSubprocess(command: string, args: string[], options: {
     cwd: string;
     timeoutMs: number;
     spawnImpl?: SpawnLike;
     stdinData?: string;
+    /**
+     * Optional circuit breaker: terminate the subprocess once combined
+     * stdout+stderr bytes exceed this threshold, instead of waiting for
+     * natural completion. Used to bound runaway agent-CLI cost/token spend
+     * that can't otherwise be observed until the process exits.
+     */
+    maxOutputBytes?: number;
+    /**
+     * Optional semantic inspector invoked with each raw stdout chunk. Used to
+     * parse streaming structured output (e.g. Claude's `stream-json` usage
+     * events) and request early termination via the supplied `terminate`
+     * callback once a semantic threshold (such as cumulative cost) is
+     * crossed — well before the subprocess would exit naturally and report
+     * a runaway final usage figure.
+     */
+    onStdoutChunk?: (chunk: Buffer, terminate: (reason: string) => void) => void;
 }): Promise<SubprocessResult>;
 export declare function runVerification(commands: string[], cwd: string, timeoutMs: number, verificationStack?: Array<{
     command: string;
@@ -26,6 +70,8 @@ export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: n
     changedFiles?: string[];
     diffStats?: ReturnType<typeof diffStatsFromNumstat>;
 }>;
+export declare function readGitChangedFiles(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<string[]>;
+export declare function resolveGitRepositoryRoot(workingDirectory: string): string | undefined;
 export interface SpawnPlan {
     command: string;
     args: string[];

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

@@ -1,11 +1,15 @@
 import { spawn } from "node:child_process";
-import { delimiter, extname, isAbsolute, join, resolve } from "node:path";
+import { delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.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 outputBytes = 0;
         const stdoutChunks = [];
         const stderrChunks = [];
         const stdinMode = options.stdinData !== undefined ? "pipe" : "ignore";
@@ -14,7 +18,7 @@ export async function runSubprocess(command, args, options) {
                 return;
             }
             settled = true;
-            resolve(result);
+            resolve({ ...result, timedOut, outputCapped, ...(terminationReason ? { terminationReason } : {}) });
         };
         let proc;
         try {
@@ -27,19 +31,33 @@ export async function runSubprocess(command, args, options) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            resolveOnce({
-                exitCode: 1,
-                stdout: "",
-                stderr: message,
-                timedOut: false
-            });
+            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false });
             return;
         }
+        const trackOutput = (chunks, chunk) => {
+            chunks.push(chunk);
+            outputBytes += chunk.byteLength;
+            if (options.maxOutputBytes !== undefined &&
+                !outputCapped &&
+                !timedOut &&
+                outputBytes > options.maxOutputBytes) {
+                outputCapped = true;
+                proc.kill("SIGTERM");
+            }
+        };
+        const terminateEarly = (reason) => {
+            if (terminationReason || timedOut || outputCapped) {
+                return;
+            }
+            terminationReason = reason;
+            proc.kill("SIGTERM");
+        };
         proc.stdout?.on("data", (chunk) => {
-            stdoutChunks.push(chunk);
+            trackOutput(stdoutChunks, chunk);
+            options.onStdoutChunk?.(chunk, terminateEarly);
         });
         proc.stderr?.on("data", (chunk) => {
-            stderrChunks.push(chunk);
+            trackOutput(stderrChunks, chunk);
         });
         proc.stdin?.on("error", (error) => {
             // Some CLIs exit before consuming stdin in tests and on fast-fail paths.
@@ -55,12 +73,7 @@ export async function runSubprocess(command, args, options) {
         }, options.timeoutMs);
         proc.on("error", (error) => {
             clearTimeout(timer);
-            resolveOnce({
-                exitCode: 1,
-                stdout: "",
-                stderr: error.message,
-                timedOut: false
-            });
+            resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false });
         });
         proc.on("close", (code) => {
             clearTimeout(timer);
@@ -68,7 +81,7 @@ export async function runSubprocess(command, args, options) {
                 exitCode: code ?? 1,
                 stdout: Buffer.concat(stdoutChunks).toString("utf8"),
                 stderr: Buffer.concat(stderrChunks).toString("utf8"),
-                timedOut
+                launched: true
             });
         });
         if (options.stdinData !== undefined && proc.stdin) {
@@ -83,7 +96,7 @@ export async function runSubprocess(command, args, options) {
                         exitCode: 1,
                         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
                         stderr: stdinError.message,
-                        timedOut: false
+                        launched: false
                     });
                 }
             }
@@ -98,9 +111,11 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         }))
         : commands.map((command) => ({ command, fastFail: true }));
     if (steps.length === 0) {
-        return { passed: true, summary: "No verification commands specified." };
+        return { passed: true, summary: "No verification commands specified.", steps: [] };
     }
     const failedSteps = [];
+    const stepOutcomes = [];
+    const warnings = [];
     for (const step of steps) {
         const parts = splitCommand(step.command);
         const [bin, ...args] = parts;
@@ -108,24 +123,53 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
             continue;
         }
         const result = await runSubprocess(bin, args, { cwd, timeoutMs, spawnImpl });
+        const detail = truncate(result.stderr.trim() || result.stdout.trim(), 500);
+        stepOutcomes.push({
+            command: step.command,
+            launched: result.launched,
+            exitCode: result.exitCode,
+            timedOut: result.timedOut,
+            fastFail: step.fastFail,
+            ...(detail ? { detail } : {})
+        });
         if (result.timedOut) {
-            return { passed: false, summary: `Verification timed out: ${step.command}` };
+            return {
+                passed: false,
+                summary: `Verification timed out: ${step.command}`,
+                steps: stepOutcomes,
+                ...(warnings.length ? { warnings } : {})
+            };
         }
         if (result.exitCode !== 0) {
-            const detail = truncate(result.stderr.trim() || result.stdout.trim(), 500);
             const summary = `Verification failed: ${step.command}\n${detail}`;
+            if (!result.launched) {
+                warnings.push(`Verifier never launched: ${step.command}`);
+            }
             if (step.fastFail) {
-                return { passed: false, summary };
+                return { passed: false, summary, steps: stepOutcomes, ...(warnings.length ? { warnings } : {}) };
             }
             failedSteps.push(step.command);
         }
     }
     if (failedSteps.length > 0) {
-        return { passed: false, summary: `Failed steps: ${failedSteps.join(", ")}` };
+        return {
+            passed: false,
+            summary: `Failed steps: ${failedSteps.join(", ")}`,
+            steps: stepOutcomes,
+            ...(warnings.length ? { warnings } : {})
+        };
     }
-    return { passed: true, summary: `All ${String(steps.length)} verification step(s) passed.` };
+    return {
+        passed: true,
+        summary: `All ${String(steps.length)} verification step(s) passed.`,
+        steps: stepOutcomes,
+        ...(warnings.length ? { warnings } : {})
+    };
 }
 export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl) {
+    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
@@ -140,6 +184,49 @@ export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl)
         ...(diffStats ? { diffStats } : {})
     };
 }
+export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
+    if (!resolveGitRepositoryRoot(repoRoot)) {
+        return [];
+    }
+    const statusResult = await runSubprocess("git", ["status", "-z", "--porcelain=v1", "--untracked-files=all", "--ignore-submodules=all", "--", "."], { cwd: repoRoot, timeoutMs, spawnImpl });
+    if (statusResult.exitCode !== 0) {
+        return [];
+    }
+    return parsePorcelainEntries(statusResult.stdout).filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+export function resolveGitRepositoryRoot(workingDirectory) {
+    const resolvedWorkingDirectory = resolve(workingDirectory);
+    const cached = gitRepositoryRootCache.get(resolvedWorkingDirectory);
+    if (cached !== undefined) {
+        return cached ?? undefined;
+    }
+    const visited = [];
+    let current = resolvedWorkingDirectory;
+    while (true) {
+        visited.push(current);
+        const currentCached = gitRepositoryRootCache.get(current);
+        if (currentCached !== undefined) {
+            for (const candidate of visited) {
+                gitRepositoryRootCache.set(candidate, currentCached);
+            }
+            return currentCached ?? undefined;
+        }
+        if (existsSync(resolve(current, ".git"))) {
+            for (const candidate of visited) {
+                gitRepositoryRootCache.set(candidate, current);
+            }
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            for (const candidate of visited) {
+                gitRepositoryRootCache.set(candidate, null);
+            }
+            return undefined;
+        }
+        current = parent;
+    }
+}
 export function createSpawnPlan(command, args, cwd, preserveRawForInjectedSpawn) {
     if (preserveRawForInjectedSpawn || process.platform !== "win32") {
         return { command, args };
@@ -150,17 +237,22 @@ export function createSpawnPlan(command, args, cwd, preserveRawForInjectedSpawn)
     // Windows can resolve the command itself — this covers cases like `pnpm` where the npm global
     // bin directory is present in the shell PATH but not yet visible to this Node.js process.
     if (resolvedOrUndefined === undefined) {
-        const cmdStr = [quoteWindowsCmdArg(command), ...args.map(quoteWindowsCmdArg)].join(" ");
         return {
             command: process.env.ComSpec || "cmd.exe",
-            args: ["/d", "/s", "/c", cmdStr]
+            args: ["/d", "/c", command, ...args]
         };
     }
     const extension = extname(resolvedOrUndefined).toLowerCase();
     if (extension === ".cmd" || extension === ".bat") {
         return {
             command: process.env.ComSpec || "cmd.exe",
-            args: ["/d", "/s", "/c", [quoteWindowsCmdArg(resolvedOrUndefined), ...args.map(quoteWindowsCmdArg)].join(" ")]
+            args: ["/d", "/c", resolvedOrUndefined, ...args]
+        };
+    }
+    if (extension === ".ps1") {
+        return {
+            command: "powershell.exe",
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolvedOrUndefined, ...args]
         };
     }
     return { command: resolvedOrUndefined, args };
@@ -186,11 +278,38 @@ function expandWindowsCommandCandidates(command) {
         return [command];
     }
     const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-    return pathExt
+    const fromPathExt = pathExt
         .split(";")
         .map((extension) => extension.trim())
         .filter(Boolean)
         .map((extension) => `${command}${extension.toLowerCase()}`);
+    const candidates = [...fromPathExt, `${command}.ps1`];
+    return Array.from(new Set(candidates));
+}
+function parsePorcelainEntries(stdout) {
+    const entries = stdout.split("\u0000").filter((entry) => entry.length > 0);
+    const changedFiles = [];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry === undefined || entry.length < 4) {
+            continue;
+        }
+        const status = entry.slice(0, 2);
+        const payload = entry.slice(3);
+        if (!payload) {
+            continue;
+        }
+        if (status.includes("R") || status.includes("C")) {
+            const renamedPath = entries[index + 1];
+            if (renamedPath && renamedPath.length > 0) {
+                changedFiles.push(renamedPath);
+                index += 1;
+                continue;
+            }
+        }
+        changedFiles.push(payload);
+    }
+    return changedFiles;
 }
 function windowsPathDirectories() {
     const rawPath = process.env.Path ?? process.env.PATH ?? "";
@@ -199,16 +318,6 @@ function windowsPathDirectories() {
         .map((entry) => entry.trim().replace(/^"|"$/g, ""))
         .filter(Boolean);
 }
-function quoteWindowsCmdArg(value) {
-    const normalized = value.replace(/\r?\n/gu, " ");
-    const escaped = normalized
-        .replace(/\^/gu, "^^")
-        .replace(/"/gu, '^"')
-        .replace(/%/gu, "%%")
-        .replace(/!/gu, "^^!")
-        .replace(/[&|<>()]/gu, (match) => `^${match}`);
-    return `"${escaped}"`;
-}
 export function splitCommand(command) {
     const tokens = [];
     let current = "";

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

@@ -0,0 +1,76 @@
+import { spawnSync } from "node:child_process";
+export interface CliCommandAvailability {
+    command: string;
+    available: boolean;
+    locator: string;
+    detail: string;
+    resolvedPath?: string;
+    candidatePaths?: string[];
+}
+export type CodexHostPlatform = "windows" | "linux" | "wsl" | "macos";
+export type CodexInstallKind = "missing" | "native" | "windows_shim" | "windows_mounted_path";
+export type CodexInvocationMode = "direct" | "cmd_shell" | "powershell";
+export interface CodexHostDiagnosis {
+    hostPlatform: CodexHostPlatform;
+    nativeInstallValid: boolean;
+    installKind: CodexInstallKind;
+    invocationMode: CodexInvocationMode;
+    sandboxMode: "workspace-write";
+    sandboxCompatible: boolean;
+    resolvedPath?: string;
+    nativeDependencyStatus?: "unknown" | "missing";
+    nativeDependencyPackage?: string;
+    warnings: string[];
+    remediation?: string;
+}
+export interface CodexLaunchProbeResult {
+    ok: boolean;
+    summary: string;
+    availability: CliCommandAvailability;
+    diagnosis: CodexHostDiagnosis;
+    command: string;
+    args: string[];
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    candidateProbeResults?: CodexProbeCandidateResult[];
+}
+export interface CodexExecArgsOptions {
+    workingDirectory: string;
+    sandbox?: "read-only" | "workspace-write" | "danger-full-access";
+    model?: string;
+    extraArgs?: string[];
+    mode?: "prompt" | "probe";
+}
+type SpawnSyncLike = typeof spawnSync;
+export interface CodexProbeCandidateResult {
+    path: string;
+    installKind: CodexInstallKind;
+    invocationMode: CodexInvocationMode;
+    nativeInstallValid: boolean;
+    sandboxCompatible: boolean;
+    launchReady: boolean;
+    summary: string;
+    remediation?: string;
+    nativeDependencyStatus?: "unknown" | "missing";
+    nativeDependencyPackage?: string;
+}
+export declare function buildCodexExecArgs(options: CodexExecArgsOptions): string[];
+export declare function resolveCliCommandAvailability(command: string, options?: {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    spawnSyncImpl?: SpawnSyncLike;
+}): CliCommandAvailability;
+export declare function detectCodexHostPlatform(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): CodexHostPlatform;
+export declare function diagnoseCodexHost(availability: CliCommandAvailability, options?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}): CodexHostDiagnosis;
+export declare function probeCodexLaunch(input: {
+    workingDirectory: string;
+    availability?: CliCommandAvailability;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    spawnSyncImpl?: SpawnSyncLike;
+}): CodexLaunchProbeResult;
+export {};