@martinloop/mcp 0.5.1 → 0.5.5

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

@@ -0,0 +1,69 @@
+import { spawnSync } from "node:child_process";
+import { type AgentExecutionIntent } from "../contracts/index.js";
+export type CodexFlagScope = "global" | "exec";
+export type CodexPromptTransport = "stdin-dash" | "argv";
+export type CodexWriteStrategy = "sandbox+approval" | "automation";
+export interface CodexCapabilityFlag {
+    flag: string;
+    scope: CodexFlagScope;
+}
+export interface CodexSandboxCapability extends CodexCapabilityFlag {
+    values: string[];
+}
+export interface CodexApprovalCapability extends CodexCapabilityFlag {
+    semantics: "approval-policy" | "automation-mode";
+    values?: string[];
+}
+export interface CodexAutonomyResolution {
+    binaryPath: string;
+    intent: AgentExecutionIntent;
+    strategy: "automation" | "sandbox+approval";
+    sandboxValue?: "workspace-write";
+    approvalValue?: string;
+}
+export interface CodexCapabilityProfile {
+    binaryPath: string;
+    supportsExec: boolean;
+    probeSucceeded: boolean;
+    probeError?: string;
+    model?: CodexCapabilityFlag;
+    cwd?: CodexCapabilityFlag;
+    sandbox?: CodexSandboxCapability;
+    /** Preferred compatibility alias. `automation` and `approvalPolicy` are authoritative. */
+    approval?: CodexApprovalCapability;
+    automation?: CodexApprovalCapability;
+    approvalPolicy?: CodexApprovalCapability;
+    json?: CodexCapabilityFlag;
+    color?: CodexCapabilityFlag & {
+        neverValue?: string;
+    };
+    userConfigIsolation?: CodexCapabilityFlag;
+    promptTransport: CodexPromptTransport;
+    promptTransports?: CodexPromptTransport[];
+}
+export interface CodexExecArgsOptions {
+    command?: string;
+    workingDirectory: string;
+    sandbox?: "read-only" | "workspace-write" | "danger-full-access";
+    model?: string;
+    extraArgs?: string[];
+    mode?: "prompt" | "probe";
+    prompt?: string;
+    capabilityProfile?: CodexCapabilityProfile;
+    promptTransport?: CodexPromptTransport;
+    writeStrategy?: CodexWriteStrategy;
+    autonomyResolution?: CodexAutonomyResolution;
+}
+type SpawnSyncLike = typeof spawnSync;
+export declare function clearCodexCapabilityCacheForTests(): void;
+export declare function cacheCodexCapabilityProfile(profile: CodexCapabilityProfile, platform?: NodeJS.Platform): CodexCapabilityProfile;
+export declare function probeCodexCapabilities(binaryPath: string, options?: {
+    platform?: NodeJS.Platform;
+    spawnSyncImpl?: SpawnSyncLike;
+    cache?: boolean;
+}): CodexCapabilityProfile;
+export declare function codexWriteStrategies(profile: CodexCapabilityProfile): CodexWriteStrategy[];
+export declare function resolveCodexAutonomyCandidates(profile: CodexCapabilityProfile, intent?: AgentExecutionIntent): CodexAutonomyResolution[];
+export declare function buildCodexExecArgs(options: CodexExecArgsOptions): string[];
+export declare function buildCodexStdin(profile: CodexCapabilityProfile, prompt: string, transport?: CodexPromptTransport): string | undefined;
+export {};

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

@@ -0,0 +1,265 @@
+import { spawnSync } from "node:child_process";
+import { extname } from "node:path";
+import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
+import { DEFAULT_AGENT_EXECUTION_INTENT } from "../contracts/index.js";
+const capabilityCache = new Map();
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function flagPattern(flag) {
+    return new RegExp(`(?:^|\\s)${escapeRegex(flag)}(?=\\s|[=,<\\[]|$)`, "imu");
+}
+function locateFlag(globalHelp, execHelp, candidates) {
+    for (const flag of candidates) {
+        if (flagPattern(flag).test(execHelp))
+            return { flag, scope: "exec" };
+    }
+    for (const flag of candidates) {
+        if (flagPattern(flag).test(globalHelp))
+            return { flag, scope: "global" };
+    }
+    return undefined;
+}
+function flagContext(help, flag) {
+    const lines = help.split(/\r?\n/u);
+    const index = lines.findIndex((line) => line.includes(flag));
+    if (index < 0)
+        return "";
+    return lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 3)).join("\n");
+}
+function parseAdvertisedValues(help, flag) {
+    const flagIndex = help.indexOf(flag);
+    if (flagIndex < 0)
+        return [];
+    const tail = help.slice(flagIndex);
+    const nextFlagOffset = tail.slice(flag.length).search(/\n\s*-/u);
+    const scoped = nextFlagOffset < 0
+        ? tail
+        : tail.slice(0, flag.length + nextFlagOffset);
+    const match = scoped.match(/possible values:\s*([^\]\n]+)/iu);
+    if (!match?.[1])
+        return [];
+    return match[1]
+        .split(",")
+        .map((value) => value.trim().replace(/[\].]$/u, ""))
+        .filter(Boolean);
+}
+function buildInjectedSpawnPlan(binaryPath, args, platform) {
+    if (platform !== "win32")
+        return { command: binaryPath, args };
+    const extension = extname(binaryPath).toLowerCase();
+    if (extension === ".cmd" || extension === ".bat" || extension === ".ps1") {
+        const script = resolveNpmShimScript(binaryPath);
+        if (script)
+            return { command: process.execPath, args: [script, ...args] };
+        if (extension === ".ps1") {
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", binaryPath, ...args]
+            };
+        }
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/c", binaryPath, ...args]
+        };
+    }
+    return { command: binaryPath, args };
+}
+function runHelpProbe(input) {
+    const plan = input.injected
+        ? buildInjectedSpawnPlan(input.binaryPath, input.args, input.platform)
+        : createSpawnPlan(input.binaryPath, input.args, process.cwd(), false);
+    const result = input.spawnSyncImpl(plan.command, plan.args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 8_000
+    });
+    return {
+        text: `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
+        status: result.status,
+        ...(result.error ? { error: result.error.message } : {})
+    };
+}
+function parsePromptTransports(execHelp) {
+    const transports = [];
+    const stdinAdvertised = /\bstdin\b/iu.test(execHelp) || /(?:^|\s)-(?:\s|,|$).*prompt/imu.test(execHelp);
+    const argvAdvertised = /(?:\[|<)PROMPT(?:\]|>)/iu.test(execHelp) || /\bPROMPT\b/iu.test(execHelp);
+    if (stdinAdvertised)
+        transports.push("stdin-dash");
+    if (argvAdvertised || !stdinAdvertised)
+        transports.push("argv");
+    return [...new Set(transports)];
+}
+export function clearCodexCapabilityCacheForTests() {
+    capabilityCache.clear();
+}
+export function cacheCodexCapabilityProfile(profile, platform = process.platform) {
+    capabilityCache.set(`${platform}:${profile.binaryPath}`, profile);
+    return profile;
+}
+export function probeCodexCapabilities(binaryPath, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const key = `${platform}:${binaryPath}`;
+    const useCache = options.cache ?? options.spawnSyncImpl === undefined;
+    if (useCache) {
+        const cached = capabilityCache.get(key);
+        if (cached)
+            return cached;
+    }
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const injected = options.spawnSyncImpl !== undefined;
+    const globalProbe = runHelpProbe({
+        binaryPath,
+        args: ["--help"],
+        platform,
+        spawnSyncImpl,
+        injected
+    });
+    const execProbe = runHelpProbe({
+        binaryPath,
+        args: ["exec", "--help"],
+        platform,
+        spawnSyncImpl,
+        injected
+    });
+    const globalHelp = globalProbe.text;
+    const execHelp = execProbe.text;
+    const supportsExec = execProbe.status === 0 &&
+        !/(unknown command|unrecognized subcommand|unexpected argument ['"]?exec)/iu.test(execHelp);
+    const sandboxFlag = locateFlag(globalHelp, execHelp, ["--sandbox", "-s"]);
+    const sandboxHelp = sandboxFlag
+        ? `${flagContext(globalHelp, sandboxFlag.flag)}\n${flagContext(execHelp, sandboxFlag.flag)}`
+        : "";
+    const sandboxValues = ["read-only", "workspace-write", "danger-full-access"].filter((value) => new RegExp(`\\b${escapeRegex(value)}\\b`, "iu").test(sandboxHelp));
+    const automationFlag = locateFlag(globalHelp, execHelp, ["--approve-for-me", "--full-auto"]);
+    const automation = automationFlag
+        ? { ...automationFlag, semantics: "automation-mode" }
+        : undefined;
+    const approvalFlag = locateFlag(globalHelp, execHelp, ["--ask-for-approval", "-a"]);
+    const approvalHelp = approvalFlag
+        ? `${flagContext(globalHelp, approvalFlag.flag)}\n${flagContext(execHelp, approvalFlag.flag)}`
+        : "";
+    const approvalValues = approvalFlag ? parseAdvertisedValues(approvalHelp, approvalFlag.flag) : [];
+    const approvalPolicy = approvalFlag
+        ? { ...approvalFlag, semantics: "approval-policy", values: approvalValues }
+        : undefined;
+    const colorFlag = locateFlag(globalHelp, execHelp, ["--color"]);
+    const colorHelp = colorFlag
+        ? `${flagContext(globalHelp, colorFlag.flag)}\n${flagContext(execHelp, colorFlag.flag)}`
+        : "";
+    const promptTransports = parsePromptTransports(execHelp);
+    const probeError = globalProbe.error ?? execProbe.error;
+    const profile = {
+        binaryPath,
+        supportsExec,
+        probeSucceeded: supportsExec && `${globalHelp}\n${execHelp}`.trim().length > 0,
+        ...(probeError ? { probeError } : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--model", "-m"])
+            ? { model: locateFlag(globalHelp, execHelp, ["--model", "-m"]) }
+            : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--cd", "--cwd", "--working-dir", "-C"])
+            ? { cwd: locateFlag(globalHelp, execHelp, ["--cd", "--cwd", "--working-dir", "-C"]) }
+            : {}),
+        ...(sandboxFlag ? { sandbox: { ...sandboxFlag, values: sandboxValues } } : {}),
+        ...(automation ? { automation, approval: automation } : {}),
+        ...(approvalPolicy
+            ? {
+                approvalPolicy,
+                ...(!automation ? { approval: approvalPolicy } : {})
+            }
+            : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--json"])
+            ? { json: locateFlag(globalHelp, execHelp, ["--json"]) }
+            : {}),
+        ...(colorFlag
+            ? {
+                color: {
+                    ...colorFlag,
+                    ...(/\bnever\b/iu.test(colorHelp) ? { neverValue: "never" } : {})
+                }
+            }
+            : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--ignore-user-config", "--no-user-config"])
+            ? { userConfigIsolation: locateFlag(globalHelp, execHelp, ["--ignore-user-config", "--no-user-config"]) }
+            : {}),
+        promptTransport: promptTransports[0] ?? "argv",
+        promptTransports
+    };
+    if (useCache)
+        cacheCodexCapabilityProfile(profile, platform);
+    return profile;
+}
+function pushCapabilityArg(globalArgs, execArgs, capability, ...values) {
+    (capability.scope === "global" ? globalArgs : execArgs).push(capability.flag, ...values);
+}
+export function codexWriteStrategies(profile) {
+    return resolveCodexAutonomyCandidates(profile).map((candidate) => candidate.strategy);
+}
+export function resolveCodexAutonomyCandidates(profile, intent = DEFAULT_AGENT_EXECUTION_INTENT) {
+    const candidates = [];
+    if (profile.automation) {
+        candidates.push({
+            binaryPath: profile.binaryPath,
+            intent,
+            strategy: "automation"
+        });
+    }
+    return candidates;
+}
+export function buildCodexExecArgs(options) {
+    const profile = options.capabilityProfile ?? probeCodexCapabilities(options.command ?? "codex");
+    if (!profile.supportsExec) {
+        throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise a usable exec subcommand.`);
+    }
+    const resolution = options.autonomyResolution;
+    if (options.mode !== "probe" && !resolution) {
+        throw new Error(`Resolved Codex binary ${profile.binaryPath} has no negotiated governed-autonomous execution resolution.`);
+    }
+    const permissionFlags = [profile.sandbox?.flag, profile.automation?.flag, profile.approvalPolicy?.flag]
+        .filter((value) => Boolean(value));
+    if ((options.extraArgs ?? []).some((arg) => arg === "danger-full-access" || permissionFlags.some((flag) => arg === flag || arg.startsWith(`${flag}=`)))) {
+        throw new Error("Permission and sandbox controls cannot be supplied through extraArgs.");
+    }
+    const globalArgs = [];
+    const execArgs = [];
+    const requestedSandbox = options.sandbox ?? "workspace-write";
+    const strategy = resolution?.strategy ?? options.writeStrategy;
+    const promptTransport = options.promptTransport ?? profile.promptTransport;
+    if (profile.userConfigIsolation)
+        pushCapabilityArg(globalArgs, execArgs, profile.userConfigIsolation);
+    if (profile.cwd)
+        pushCapabilityArg(globalArgs, execArgs, profile.cwd, options.workingDirectory);
+    if (requestedSandbox === "workspace-write") {
+        if (strategy === "sandbox+approval" && profile.sandbox?.values.includes("workspace-write")) {
+            pushCapabilityArg(globalArgs, execArgs, profile.sandbox, "workspace-write");
+        }
+        if (strategy === "automation" && profile.automation) {
+            pushCapabilityArg(globalArgs, execArgs, profile.automation);
+        }
+        if (strategy === "sandbox+approval" && profile.approvalPolicy && resolution?.approvalValue) {
+            pushCapabilityArg(globalArgs, execArgs, profile.approvalPolicy, resolution.approvalValue);
+        }
+    }
+    else {
+        if (!profile.sandbox?.values.includes(requestedSandbox)) {
+            throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise requested sandbox mode ${requestedSandbox}.`);
+        }
+        pushCapabilityArg(globalArgs, execArgs, profile.sandbox, requestedSandbox);
+    }
+    if (profile.json)
+        pushCapabilityArg(globalArgs, execArgs, profile.json);
+    if (profile.color?.neverValue)
+        pushCapabilityArg(globalArgs, execArgs, profile.color, profile.color.neverValue);
+    if (options.model) {
+        if (!profile.model) {
+            throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise a model override flag.`);
+        }
+        pushCapabilityArg(globalArgs, execArgs, profile.model, options.model);
+    }
+    const prompt = options.prompt ?? "";
+    const promptArgs = promptTransport === "stdin-dash" ? ["-"] : prompt ? [prompt] : [];
+    return [...globalArgs, "exec", ...execArgs, ...(options.extraArgs ?? []), ...promptArgs];
+}
+export function buildCodexStdin(profile, prompt, transport = profile.promptTransport) {
+    return transport === "stdin-dash" ? prompt : undefined;
+}

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

@@ -0,0 +1,23 @@
+import { type CodexCliAdapterOptions as LegacyCodexCliAdapterOptions } from "./claude-cli.js";
+import { type CodexAutonomyResolution, type CodexCapabilityProfile } from "./codex-launcher.js";
+export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOptions, "command"> {
+    /** Exact resolved executable selected by the Codex launch probe. */
+    command?: string;
+    /**
+     * Optional pre-probed capability profile. Production callers normally omit
+     * this because probeCodexCapabilities caches profiles by exact binary path
+     * for the process lifetime. Exposed for deterministic integrations/tests.
+     */
+    capabilityProfile?: CodexCapabilityProfile;
+    autonomyResolution?: CodexAutonomyResolution;
+}
+/**
+ * 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.
+ */
+export declare function createCodexCliAdapter(options?: CodexCliAdapterOptions): import("../core/index.js").MartinAdapter;

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

@@ -0,0 +1,72 @@
+import { spawn } from "node:child_process";
+import { createAgentCliAdapter } from "./claude-cli.js";
+import { buildCodexExecArgs, buildCodexStdin, 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.
+ */
+export function createCodexCliAdapter(options = {}) {
+    const workingDirectory = options.workingDirectory ?? process.cwd();
+    const selectedBinary = options.command ?? options.capabilityProfile?.binaryPath ?? "codex";
+    const capabilityProfile = options.capabilityProfile ?? probeCodexCapabilities(selectedBinary);
+    const autonomyResolution = options.autonomyResolution;
+    if (capabilityProfile.binaryPath !== selectedBinary) {
+        throw new Error("Codex exact binary capability profile mismatch.");
+    }
+    if (autonomyResolution && autonomyResolution.binaryPath !== selectedBinary) {
+        throw new Error("Codex exact binary autonomy resolution mismatch.");
+    }
+    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.
+        command: "codex",
+        adapterIdSuffix: "codex",
+        model: options.model,
+        label: options.label ?? "Codex CLI adapter",
+        workingDirectory,
+        timeoutMs: options.timeoutMs,
+        agentExecutionIntent: options.agentExecutionIntent,
+        providerExecutionTimeoutMs: options.providerExecutionTimeoutMs,
+        verifyTimeoutMs: options.verifyTimeoutMs,
+        supportsJsonOutput: false,
+        spawnImpl,
+        argsBuilder: (prompt) => buildCodexExecArgs({
+            command: selectedBinary,
+            workingDirectory,
+            sandbox,
+            ...(launchModel ? { model: launchModel } : {}),
+            extraArgs,
+            mode: "prompt",
+            prompt,
+            capabilityProfile,
+            ...(autonomyResolution ? { autonomyResolution } : {})
+        }),
+        stdinBuilder: (prompt) => buildCodexStdin(capabilityProfile, prompt)
+    });
+}

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

@@ -0,0 +1,107 @@
+import { spawnSync } from "node:child_process";
+import { type CodexAutonomyResolution, type CodexCapabilityProfile, type CodexPromptTransport, type CodexWriteStrategy } from "./codex-capabilities.js";
+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 CodexProbeCandidateResult {
+    path: string;
+    installKind: CodexInstallKind;
+    invocationMode: CodexInvocationMode;
+    nativeInstallValid: boolean;
+    sandboxCompatible: boolean;
+    launchReady: boolean;
+    summary: string;
+    remediation?: string;
+    nativeDependencyStatus?: "unknown" | "missing";
+    nativeDependencyPackage?: string;
+    capabilityProfile?: CodexCapabilityProfile;
+    writeStrategy?: CodexWriteStrategy;
+    autonomyResolution?: CodexAutonomyResolution;
+    promptTransport?: CodexPromptTransport;
+}
+export interface CodexLaunchProbeResult {
+    ok: boolean;
+    summary: string;
+    availability: CliCommandAvailability;
+    diagnosis: CodexHostDiagnosis;
+    command: string;
+    args: string[];
+    capabilityProfile?: CodexCapabilityProfile;
+    writeStrategy?: CodexWriteStrategy;
+    autonomyResolution?: CodexAutonomyResolution;
+    promptTransport?: CodexPromptTransport;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    candidateProbeResults?: CodexProbeCandidateResult[];
+}
+type SpawnSyncLike = typeof spawnSync;
+export interface CodexSandboxPreflightOk {
+    ok: true;
+    effectiveSandbox: "read-only" | "workspace-write";
+    capabilitySource: "probe";
+    writableRoot: string;
+}
+export interface CodexSandboxPreflightReadOnly {
+    ok: false;
+    code: "provider_sandbox_read_only";
+    requestedCapability: "workspace-write";
+    detectedCapability: "read-only";
+    effectiveSandbox: "read-only";
+    affectedPath: string;
+    writableRoot: string;
+    capabilitySource: "probe";
+    remediation: string;
+}
+export type CodexSandboxPreflightOutcome = CodexSandboxPreflightOk | CodexSandboxPreflightReadOnly;
+export declare function probeFilesystemWriteCapability(directory: string): {
+    writable: true;
+} | {
+    writable: false;
+    reason: string;
+};
+export declare function checkCodexSandboxPreflight(input: {
+    requestedSandbox: "read-only" | "workspace-write";
+    workingDirectory: string;
+}): CodexSandboxPreflightOutcome;
+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;
+    model?: string;
+    providerExecutionTimeoutMs?: number;
+}): CodexLaunchProbeResult;
+export {};