@martinloop/mcp 0.3.6 → 0.3.7

package/dist/server-validation.js

@@ -14,12 +14,12 @@ export function validateToolInput(name, args) {
             return validateStatusInput(args);
         case "martin_doctor":
             return validateDoctorInput(args);
+        case "martin_estimate":
+            return validateEstimateInput(args);
         case "martin_plan":
             return validatePlanInput(args);
         case "martin_preflight":
             return validatePreflightInput(args);
-        case "martin_estimate":
-            return validateEstimateInput(args);
         case "martin_logs":
             return validateLogsInput(args);
         case "martin_cancel":
@@ -254,27 +254,22 @@ function validateDoctorInput(args) {
         ...optionalEnumAsObject(record.engine, "engine", MARTIN_ENGINE_VALUES)
     };
 }
-function validatePreflightInput(args) {
-    return validateRunInput(args);
-}
-function validatePlanInput(args) {
-    return validateRunInput(args);
-}
 function validateEstimateInput(args) {
     const record = requireObject(args);
-    assertAllowedKeys(record, ["objective", "engine", "budgetUsd", "fileScope", "workingDirectory"]);
-    const engine = optionalEnum(record.engine, "engine", MARTIN_ENGINE_VALUES);
-    const fileScope = normalizeSafePathPatterns(record.fileScope, "fileScope");
+    assertAllowedKeys(record, ["objective", "engine", "budgetUsd", "fileScope"]);
     return {
         objective: requireString(record.objective, "objective"),
-        ...(engine ? { engine } : {}),
+        ...optionalEnumAsObject(record.engine, "engine", MARTIN_ENGINE_VALUES),
         ...optionalPositiveNumber(record.budgetUsd, "budgetUsd"),
-        ...(fileScope ? { fileScope } : {}),
-        ...(record.workingDirectory !== undefined
-            ? { workingDirectory: resolveSafeRepoRoot(requireString(record.workingDirectory, "workingDirectory")) }
-            : {})
+        ...optionalStringArrayAsObject(record.fileScope, "fileScope")
     };
 }
+function validatePreflightInput(args) {
+    return validateRunInput(args);
+}
+function validatePlanInput(args) {
+    return validateRunInput(args);
+}
 function validateLogsInput(args) {
     const record = requireObject(args);
     assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "limit"]);

package/dist/server.d.ts

@@ -16,7 +16,6 @@
  * Manual start:
  *   node dist/server.js
  */
-import { type Server as NodeHttpServer } from "node:http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 export declare function createMartinMcpServer(serverInfo?: {
     name?: string;
@@ -89,26 +88,4 @@ export declare function connectMartinMcpStdioServer(): Promise<Server<{
         } | undefined;
     } | undefined;
 }>>;
-export interface MartinMcpHttpServerOptions {
-    host?: string;
-    port?: number;
-    path?: string;
-}
-export interface MartinMcpHttpServerHandle {
-    server: NodeHttpServer;
-    host: string;
-    port: number;
-    path: string;
-    endpoint: string;
-    close: () => Promise<void>;
-}
-export declare function parseMartinMcpServerArgs(argv: string[]): {
-    transport: "stdio";
-} | {
-    transport: "http";
-    host: string;
-    port: number;
-    path: string;
-};
-export declare function connectMartinMcpHttpServer(options?: MartinMcpHttpServerOptions): Promise<MartinMcpHttpServerHandle>;
 export declare function isDirectExecutionEntry(entryPath: string | undefined, moduleUrl?: string): boolean;

package/dist/server.js

@@ -16,14 +16,12 @@
  * Manual start:
  *   node dist/server.js
  */
-import { createServer as createHttpServer } from "node:http";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { resolveRunsRoot } from "./vendor/core/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { MARTIN_MCP_PACKAGE_VERSION } from "./package-version.js";
 import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
@@ -1403,10 +1401,6 @@ export function createMartinMcpServer(serverInfo) {
                             type: "array",
                             items: { type: "string" },
                             description: "Optional file paths to scope the estimate."
-                        },
-                        workingDirectory: {
-                            type: "string",
-                            description: "Optional workspace path for recording the estimate receipt against the same task root you plan to run."
                         }
                     },
                     required: ["objective"]
@@ -1524,7 +1518,7 @@ export function createMartinMcpServer(serverInfo) {
                     workingDirectory: output.environment.workingDirectory,
                     engine: input.engine,
                     receiptScope: output.receiptScope
-                }).catch(() => { });
+                });
                 return createToolSuccessResult(output, output.summary);
             }
             if (name === "martin_plan") {
@@ -1541,7 +1535,7 @@ export function createMartinMcpServer(serverInfo) {
                         repoRoot: output.workingDirectory,
                         runsRoot: resolveRunsRoot(process.env)
                     }
-                }).catch(() => { });
+                });
                 return createToolSuccessResult(output, `Plan ready for ${output.objective} with ${output.risk.level} risk and ${output.approvalRecommendation.replace(/_/gu, " ")} approval.`);
             }
             if (name === "martin_preflight") {
@@ -1559,7 +1553,7 @@ export function createMartinMcpServer(serverInfo) {
                         allowedPaths: output.normalized.allowedPaths,
                         deniedPaths: output.normalized.deniedPaths,
                         budget: output.normalized.budget
-                    }).catch(() => { });
+                    });
                 }
                 return createToolSuccessResult(output, output.summary);
             }
@@ -1646,8 +1640,8 @@ export function createMartinMcpServer(serverInfo) {
                 const engine = input.engine ?? "claude";
                 const budgetUsd = input.budgetUsd ?? 5;
                 const fileScope = input.fileScope ?? [];
+                const workingDirectory = resolveSafeRepoRoot();
                 const runsRoot = resolveRunsRoot(process.env);
-                const workingDirectory = input.workingDirectory ?? resolveSafeRepoRoot();
                 const route = classifyRoute({
                     objective,
                     verificationPlan: [],
@@ -1679,14 +1673,8 @@ export function createMartinMcpServer(serverInfo) {
                     step: "estimate",
                     workingDirectory,
                     objective,
-                    engine,
-                    receiptScope: {
-                        invocationRoot: resolveSafeRepoRoot(),
-                        workingDirectory,
-                        repoRoot: workingDirectory,
-                        runsRoot
-                    }
-                }).catch(() => { });
+                    engine
+                });
                 return createToolSuccessResult(output, `Estimate: ${route.selectedMode} route (${route.recommendedModelTier}), ~$${route.expectedCostUsd.toFixed(2)} expected cost, ${route.expectedPreworkBurnPct}% pre-work burn. Recommended budget: $${recommendedBudgetUsd.toFixed(2)}.`);
             }
             return createToolErrorResult(toToolFailure(new Error(`Unknown tool: ${name}`)));
@@ -1710,114 +1698,6 @@ export async function connectMartinMcpStdioServer() {
     await server.connect(transport);
     return server;
 }
-export function parseMartinMcpServerArgs(argv) {
-    let transport = "stdio";
-    let host = "127.0.0.1";
-    let port = 3033;
-    let path = "/mcp";
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (token === "--http") {
-            transport = "http";
-            continue;
-        }
-        if (token === "--port") {
-            const next = argv[index + 1];
-            const parsed = Number(next);
-            if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
-                throw new Error(`Invalid --port value '${next ?? ""}'.`);
-            }
-            port = parsed;
-            index += 1;
-            continue;
-        }
-        if (token === "--host") {
-            const next = argv[index + 1];
-            if (!next) {
-                throw new Error("Missing value for --host.");
-            }
-            host = next;
-            index += 1;
-            continue;
-        }
-        if (token === "--path") {
-            const next = argv[index + 1];
-            if (!next || !next.startsWith("/")) {
-                throw new Error("MCP HTTP path must start with '/'.");
-            }
-            path = next;
-            index += 1;
-        }
-    }
-    return transport === "http"
-        ? { transport, host, port, path }
-        : { transport };
-}
-export async function connectMartinMcpHttpServer(options = {}) {
-    const host = options.host ?? "127.0.0.1";
-    const port = options.port ?? 3033;
-    const path = options.path ?? "/mcp";
-    const mcpServer = createMartinMcpServer();
-    const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: undefined
-    });
-    await mcpServer.connect(transport);
-    const httpServer = createHttpServer(async (req, res) => {
-        try {
-            const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? `${host}:${port}`}`);
-            if (requestUrl.pathname !== path) {
-                res.statusCode = 404;
-                res.setHeader("content-type", "application/json");
-                res.end(JSON.stringify({ error: "not_found", path: requestUrl.pathname }));
-                return;
-            }
-            if (req.method === "POST") {
-                const parsedBody = await readJsonBody(req, res);
-                if (res.writableEnded) {
-                    return;
-                }
-                await transport.handleRequest(req, res, parsedBody);
-                return;
-            }
-            if (req.method === "GET" || req.method === "DELETE") {
-                await transport.handleRequest(req, res);
-                return;
-            }
-            res.statusCode = 405;
-            res.setHeader("allow", "GET, POST, DELETE");
-            res.end();
-        }
-        catch (error) {
-            if (!res.headersSent) {
-                res.statusCode = 500;
-                res.setHeader("content-type", "application/json");
-                res.end(JSON.stringify({ error: "internal_error", message: error.message }));
-            }
-        }
-    });
-    await new Promise((resolve, reject) => {
-        httpServer.once("error", reject);
-        httpServer.listen(port, host, () => {
-            httpServer.off("error", reject);
-            resolve();
-        });
-    });
-    const address = httpServer.address();
-    const resolvedPort = typeof address === "object" && address ? address.port : port;
-    return {
-        server: httpServer,
-        host,
-        port: resolvedPort,
-        path,
-        endpoint: `http://${host}:${resolvedPort}${path}`,
-        close: async () => {
-            await transport.close();
-            await new Promise((resolve) => {
-                httpServer.close(() => resolve());
-            });
-        }
-    };
-}
 export function isDirectExecutionEntry(entryPath, moduleUrl = import.meta.url) {
     if (typeof entryPath !== "string" || entryPath.length === 0) {
         return false;
@@ -1838,30 +1718,5 @@ function realPathOrResolved(filePath) {
     }
 }
 if (isDirectExecution()) {
-    const startup = parseMartinMcpServerArgs(process.argv.slice(2));
-    if (startup.transport === "http") {
-        await connectMartinMcpHttpServer(startup);
-    }
-    else {
-        await connectMartinMcpStdioServer();
-    }
-}
-async function readJsonBody(req, res) {
-    const chunks = [];
-    for await (const chunk of req) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    const raw = Buffer.concat(chunks).toString("utf8").trim();
-    if (!raw) {
-        return undefined;
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        res.statusCode = 400;
-        res.setHeader("content-type", "application/json");
-        res.end(JSON.stringify({ error: "invalid_json" }));
-        return undefined;
-    }
+    await connectMartinMcpStdioServer();
 }

package/dist/tools/run-loop.d.ts

@@ -1,5 +1,5 @@
 import { type SpawnLike } from "../vendor/adapters/index.js";
-import { type RunStore } from "../vendor/core/index.js";
+import { type RunStore, type RunMartinInput, type RunMartinResult } from "../vendor/core/index.js";
 import type { LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
@@ -46,4 +46,5 @@ export interface RunLoopOutput {
 }
 export declare function __setProofModeVerifierSpawnImplForTests(spawnImpl?: SpawnLike): void;
 export declare function __setRunStoreOverrideForTests(store?: RunStore): void;
+export declare function __setRunMartinImplForTests(impl?: (input: RunMartinInput) => Promise<RunMartinResult>): void;
 export declare function runLoopTool(input: RunLoopInput): Promise<RunLoopOutput>;

package/dist/tools/run-loop.js

@@ -6,12 +6,16 @@ import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, build
 import { normalizeLoopBudget } from "./workflow-governance.js";
 let proofModeVerifierSpawnImpl;
 let runStoreOverrideForTests;
+let runMartinImpl = runMartin;
 export function __setProofModeVerifierSpawnImplForTests(spawnImpl) {
     proofModeVerifierSpawnImpl = spawnImpl;
 }
 export function __setRunStoreOverrideForTests(store) {
     runStoreOverrideForTests = store;
 }
+export function __setRunMartinImplForTests(impl) {
+    runMartinImpl = impl ?? runMartin;
+}
 export async function runLoopTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const engine = input.engine ?? "claude";
@@ -98,7 +102,7 @@ export async function runLoopTool(input) {
         partialBudget.maxTokens = input.maxTokens;
     }
     const budget = normalizeLoopBudget(partialBudget);
-    const result = await runMartin({
+    const result = await runMartinImpl({
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
         store: runStoreOverrideForTests ?? createFileRunStore({ runsRoot }),

package/dist/tools/tool-support.js

@@ -429,6 +429,7 @@ export function buildSuggestedResourceUris(loopId) {
         "martin://runs/triage",
         "martin://runs/latest",
         "martin://runs/latest/summary",
+        "martin://runs/latest/receipt",
         "martin://runs/latest/proof-card",
         "martin://runs/latest/budget-status",
         "martin://runs/latest/verifier-evidence",

package/dist/vendor/adapters/adapters/src/claude-cli.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Real agent-CLI adapters.
+ *
+ * Exports a generic factory (`createAgentCliAdapter`) and two pre-configured
+ * factories (`createClaudeCliAdapter`, `createCodexCliAdapter`) that spawn
+ * the respective AI coding CLI as a child subprocess.
+ *
+ * Usage in CLI:
+ *   createClaudeCliAdapter({ workingDirectory: process.cwd() })
+ *   createCodexCliAdapter({ workingDirectory: process.cwd() })
+ *
+ * MCP tools and integration tests use the same factories.
+ */
+import type { MartinAdapter, MartinAdapterRequest } from "../../../core/index.js";
+import { type SpawnLike } from "./cli-bridge.js";
+/**
+ * Given a prompt string, returns the full argv array to pass to spawn().
+ * Example for Claude:  () => ["--output-format", "json", "--print"]
+ * Example for Codex:   () => ["exec", "--sandbox", "workspace-write", "-"]
+ */
+export type CliArgsBuilder = (prompt: string, request: MartinAdapterRequest) => string[];
+export type CliStdinBuilder = (prompt: string) => string | undefined;
+export interface AgentCliAdapterOptions {
+    /** The executable to spawn (e.g. "claude", "codex"). */
+    command: string;
+    /** Converts a prompt string into the argv array passed to spawn(). */
+    argsBuilder: CliArgsBuilder;
+    /** Optional stdin payload for CLIs that accept prompt input via stdin or `-`. */
+    stdinBuilder?: CliStdinBuilder;
+    /** Adapter ID suffix. Defaults to command. */
+    adapterIdSuffix?: string;
+    /** Working directory for all subprocesses. Defaults to process.cwd(). */
+    workingDirectory?: string;
+    /** Timeout for the agent subprocess in ms. Defaults to 300_000 (5 min). */
+    timeoutMs?: number;
+    /** Timeout per verification command in ms. Defaults to 120_000 (2 min). */
+    verifyTimeoutMs?: number;
+    /** Human-readable label shown in loop records. */
+    label?: string;
+    /** Model name surfaced in adapter metadata (also used for cost estimation). */
+    model?: string;
+    /**
+     * Whether the CLI outputs JSON when --output-format json is passed.
+     * Set to false for CLIs that don't support this flag (e.g. Codex).
+     * Defaults to true for Claude.
+     */
+    supportsJsonOutput?: boolean;
+    /**
+     * Set when `argsBuilder` requests `--output-format stream-json` (newline-
+     * delimited JSON events) rather than single-blob `json`. Enables (a)
+     * incremental result parsing that scans for the final `result` event, and
+     * (b) a live cumulative-cost circuit breaker that terminates the subprocess
+     * the moment projected spend crosses the remaining per-attempt budget,
+     * rather than only learning about an overspend after the process exits.
+     */
+    streamingUsageCap?: boolean;
+    /** Test-only override for subprocess spawning. */
+    spawnImpl?: SpawnLike;
+}
+export interface ClaudeCliAdapterOptions {
+    workingDirectory?: string;
+    timeoutMs?: number;
+    verifyTimeoutMs?: number;
+    label?: string;
+    /** Override the model passed via --model flag. */
+    model?: string;
+    /** Extra args appended after core args (before prompt). */
+    extraArgs?: string[];
+    spawnImpl?: SpawnLike;
+}
+export interface CodexCliAdapterOptions {
+    /** Override the executable or absolute command path used to launch Codex. */
+    command?: string;
+    workingDirectory?: string;
+    timeoutMs?: number;
+    verifyTimeoutMs?: number;
+    label?: string;
+    /** Override the model passed via --model flag. */
+    model?: string;
+    /**
+     * Deprecated no-op retained for compatibility.
+     *
+     * Codex CLI's supported non-interactive entrypoint is `codex exec`.
+     * MartinLoop now uses explicit sandboxing instead of the legacy
+     * `--full-auto` compatibility path, which can exit before verifier execution.
+     */
+    fullAuto?: boolean;
+    /** Codex sandbox mode for model-generated commands. Defaults to workspace-write. */
+    sandbox?: "read-only" | "workspace-write" | "danger-full-access";
+    /** Extra args appended after core args (before prompt). */
+    extraArgs?: string[];
+    spawnImpl?: SpawnLike;
+}
+export interface GeminiCliAdapterOptions {
+    workingDirectory?: string;
+    timeoutMs?: number;
+    verifyTimeoutMs?: number;
+    label?: string;
+    /** Override the model passed via --model flag. Defaults to the Gemini `flash` alias. */
+    model?: string;
+    /** Approval mode for headless Gemini runs. Defaults to yolo for autonomous execution. */
+    approvalMode?: "default" | "auto_edit" | "yolo" | "plan";
+    /** Enable Gemini sandbox mode when the host is configured for it. Disabled by default. */
+    sandbox?: boolean;
+    /** Extra args appended after core args. */
+    extraArgs?: string[];
+    spawnImpl?: SpawnLike;
+}
+export declare function createAgentCliAdapter(options: AgentCliAdapterOptions): MartinAdapter;
+/**
+ * Spawns `claude --output-format stream-json --verbose --print "<prompt>" [extraArgs]`.
+ *
+ * `stream-json` emits one JSON event per line — including per-turn usage on
+ * each `assistant` message and a final `result` event carrying the same
+ * `result`/`usage`/`total_cost_usd` fields as single-blob `json` output — so
+ * MartinLoop can both (a) recover real token usage/cost as before, and
+ * (b) watch cumulative spend live and self-terminate the subprocess the
+ * moment it crosses the remaining per-attempt budget (see
+ * `streamingUsageCap` / `createStreamingUsageInspector`), instead of only
+ * discovering an overspend after the whole process has already exited.
+ *
+ * Requires the Claude Code CLI to be installed and authenticated:
+ *   https://docs.anthropic.com/claude-code
+ */
+export declare function createClaudeCliAdapter(options?: ClaudeCliAdapterOptions): MartinAdapter;
+/**
+ * Spawns `codex exec --cd <workspace> --sandbox <mode> [--model <model>] [extraArgs] -`.
+ *
+ * The prompt is delivered via stdin so Windows shell quoting cannot truncate or
+ * reinterpret long MartinLoop prompts that contain paths, deny rules, or budget
+ * context.
+ *
+ * Requires the Codex CLI to be installed and authenticated:
+ *   npm install -g @openai/codex
+ */
+export declare function createCodexCliAdapter(options?: CodexCliAdapterOptions): MartinAdapter;
+/**
+ * Spawns `gemini --model <model> --prompt "" --approval-mode <mode> --output-format json [...]`.
+ *
+ * The prompt is delivered via stdin while forcing headless mode with `--prompt ""`,
+ * which keeps large MartinLoop prompts off the command line on Windows.
+ *
+ * Requires the Gemini CLI to be installed and authenticated:
+ *   npm install -g @google/gemini-cli
+ */
+export declare function createGeminiCliAdapter(options?: GeminiCliAdapterOptions): MartinAdapter;