axexec 1.0.0 → 1.1.1

package/dist/credentials/types.d.ts

@@ -1,15 +1,6 @@
 /**
  * Credential types for axexec.
  */
-/** Raw credentials that can be installed for any agent */
-interface RawCredentials {
-    /** OAuth credentials (access token, refresh token, etc.) */
-    oauth?: Record<string, unknown>;
-    /** API key for direct API access */
-    apiKey?: string;
-    /** GitHub token for Copilot */
-    githubToken?: string;
-}
 /** Result of credential installation */
 interface InstallResult {
     /** Environment variables to pass to the agent subprocess */
@@ -21,4 +12,4 @@ interface InstallResult {
     /** Base temporary directory (for cleanup) */
     baseDirectory: string;
 }
-export type { InstallResult, RawCredentials };
+export type { InstallResult };

package/dist/credentials/write-agent-credentials.d.ts

@@ -2,35 +2,57 @@
  * Per-agent credential file writers.
  *
  * Each agent has its own credential file format. These functions
- * write credentials in the agent-specific format.
+ * write credentials in the agent-specific format, extracting what
+ * they need from the canonical Credentials type.
  */
-import type { RawCredentials } from "./types.js";
+import type { Credentials } from "./credentials.js";
+type WarningWriter = (message: string) => void;
 /**
  * Installs Claude credentials to a config directory.
  *
  * File: .credentials.json
  * Format: { claudeAiOauth: { ... } }
+ *
+ * Handles:
+ * - oauth-credentials: Full OAuth data written to file
+ * - oauth-token: Not written (env var only)
+ * - api-key: Not written (env var only)
  */
-declare function installClaudeCredentials(configDirectory: string, credentials: RawCredentials): void;
+declare function installClaudeCredentials(configDirectory: string, credentials: Credentials): void;
 /**
  * Installs Codex credentials to a config directory.
  *
  * File: auth.json
  * Format: { OPENAI_API_KEY: "..." } or { tokens: { ... }, last_refresh: "..." }
+ *
+ * Handles:
+ * - api-key: Written as { OPENAI_API_KEY: "..." }
+ * - oauth-credentials: Written as { tokens: { ... }, last_refresh: "..." }
  */
-declare function installCodexCredentials(configDirectory: string, credentials: RawCredentials): void;
+declare function installCodexCredentials(configDirectory: string, credentials: Credentials, warn?: WarningWriter): void;
 /**
  * Installs Gemini credentials to a config directory.
  *
  * File: oauth_creds.json
  * Format: { access_token: "...", refresh_token: "...", ... }
+ *
+ * Handles:
+ * - oauth-credentials: Full OAuth data written to file
+ * - api-key: Not written (env var only)
  */
-declare function installGeminiCredentials(configDirectory: string, credentials: RawCredentials): void;
+declare function installGeminiCredentials(configDirectory: string, credentials: Credentials): void;
 /**
  * Installs OpenCode credentials to a data directory.
  *
  * File: auth.json
  * Format: { anthropic: { type: "oauth", ... }, openai: { type: "api", ... } }
+ *
+ * OpenCode is a multi-provider agent. The Credentials.provider field
+ * specifies which provider (anthropic, openai, etc.) the credential is for.
+ *
+ * Handles:
+ * - oauth-credentials: Written as { [provider]: { type: "oauth", ...data } }
+ * - api-key: Written as { [provider]: { type: "api", key: "..." } }
  */
-declare function installOpenCodeCredentials(dataDirectory: string, credentials: RawCredentials): void;
+declare function installOpenCodeCredentials(dataDirectory: string, credentials: Credentials, warn?: WarningWriter): void;
 export { installClaudeCredentials, installCodexCredentials, installGeminiCredentials, installOpenCodeCredentials, };

package/dist/credentials/write-agent-credentials.js

@@ -2,45 +2,74 @@
  * Per-agent credential file writers.
  *
  * Each agent has its own credential file format. These functions
- * write credentials in the agent-specific format.
+ * write credentials in the agent-specific format, extracting what
+ * they need from the canonical Credentials type.
  */
 import path from "node:path";
+import { resolveStringField } from "./resolve-string-field.js";
 import { saveJsonFile } from "./save-json-file.js";
+function normalizeOpenCodeProvider(provider) {
+    if (!provider)
+        return "anthropic";
+    return provider === "gemini" ? "google" : provider;
+}
+function defaultWarningWriter(message) {
+    const formatted = message.endsWith("\n") ? message : `${message}\n`;
+    process.stderr.write(formatted);
+}
 /**
  * Installs Claude credentials to a config directory.
  *
  * File: .credentials.json
  * Format: { claudeAiOauth: { ... } }
+ *
+ * Handles:
+ * - oauth-credentials: Full OAuth data written to file
+ * - oauth-token: Not written (env var only)
+ * - api-key: Not written (env var only)
  */
 function installClaudeCredentials(configDirectory, credentials) {
-    if (!credentials.oauth && !credentials.apiKey) {
+    // Only oauth-credentials need file installation
+    if (credentials.type !== "oauth-credentials") {
         return;
     }
     const credentialsPath = path.join(configDirectory, ".credentials.json");
-    if (credentials.oauth) {
-        saveJsonFile(credentialsPath, { claudeAiOauth: credentials.oauth });
-    }
-    // API key is passed via environment variable, not file
+    saveJsonFile(credentialsPath, { claudeAiOauth: credentials.data });
 }
 /**
  * Installs Codex credentials to a config directory.
  *
  * File: auth.json
  * Format: { OPENAI_API_KEY: "..." } or { tokens: { ... }, last_refresh: "..." }
+ *
+ * Handles:
+ * - api-key: Written as { OPENAI_API_KEY: "..." }
+ * - oauth-credentials: Written as { tokens: { ... }, last_refresh: "..." }
  */
-function installCodexCredentials(configDirectory, credentials) {
-    if (!credentials.oauth && !credentials.apiKey) {
-        return;
-    }
+function installCodexCredentials(configDirectory, credentials, warn = defaultWarningWriter) {
     const authPath = path.join(configDirectory, "auth.json");
-    if (credentials.apiKey) {
-        saveJsonFile(authPath, { OPENAI_API_KEY: credentials.apiKey });
-    }
-    else if (credentials.oauth) {
-        saveJsonFile(authPath, {
-            tokens: credentials.oauth,
-            last_refresh: new Date().toISOString(),
-        });
+    switch (credentials.type) {
+        case "api-key": {
+            const apiKey = resolveStringField(credentials.data, "apiKey", "key");
+            if (!apiKey) {
+                warn("Warning: installCodexCredentials: no API key found in credentials.data. auth.json was not written.");
+                break;
+            }
+            saveJsonFile(authPath, { OPENAI_API_KEY: apiKey });
+            break;
+        }
+        case "oauth-credentials": {
+            saveJsonFile(authPath, {
+                tokens: credentials.data,
+                last_refresh: new Date().toISOString(),
+            });
+            break;
+        }
+        case "oauth-token": {
+            // OAuth tokens are not applicable for Codex (uses API key only)
+            warn("Warning: installCodexCredentials: oauth-token credentials are not applicable for Codex. No authentication was configured.");
+            break;
+        }
     }
 }
 /**
@@ -48,43 +77,59 @@ function installCodexCredentials(configDirectory, credentials) {
  *
  * File: oauth_creds.json
  * Format: { access_token: "...", refresh_token: "...", ... }
+ *
+ * Handles:
+ * - oauth-credentials: Full OAuth data written to file
+ * - api-key: Not written (env var only)
  */
 function installGeminiCredentials(configDirectory, credentials) {
-    if (!credentials.oauth && !credentials.apiKey) {
+    // Only oauth-credentials need file installation
+    if (credentials.type !== "oauth-credentials") {
         return;
     }
-    if (credentials.oauth) {
-        const credentialsPath = path.join(configDirectory, "oauth_creds.json");
-        saveJsonFile(credentialsPath, credentials.oauth);
-    }
-    // API key is passed via environment variable, not file
+    const credentialsPath = path.join(configDirectory, "oauth_creds.json");
+    saveJsonFile(credentialsPath, credentials.data);
 }
 /**
  * Installs OpenCode credentials to a data directory.
  *
  * File: auth.json
  * Format: { anthropic: { type: "oauth", ... }, openai: { type: "api", ... } }
+ *
+ * OpenCode is a multi-provider agent. The Credentials.provider field
+ * specifies which provider (anthropic, openai, etc.) the credential is for.
+ *
+ * Handles:
+ * - oauth-credentials: Written as { [provider]: { type: "oauth", ...data } }
+ * - api-key: Written as { [provider]: { type: "api", key: "..." } }
  */
-function installOpenCodeCredentials(dataDirectory, credentials) {
-    if (!credentials.oauth && !credentials.apiKey) {
-        return;
-    }
+function installOpenCodeCredentials(dataDirectory, credentials, warn = defaultWarningWriter) {
     const authPath = path.join(dataDirectory, "auth.json");
-    const authData = {};
-    if (credentials.oauth) {
-        authData.anthropic = {
-            type: "oauth",
-            ...credentials.oauth,
-        };
-    }
-    if (credentials.apiKey) {
-        authData.anthropic = {
-            type: "api",
-            key: credentials.apiKey,
-        };
-    }
-    if (Object.keys(authData).length > 0) {
-        saveJsonFile(authPath, authData);
+    const provider = normalizeOpenCodeProvider(credentials.provider);
+    switch (credentials.type) {
+        case "oauth-credentials": {
+            saveJsonFile(authPath, {
+                [provider]: {
+                    type: "oauth",
+                    ...credentials.data,
+                },
+            });
+            break;
+        }
+        case "api-key": {
+            const apiKey = resolveStringField(credentials.data, "apiKey", "key");
+            if (!apiKey) {
+                warn(`Warning: installOpenCodeCredentials: no API key found in credentials.data for provider "${provider}". auth.json was not written.`);
+                break;
+            }
+            saveJsonFile(authPath, {
+                [provider]: {
+                    type: "api",
+                    key: apiKey,
+                },
+            });
+            break;
+        }
     }
 }
 // Note: Copilot uses environment variables (GITHUB_TOKEN), not file-based credentials.

package/dist/execute-agent.d.ts

@@ -0,0 +1,12 @@
+import type { AgentAdapter } from "./types/adapter.js";
+import type { AgentCli } from "./types/events.js";
+import type { RunAgentOptions, RunResult } from "./types/run-result.js";
+import type { Credentials } from "./credentials/credentials.js";
+import type { installCredentials } from "./credentials/install-credentials.js";
+import type { DiagnosticWriter } from "./resolve-run-diagnostics.js";
+type CredentialInstallResult = Awaited<ReturnType<typeof installCredentials>>;
+/**
+ * Executes agent and streams events.
+ */
+declare function executeAgent(agentId: AgentCli, adapter: AgentAdapter, options: RunAgentOptions, configEnvironment: Record<string, string>, credentialResult: CredentialInstallResult | undefined, credentials: Credentials | undefined, preserveConfigDirectory: boolean, emitError: DiagnosticWriter): Promise<RunResult>;
+export { executeAgent };

package/dist/execute-agent.js

@@ -0,0 +1,68 @@
+import { isStreamableAdapter } from "./types/adapter.js";
+import { cleanupCredentials } from "./credentials/install-credentials.js";
+import { streamAgent } from "./stream-agent.js";
+import { resolveOutputMode } from "./resolve-output-mode.js";
+import { createEventWriter } from "./write-event.js";
+import { DependencyError } from "./resolve-binary.js";
+import { buildExecutionMetadata } from "./build-execution-metadata.js";
+/**
+ * Executes agent and streams events.
+ */
+async function executeAgent(agentId, adapter, options, configEnvironment, credentialResult, credentials, preserveConfigDirectory, emitError) {
+    const runOptions = {
+        prompt: options.prompt,
+        verbose: options.verbose ?? false,
+        model: options.model,
+        rawLogPath: options.rawLog,
+        debug: options.debug,
+        configEnv: configEnvironment,
+        preserveGithubSha: options.preserveGithubSha,
+    };
+    const outputMode = resolveOutputMode(options.format, process.stdout.isTTY);
+    const writeEvent = createEventWriter(outputMode);
+    const events = [];
+    // Build execution metadata (same for success and error cases)
+    const execution = buildExecutionMetadata(agentId, options, credentialResult, credentials, preserveConfigDirectory);
+    try {
+        const eventStream = isStreamableAdapter(adapter)
+            ? adapter.streamSession(runOptions)
+            : streamAgent(adapter, runOptions);
+        for await (const event of eventStream) {
+            events.push(event);
+            writeEvent(event);
+        }
+        const success = adapter.isSuccess(events);
+        return { events, success, execution };
+    }
+    catch (error) {
+        if (error instanceof DependencyError) {
+            emitError(error.message);
+            const errorEvent = {
+                type: "session.error",
+                code: "DEPENDENCY_ERROR",
+                message: error.message,
+                timestamp: Date.now(),
+            };
+            events.push(errorEvent);
+            writeEvent(errorEvent);
+            return { events, success: false, execution };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const errorEvent = {
+            type: "session.error",
+            code: "SPAWN_ERROR",
+            message,
+            timestamp: Date.now(),
+        };
+        events.push(errorEvent);
+        writeEvent(errorEvent);
+        return { events, success: false, execution };
+    }
+    finally {
+        // Clean up temp directory unless caller wants to preserve it
+        if (credentialResult && !preserveConfigDirectory) {
+            await cleanupCredentials(credentialResult.baseDirectory);
+        }
+    }
+}
+export { executeAgent };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * axexec - Unified execution engine for AI coding agents.
+ *
+ * Programmatic API for running agents with credential isolation,
+ * config generation, and normalized event streaming.
+ */
+import "./agents/claude-code/adapter.js";
+import "./agents/codex/adapter.js";
+import "./agents/gemini/adapter.js";
+import "./agents/opencode/adapter.js";
+import "./agents/copilot/adapter.js";
+export { runAgent } from "./run-agent.js";
+export { cleanupCredentials } from "./credentials/install-credentials.js";
+export type { ExecutionCredentials, ExecutionDirectories, ExecutionMetadata, RunAgentDiagnostics, RunAgentOptions, RunResult, } from "./types/run-result.js";
+export type { AxexecEvent, AgentCli } from "./types/events.js";
+export type { Credentials } from "./credentials/credentials.js";

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * axexec - Unified execution engine for AI coding agents.
+ *
+ * Programmatic API for running agents with credential isolation,
+ * config generation, and normalized event streaming.
+ */
+// Import all adapters to trigger self-registration
+import "./agents/claude-code/adapter.js";
+import "./agents/codex/adapter.js";
+import "./agents/gemini/adapter.js";
+import "./agents/opencode/adapter.js";
+import "./agents/copilot/adapter.js";
+// Main entry point
+export { runAgent } from "./run-agent.js";
+// Cleanup utility for use with preserveConfigDirectory option
+export { cleanupCredentials } from "./credentials/install-credentials.js";

package/dist/parse-credentials.d.ts

@@ -1,13 +1,27 @@
 /**
  * Credential parsing from environment variables.
+ *
+ * Used by axexec CLI to read credentials from environment when
+ * not provided via the programmatic API.
  */
-import type { RawCredentials } from "./credentials/install-credentials.js";
+import type { AgentCli } from "axshared";
+import { type Credentials } from "./credentials/credentials.js";
+type ParseCredentialsResult = {
+    ok: true;
+    credentials: Credentials | undefined;
+} | {
+    ok: false;
+    message: string;
+    exitCode: number;
+};
 /**
  * Parses credentials from environment variables.
  *
  * Environment variables checked (in order):
- * - AX_<AGENT>_CREDENTIALS: JSON with credentials
+ * - AX_<AGENT>_CREDENTIALS: JSON with full Credentials object
  * - Standard env vars: ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
+ *
+ * Returns ok with undefined credentials if none are found.
  */
-declare function parseCredentialsFromEnvironment(agentId: string): RawCredentials;
+declare function parseCredentialsFromEnvironment(agentId: AgentCli, model?: string): ParseCredentialsResult;
 export { parseCredentialsFromEnvironment };

package/dist/parse-credentials.js

@@ -1,63 +1,182 @@
 /**
  * Credential parsing from environment variables.
+ *
+ * Used by axexec CLI to read credentials from environment when
+ * not provided via the programmatic API.
  */
+import { parseCredentials, } from "./credentials/credentials.js";
+import { getEnvironmentTrimmed } from "./credentials/get-environment-trimmed.js";
 /**
  * Parses credentials from environment variables.
  *
  * Environment variables checked (in order):
- * - AX_<AGENT>_CREDENTIALS: JSON with credentials
+ * - AX_<AGENT>_CREDENTIALS: JSON with full Credentials object
  * - Standard env vars: ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
+ *
+ * Returns ok with undefined credentials if none are found.
  */
-function parseCredentialsFromEnvironment(agentId) {
-    const credentials = {};
-    // Check for axexec credentials env var
+function parseCredentialsFromEnvironment(agentId, model) {
+    // Check for axexec credentials env var (full Credentials JSON)
     const credEnvironmentVariable = `AX_${agentId.toUpperCase()}_CREDENTIALS`;
     const credEnvironmentValue = process.env[credEnvironmentVariable];
     if (credEnvironmentValue) {
         try {
             const parsed = JSON.parse(credEnvironmentValue);
-            return parsed;
+            const parseResult = parseCredentials(parsed);
+            if (parseResult.ok) {
+                if (parseResult.credentials.agent !== agentId) {
+                    return {
+                        ok: false,
+                        exitCode: 2,
+                        message: `Error: ${credEnvironmentVariable} agent mismatch. ` +
+                            `Expected ${agentId}, got ${parseResult.credentials.agent}.`,
+                    };
+                }
+                return { ok: true, credentials: parseResult.credentials };
+            }
+            return {
+                ok: false,
+                exitCode: 2,
+                message: `Error: Invalid credentials format in ${credEnvironmentVariable}: ` +
+                    parseResult.error,
+            };
         }
-        catch {
-            process.stderr.write(`Warning: Failed to parse ${credEnvironmentVariable}\n`);
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                exitCode: 2,
+                message: `Error: Failed to parse ${credEnvironmentVariable}: ${message}`,
+            };
         }
     }
-    // Fall back to standard env vars
+    // Fall back to standard API key env vars
+    return parseApiKeyFromEnvironment(agentId, model);
+}
+/**
+ * Parses API key from standard environment variables.
+ */
+function parseApiKeyFromEnvironment(agentId, model) {
+    let apiKey;
     switch (agentId) {
         case "claude": {
-            if (process.env["ANTHROPIC_API_KEY"]) {
-                credentials.apiKey = process.env["ANTHROPIC_API_KEY"];
+            // Check for OAuth token first (higher priority)
+            const oauthToken = getEnvironmentTrimmed("CLAUDE_CODE_OAUTH_TOKEN");
+            if (oauthToken) {
+                return {
+                    ok: true,
+                    credentials: {
+                        agent: agentId,
+                        type: "oauth-token",
+                        data: { oauthToken },
+                    },
+                };
             }
+            apiKey = getEnvironmentTrimmed("ANTHROPIC_API_KEY");
             break;
         }
         case "codex": {
-            if (process.env["OPENAI_API_KEY"]) {
-                credentials.apiKey = process.env["OPENAI_API_KEY"];
-            }
+            apiKey = getEnvironmentTrimmed("OPENAI_API_KEY");
             break;
         }
         case "gemini": {
-            if (process.env["GEMINI_API_KEY"]) {
-                credentials.apiKey = process.env["GEMINI_API_KEY"];
-            }
+            apiKey = getEnvironmentTrimmed("GEMINI_API_KEY");
             break;
         }
         case "opencode": {
-            if (process.env["ANTHROPIC_API_KEY"]) {
-                credentials.apiKey = process.env["ANTHROPIC_API_KEY"];
-            }
-            break;
+            // OpenCode can use multiple providers
+            return parseOpenCodeApiKeyFromEnvironment(model);
         }
         case "copilot": {
-            const token = process.env["GITHUB_TOKEN"] ??
-                process.env["GH_TOKEN"] ??
-                process.env["COPILOT_GITHUB_TOKEN"];
-            if (token) {
-                credentials.githubToken = token;
-            }
+            apiKey =
+                getEnvironmentTrimmed("COPILOT_GITHUB_TOKEN") ??
+                    getEnvironmentTrimmed("GH_TOKEN") ??
+                    getEnvironmentTrimmed("GITHUB_TOKEN");
             break;
         }
     }
-    return credentials;
+    if (!apiKey) {
+        return { ok: true, credentials: undefined };
+    }
+    return {
+        ok: true,
+        credentials: {
+            agent: agentId,
+            type: "api-key",
+            data: { apiKey },
+        },
+    };
+}
+function normalizeOpenCodeProvider(provider) {
+    if (!provider)
+        return undefined;
+    return provider === "gemini" ? "google" : provider;
+}
+function parseOpenCodeApiKeyFromEnvironment(model) {
+    const providers = [
+        {
+            provider: "anthropic",
+            envVar: "ANTHROPIC_API_KEY",
+            value: getEnvironmentTrimmed("ANTHROPIC_API_KEY"),
+        },
+        {
+            provider: "openai",
+            envVar: "OPENAI_API_KEY",
+            value: getEnvironmentTrimmed("OPENAI_API_KEY"),
+        },
+        {
+            provider: "google",
+            envVar: "GEMINI_API_KEY",
+            value: getEnvironmentTrimmed("GEMINI_API_KEY"),
+        },
+    ];
+    const available = providers.filter((entry) => entry.value !== undefined);
+    const modelProvider = normalizeOpenCodeProvider(model?.split("/")[0]);
+    if (modelProvider &&
+        ["anthropic", "openai", "google"].includes(modelProvider)) {
+        const match = providers.find((entry) => entry.provider === modelProvider);
+        if (match?.value) {
+            return {
+                ok: true,
+                credentials: {
+                    agent: "opencode",
+                    type: "api-key",
+                    provider: modelProvider,
+                    data: { apiKey: match.value },
+                },
+            };
+        }
+        const requiredEnvironmentVariable = match?.envVar ?? "AX_OPENCODE_CREDENTIALS";
+        return {
+            ok: false,
+            exitCode: 2,
+            message: `Error: ${requiredEnvironmentVariable} is required for OpenCode ` +
+                `model provider "${modelProvider}".`,
+        };
+    }
+    if (available.length === 0) {
+        return { ok: true, credentials: undefined };
+    }
+    if (available.length === 1) {
+        const match = available[0];
+        if (!match)
+            return { ok: true, credentials: undefined };
+        return {
+            ok: true,
+            credentials: {
+                agent: "opencode",
+                type: "api-key",
+                provider: match.provider,
+                data: { apiKey: match.value },
+            },
+        };
+    }
+    const environmentList = available.map((entry) => entry.envVar).join(", ");
+    return {
+        ok: false,
+        exitCode: 2,
+        message: "Error: Multiple OpenCode API keys detected. " +
+            `Set AX_OPENCODE_CREDENTIALS to disambiguate (${environmentList}).`,
+    };
 }
 export { parseCredentialsFromEnvironment };

package/dist/resolve-run-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { RunAgentOptions } from "./types/run-result.js";
+type DiagnosticWriter = (message: string) => void;
+declare function resolveDiagnostics(options: RunAgentOptions): {
+    error: DiagnosticWriter;
+    warn: DiagnosticWriter;
+};
+declare function resolveExitCodeSetter(options: RunAgentOptions): (code: number) => void;
+export type { DiagnosticWriter };
+export { resolveDiagnostics, resolveExitCodeSetter };

package/dist/resolve-run-diagnostics.js

@@ -0,0 +1,35 @@
+function formatDiagnosticMessage(message) {
+    return message.endsWith("\n") ? message : `${message}\n`;
+}
+function resolveDiagnostics(options) {
+    if (options.diagnostics) {
+        const diagnostics = options.diagnostics;
+        return {
+            error: (message) => {
+                diagnostics.error(formatDiagnosticMessage(message));
+            },
+            warn: (message) => {
+                diagnostics.warn(formatDiagnosticMessage(message));
+            },
+        };
+    }
+    return {
+        error: (message) => {
+            process.stderr.write(formatDiagnosticMessage(message));
+        },
+        warn: (message) => {
+            process.stderr.write(formatDiagnosticMessage(message));
+        },
+    };
+}
+function noopExitCodeSetter() { }
+function setProcessExitCode(code) {
+    process.exitCode = code;
+}
+function resolveExitCodeSetter(options) {
+    if (options.setExitCode === false) {
+        return noopExitCodeSetter;
+    }
+    return setProcessExitCode;
+}
+export { resolveDiagnostics, resolveExitCodeSetter };