@ogment-ai/cli 0.4.2 → 0.5.0

package/dist/cli.js

@@ -1,741 +1,6 @@
 #!/usr/bin/env node
-import { realpathSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Command, CommanderError } from "commander";
-import { runAuthLoginCommand, runAuthLogoutCommand, runAuthStatusCommand, } from "./commands/auth.js";
-import { runCatalogCommand, runCatalogToolDetailsCommand, runCatalogToolsCommand, } from "./commands/catalog.js";
-import { runInvokeCommand } from "./commands/invoke.js";
-import { runStatusCommand } from "./commands/status.js";
-import { createBrowserOpener } from "./infra/browser.js";
-import { createFileCredentialsStore } from "./infra/credentials.js";
-import { createRuntimeConfig } from "./infra/env.js";
-import { createHttpClient } from "./infra/http.js";
-import { OutputManager } from "./output/manager.js";
-import { createAccountService } from "./services/account.js";
-import { createAuthService } from "./services/auth.js";
-import { createInfoService } from "./services/info.js";
-import { createMcpService } from "./services/mcp.js";
-import { buildJsonSchemaExample, EXAMPLE_PLACEHOLDER } from "./shared/schema-example.js";
-import { ERROR_CODE } from "./shared/error-codes.js";
-import { AuthError, ContractMismatchError, NotFoundError, RemoteRequestError, UnexpectedError, ValidationError, } from "./shared/errors.js";
-import { EXIT_CODE, exitCodeForError } from "./shared/exit-codes.js";
-import { APP_DESCRIPTION, APP_NAME, VERSION } from "./shared/constants.js";
-class CliExitError extends Error {
-    exitCode;
-    constructor(exitCode) {
-        super("CLI exit");
-        this.exitCode = exitCode;
-    }
-}
-const createRuntime = () => {
-    const runtimeConfig = createRuntimeConfig();
-    const output = new OutputManager();
-    const credentialsStore = createFileCredentialsStore({
-        configDir: runtimeConfig.configDir,
-        credentialsPath: runtimeConfig.credentialsPath,
-    });
-    const httpClient = createHttpClient();
-    const browserOpener = createBrowserOpener();
-    const services = {
-        account: createAccountService({
-            baseUrl: runtimeConfig.baseUrl,
-            httpClient,
-        }),
-        auth: createAuthService({
-            baseUrl: runtimeConfig.baseUrl,
-            browserOpener,
-            credentialsStore,
-            envApiKey: runtimeConfig.envApiKey,
-            httpClient,
-        }),
-        mcp: createMcpService({
-            baseUrl: runtimeConfig.baseUrl,
-            version: runtimeConfig.version,
-        }),
-    };
-    const infoService = createInfoService({
-        accountService: services.account,
-        baseUrl: runtimeConfig.baseUrl,
-        baseUrlSource: runtimeConfig.baseUrlSource,
-        configDir: runtimeConfig.configDir,
-        credentialsPath: runtimeConfig.credentialsPath,
-        credentialsStore,
-        envApiKey: runtimeConfig.envApiKey,
-        httpClient,
-        version: runtimeConfig.version,
-    });
-    return {
-        context: {
-            apiKeyOverride: undefined,
-            output,
-            services,
-        },
-        infoService,
-        output,
-    };
-};
-const asGlobalOptions = (command) => {
-    const options = command.optsWithGlobals();
-    return {
-        apiKey: options.apiKey,
-        human: options.human,
-        nonInteractive: options.nonInteractive,
-        quiet: options.quiet,
-        yes: options.yes,
-    };
-};
-const mapGlobalOutputOptions = (options) => {
-    return {
-        human: options.human,
-        nonInteractive: options.nonInteractive,
-        quiet: options.quiet,
-        yes: options.yes,
-    };
-};
-const throwCommandError = (error) => {
-    throw new CliExitError(exitCodeForError(error));
-};
-const nextAction = (id, title, command, reason, when = null) => {
-    return {
-        command,
-        id,
-        reason,
-        title,
-        when,
-    };
-};
-const hasPlaceholderTokens = (command) => {
-    return command.includes("<") || command.includes(">");
-};
-const nextActionsForError = (error) => {
-    const fallbackByCode = {
-        [ERROR_CODE.authDeviceExpired]: {
-            command: "ogment auth login",
-            reason: "Device code expired; restart login to continue.",
-            title: "Restart login",
-        },
-        [ERROR_CODE.authDevicePending]: {
-            command: "ogment auth status",
-            reason: "Authorization is pending; check whether credentials are now available.",
-            title: "Check auth status",
-        },
-        [ERROR_CODE.authInvalidCredentials]: {
-            command: "ogment auth logout",
-            reason: "Credentials are invalid; clear local state before re-authenticating.",
-            title: "Reset auth state",
-        },
-        [ERROR_CODE.authRequired]: {
-            command: "ogment auth login",
-            reason: "Authentication is required before catalog or invoke commands can run.",
-            title: "Authenticate",
-        },
-        [ERROR_CODE.remoteRateLimited]: {
-            command: "ogment status",
-            reason: "Remote rate limit detected; check diagnostics before retrying.",
-            title: "Inspect diagnostics",
-        },
-        [ERROR_CODE.remoteUnavailable]: {
-            command: "ogment status",
-            reason: "Remote service is unavailable; check connectivity and endpoint health.",
-            title: "Inspect diagnostics",
-        },
-        [ERROR_CODE.toolInputSchemaViolation]: {
-            command: "ogment catalog",
-            reason: "Tool contract did not validate; inspect available servers and tool metadata.",
-            title: "Inspect catalog",
-        },
-        [ERROR_CODE.toolNotFound]: {
-            command: "ogment catalog",
-            reason: "Requested tool could not be found; rediscover servers and tools.",
-            title: "Rediscover tools",
-        },
-        [ERROR_CODE.transportRequestFailed]: {
-            command: "ogment status",
-            reason: "Transport request failed; inspect connectivity diagnostics.",
-            title: "Inspect diagnostics",
-        },
-        [ERROR_CODE.contractVersionUnsupported]: {
-            command: "ogment --version",
-            reason: "Contract mismatch detected; verify CLI version and upgrade before retrying.",
-            title: "Inspect CLI version",
-        },
-        [ERROR_CODE.internalUnexpected]: {
-            command: "ogment status",
-            reason: "Unexpected failure detected; run diagnostics before retrying the workflow.",
-            title: "Inspect diagnostics",
-        },
-        [ERROR_CODE.validationInvalidInput]: {
-            command: "ogment --help",
-            reason: "Input validation failed; inspect canonical command syntax.",
-            title: "Show command help",
-        },
-    };
-    const fallback = fallbackByCode[error.code];
-    const suggestedCommand = typeof error.suggestedCommand === "string" && !hasPlaceholderTokens(error.suggestedCommand)
-        ? error.suggestedCommand
-        : undefined;
-    const command = suggestedCommand ?? fallback?.command;
-    if (command === undefined) {
-        return [];
-    }
-    return [
-        nextAction(`recover_${error.code.toLowerCase()}`, fallback?.title ?? "Run suggested command", command, fallback?.reason ?? `Suggested recovery for error ${error.code}.`, "immediate"),
-    ];
-};
-const ensureSuccess = (result, output, context) => {
-    if (result.status === "error") {
-        output.error(result.error, {
-            command: context.command,
-            entity: context.entity ?? null,
-            nextActions: nextActionsForError(result.error),
-        });
-        throwCommandError(result.error);
-    }
-    return result.value;
-};
-const nextActionsForLogin = (payload, mode) => {
-    return [
-        nextAction("check_auth_status", "Check auth status", "ogment auth status", `Verify persisted credentials after ${mode} login for ${payload.agentName}.`, "immediate"),
-        nextAction("discover_servers", "Discover servers", "ogment catalog", `Logged in as ${payload.agentName} via ${mode}; discover available servers.`, "after_auth"),
-    ];
-};
-const nextActionsForAuthStatus = (payload) => {
-    if (!payload.loggedIn) {
-        return [
-            nextAction("login", "Authenticate", "ogment auth login", "No API key is configured locally; login is required.", "immediate"),
-        ];
-    }
-    return [
-        nextAction("discover_servers", "Discover servers", "ogment catalog", `Authenticated via ${payload.apiKeySource}; discover servers next.`, "after_auth"),
-    ];
-};
-const nextActionsForCatalogSummary = (payload, context) => {
-    const actions = [];
-    const targetServer = payload.servers.find((server) => server.toolCount > 0);
-    if (targetServer !== undefined) {
-        actions.push(nextAction("inspect_tools", "Inspect tools", `ogment catalog ${targetServer.serverId}`, `${targetServer.serverId} has ${targetServer.toolCount} available tools.`, "if_tool_count_gt_0"));
-    }
-    if (context.nextCursor !== null) {
-        const limitFlag = context.limit === null ? "" : ` --limit ${context.limit}`;
-        actions.push(nextAction("next_catalog_page", "Load next page", `ogment catalog --cursor ${context.nextCursor}${limitFlag}`, `More servers are available after cursor ${context.nextCursor}.`, "if_more_servers"));
-    }
-    return actions;
-};
-const nextActionsForCatalogTools = (payload) => {
-    const firstTool = payload.tools[0];
-    if (firstTool === undefined) {
-        return [];
-    }
-    return [
-        nextAction("inspect_tool", "Inspect tool details", `ogment catalog ${payload.server.serverId} ${firstTool.name}`, `Inspect schema for ${payload.server.serverId}/${firstTool.name} before invoking.`, "if_tools_available"),
-    ];
-};
-const toInlineJsonTemplateArgument = (value) => {
-    const placeholderLiteral = JSON.stringify(EXAMPLE_PLACEHOLDER);
-    const serialized = JSON.stringify(value).replaceAll(placeholderLiteral, " ... ");
-    const escaped = serialized.replaceAll("'", String.raw `'\''`);
-    return `'${escaped}'`;
-};
-const nextActionsForCatalogToolDetails = (payload, exampleInput) => {
-    const inputArgument = toInlineJsonTemplateArgument(exampleInput);
-    return [
-        nextAction("invoke_tool", "Invoke this tool", `ogment invoke ${payload.server.serverId}/${payload.name} --input ${inputArgument}`, `Replace every ... placeholder with real JSON values, then invoke ${payload.server.serverId}/${payload.name}.`, "after_tool_inspection"),
-    ];
-};
-const nextActionsForInvoke = (payload) => {
-    return [
-        nextAction("inspect_tool", "Inspect tool schema", `ogment catalog ${payload.serverId} ${payload.toolName}`, `Review ${payload.serverId}/${payload.toolName} schema for the next invocation.`, "after_invoke"),
-    ];
-};
-const nextActionsForStatus = (payload) => {
-    if (!payload.auth.apiKeyPresent) {
-        return [
-            nextAction("login", "Authenticate", "ogment auth login", "Status detected no API key; authenticate first.", "immediate"),
-        ];
-    }
-    return [
-        nextAction("discover_servers", "Discover servers", "ogment catalog", `Connectivity is ${payload.summary.status}; discover available servers.`, "after_status"),
-    ];
-};
-const createProgram = (runtime) => {
-    const program = new Command();
-    program.exitOverride();
-    program.configureOutput({
-        writeErr: () => undefined,
-    });
-    program
-        .name(APP_NAME)
-        .description(APP_DESCRIPTION)
-        .version(VERSION)
-        .option("--api-key <key>", "API key override")
-        .option("--human", "Render output for humans")
-        .option("--quiet", "Suppress non-essential output")
-        .option("--non-interactive", "Disable interactive behavior")
-        .option("--yes", "Assume yes for any confirmation")
-        .hook("preAction", (thisCommand) => {
-        const options = asGlobalOptions(thisCommand);
-        runtime.output.configure(mapGlobalOutputOptions(options));
-        runtime.context.apiKeyOverride = options.apiKey;
-    });
-    const authCommand = program.command("auth").description("Authentication workflows");
-    const runLoginFlow = async (mode, apiKey) => {
-        const loginInvocation = (() => {
-            if (mode === "api_key") {
-                return {
-                    commandOptions: {
-                        apiKey: apiKey ?? "",
-                        mode: "apiKey",
-                    },
-                    invokedCommand: "ogment auth login --api-key <redacted>",
-                };
-            }
-            if (mode === "browser") {
-                return {
-                    commandOptions: {
-                        mode: "browser",
-                    },
-                    invokedCommand: "ogment auth login --browser",
-                };
-            }
-            const deviceCommand = "ogment auth login";
-            return {
-                commandOptions: {
-                    mode: "device",
-                    onPending: ({ userCode, verificationUri }) => {
-                        const pendingNextActions = [
-                            nextAction("check_login_status", "Check login status", "ogment auth status", `Approve ${userCode} at ${verificationUri}, then verify local auth state.`, "immediate"),
-                            nextAction("restart_device_login", "Restart login", "ogment auth login", `Restart login if code ${userCode} expires before approval.`, "if_expired"),
-                        ];
-                        runtime.output.success({
-                            state: "pending",
-                            userCode,
-                            verificationUri,
-                        }, {
-                            command: deviceCommand,
-                            entity: {
-                                mode,
-                                state: "pending",
-                                userCode,
-                                verificationUri,
-                            },
-                            humanMessage: `Open ${verificationUri} and enter code ${userCode}`,
-                            nextActions: pendingNextActions,
-                        });
-                    },
-                },
-                invokedCommand: deviceCommand,
-            };
-        })();
-        const { commandOptions, invokedCommand } = loginInvocation;
-        const result = await runAuthLoginCommand(runtime.context, commandOptions);
-        const data = ensureSuccess(result, runtime.output, {
-            command: invokedCommand,
-            entity: {
-                mode,
-            },
-        });
-        let humanMessage = `Logged in as ${data.agentName}.`;
-        if (data.alreadyLoggedIn) {
-            humanMessage = `Already logged in as ${data.agentName}.`;
-        }
-        else if (mode === "api_key") {
-            humanMessage = `Imported API key for ${data.agentName}.`;
-        }
-        runtime.output.success(data, {
-            command: invokedCommand,
-            entity: {
-                agentName: data.agentName,
-                alreadyLoggedIn: data.alreadyLoggedIn,
-                mode,
-            },
-            humanMessage,
-            nextActions: nextActionsForLogin(data, mode),
-        });
-    };
-    const loginWorkflowCommand = authCommand
-        .command("login")
-        .description("Authenticate with Ogment using device flow (recommended)")
-        .option("--browser", "Fallback: use browser callback flow");
-    loginWorkflowCommand.action(async (options, command) => {
-        const { apiKey } = asGlobalOptions(command);
-        if (options.browser === true && apiKey !== undefined) {
-            throw new ValidationError({
-                details: "--browser with --api-key",
-                message: "Use only one login mode: default device, --browser, or --api-key.",
-                suggestedCommand: "ogment auth login",
-            });
-        }
-        if (apiKey !== undefined) {
-            await runLoginFlow("api_key", apiKey);
-            return;
-        }
-        if (options.browser === true) {
-            await runLoginFlow("browser");
-            return;
-        }
-        await runLoginFlow("device");
-    });
-    authCommand
-        .command("status")
-        .description("Show local authentication status")
-        .action(async () => {
-        const command = "ogment auth status";
-        const result = await runAuthStatusCommand(runtime.context);
-        const data = ensureSuccess(result, runtime.output, {
-            command,
-        });
-        runtime.output.success(data, {
-            command,
-            entity: {
-                apiKeySource: data.apiKeySource,
-                loggedIn: data.loggedIn,
-            },
-            humanMessage: data.loggedIn
-                ? `Authenticated (${data.apiKeySource}).`
-                : "Not authenticated.",
-            nextActions: nextActionsForAuthStatus(data),
-        });
-    });
-    authCommand
-        .command("logout")
-        .description("Revoke token and delete local credentials")
-        .action(async () => {
-        const command = "ogment auth logout";
-        const result = await runAuthLogoutCommand(runtime.context);
-        const data = ensureSuccess(result, runtime.output, {
-            command,
-        });
-        let message = "Not logged in.";
-        if (data.localCredentialsDeleted) {
-            message = data.revoked
-                ? "Logged out and revoked API key."
-                : "Logged out locally. Server revocation not confirmed.";
-        }
-        runtime.output.success(data, {
-            command,
-            entity: {
-                localCredentialsDeleted: data.localCredentialsDeleted,
-                revoked: data.revoked,
-            },
-            humanMessage: message,
-            nextActions: [
-                nextAction("login", "Authenticate again", "ogment auth login", "Logout completed; authenticate again before further tool calls.", "after_logout"),
-            ],
-        });
-    });
-    const catalogCommand = program
-        .command("catalog [serverId] [toolName]")
-        .description("Discover servers and tools with progressive disclosure")
-        .option("--cursor <cursor>", "Pagination cursor (catalog summary only)")
-        .option("--limit <limit>", "Maximum servers to return (catalog summary only)")
-        .option("--example", "Include a generated example input payload (tool details only)");
-    catalogCommand.action(async (serverId, toolName, options) => {
-        const parsedLimit = typeof options.limit === "string" ? Number.parseInt(options.limit, 10) : undefined;
-        if (options.limit !== undefined && (parsedLimit === undefined || Number.isNaN(parsedLimit))) {
-            throw new ValidationError({
-                details: options.limit,
-                message: "Invalid --limit value. Expected an integer.",
-                suggestedCommand: "ogment catalog --limit 20",
-            });
-        }
-        if (parsedLimit !== undefined && parsedLimit < 1) {
-            throw new ValidationError({
-                details: options.limit ?? String(parsedLimit),
-                message: "Invalid --limit value. Expected a positive integer.",
-                suggestedCommand: "ogment catalog --limit 20",
-            });
-        }
-        if (serverId === undefined) {
-            if (options.example === true) {
-                throw new ValidationError({
-                    details: "--example without <server-id> <tool-name>",
-                    message: "Invalid catalog options. --example requires <server-id> <tool-name>.",
-                    suggestedCommand: "ogment catalog",
-                });
-            }
-            const command = [
-                "ogment catalog",
-                ...(options.cursor === undefined ? [] : [`--cursor ${options.cursor}`]),
-                ...(parsedLimit === undefined || Number.isNaN(parsedLimit)
-                    ? []
-                    : [`--limit ${parsedLimit}`]),
-            ].join(" ");
-            const result = await runCatalogCommand(runtime.context, {
-                cursor: options.cursor,
-                limit: parsedLimit,
-            });
-            const data = ensureSuccess(result, runtime.output, {
-                command,
-                entity: {
-                    cursor: options.cursor ?? null,
-                    limit: parsedLimit ?? null,
-                },
-            });
-            const outputData = {
-                servers: data.servers,
-            };
-            runtime.output.success(outputData, {
-                command,
-                entity: {
-                    cursor: options.cursor ?? null,
-                    limit: parsedLimit ?? null,
-                    serverCount: data.servers.length,
-                },
-                humanMessage: data.nextCursor === null
-                    ? `${data.servers.length} server(s) available.`
-                    : `${data.servers.length} server(s) shown. More available with --cursor ${data.nextCursor}.`,
-                nextActions: nextActionsForCatalogSummary(outputData, {
-                    limit: parsedLimit ?? null,
-                    nextCursor: data.nextCursor,
-                }),
-                pagination: {
-                    nextCursor: data.nextCursor,
-                },
-            });
-            return;
-        }
-        if (toolName === undefined) {
-            if (options.cursor !== undefined || parsedLimit !== undefined) {
-                throw new ValidationError({
-                    details: `${options.cursor === undefined ? "" : `--cursor ${options.cursor} `}${parsedLimit === undefined ? "" : `--limit ${parsedLimit}`}`.trim(),
-                    message: "Invalid catalog options. --cursor and --limit are only valid for `ogment catalog`.",
-                    suggestedCommand: "ogment catalog",
-                });
-            }
-            if (options.example === true) {
-                throw new ValidationError({
-                    details: `--example without tool name for ${serverId}`,
-                    message: "Invalid catalog options. --example requires <tool-name>.",
-                    suggestedCommand: `ogment catalog ${serverId}`,
-                });
-            }
-            const command = `ogment catalog ${serverId}`;
-            const result = await runCatalogToolsCommand(runtime.context, { serverId });
-            const data = ensureSuccess(result, runtime.output, {
-                command,
-                entity: {
-                    serverId,
-                },
-            });
-            runtime.output.success(data, {
-                command,
-                entity: {
-                    serverId: data.server.serverId,
-                    toolCount: data.tools.length,
-                },
-                humanMessage: `${data.tools.length} tool(s) available on ${data.server.serverId}.`,
-                nextActions: nextActionsForCatalogTools(data),
-            });
-            return;
-        }
-        if (options.cursor !== undefined || parsedLimit !== undefined) {
-            throw new ValidationError({
-                details: `${options.cursor === undefined ? "" : `--cursor ${options.cursor} `}${parsedLimit === undefined ? "" : `--limit ${parsedLimit}`}`.trim(),
-                message: "Invalid catalog options. --cursor and --limit are only valid for `ogment catalog`.",
-                suggestedCommand: `ogment catalog ${serverId} ${toolName}${options.example === true ? " --example" : ""}`,
-            });
-        }
-        const command = [
-            "ogment catalog",
-            serverId,
-            toolName,
-            ...(options.example === true ? ["--example"] : []),
-        ].join(" ");
-        const result = await runCatalogToolDetailsCommand(runtime.context, { serverId, toolName });
-        const data = ensureSuccess(result, runtime.output, {
-            command,
-            entity: {
-                serverId,
-                toolName,
-            },
-        });
-        const exampleInput = buildJsonSchemaExample(data.inputSchema);
-        const outputData = options.example === true ? { ...data, exampleInput } : data;
-        runtime.output.success(outputData, {
-            command,
-            entity: {
-                serverId: data.server.serverId,
-                toolName: data.name,
-            },
-            humanMessage: `Loaded schema for ${data.server.serverId}/${data.name}.`,
-            nextActions: nextActionsForCatalogToolDetails(data, exampleInput),
-        });
-    });
-    program
-        .command("invoke <target>")
-        .description("Invoke a tool using <server-id>/<tool-name>")
-        .option("--input <value>", "Input payload: inline JSON object, @path, or - for stdin")
-        .action(async (target, options) => {
-        let inputSource = "none";
-        let command = `ogment invoke ${target}`;
-        if (options.input !== undefined) {
-            if (options.input === "-") {
-                inputSource = "stdin";
-                command = `ogment invoke ${target} --input -`;
-            }
-            else if (options.input.startsWith("@")) {
-                inputSource = "file";
-                command = `ogment invoke ${target} --input ${options.input}`;
-            }
-            else {
-                inputSource = "inline_json";
-                command = `ogment invoke ${target} --input <json>`;
-            }
-        }
-        const result = await runInvokeCommand(runtime.context, {
-            input: options.input,
-            target,
-        });
-        const data = ensureSuccess(result, runtime.output, {
-            command,
-            entity: {
-                inputSource,
-                target,
-            },
-        });
-        runtime.output.success(data, {
-            command,
-            entity: {
-                inputSource,
-                serverId: data.serverId,
-                toolName: data.toolName,
-            },
-            humanMessage: `Invoked ${data.serverId}/${data.toolName}.`,
-            nextActions: nextActionsForInvoke(data),
-        });
-    });
-    program
-        .command("status")
-        .description("Show runtime configuration and connectivity diagnostics")
-        .action(async () => {
-        const command = "ogment status";
-        if (runtime.infoService === undefined) {
-            throw new UnexpectedError({
-                message: "Info service is not configured",
-            });
-        }
-        const result = await runStatusCommand({
-            apiKeyOverride: runtime.context.apiKeyOverride,
-        }, {
-            infoService: runtime.infoService,
-        });
-        const data = ensureSuccess(result, runtime.output, {
-            command,
-        });
-        runtime.output.success(data, {
-            command,
-            entity: {
-                summaryStatus: data.summary.status,
-            },
-            humanMessage: `Diagnostics status: ${data.summary.status.toUpperCase()}`,
-            nextActions: nextActionsForStatus(data),
-        });
-    });
-    program.action(() => {
-        runtime.output.success({
-            commands: [
-                "auth login",
-                "auth status",
-                "auth logout",
-                "catalog",
-                "catalog <server-id>",
-                "catalog <server-id> <tool-name>",
-                "invoke <server-id>/<tool-name>",
-                "status",
-            ],
-        }, {
-            command: "ogment",
-            entity: null,
-            humanMessage: "Select a command to continue.",
-            nextActions: [
-                nextAction("login", "Authenticate", "ogment auth login", "Authenticate first so catalog and invoke commands can run.", "immediate"),
-                nextAction("catalog", "Discover servers", "ogment catalog", "List accessible servers and tool counts.", "after_auth"),
-            ],
-        });
-    });
-    return program;
-};
-const normalizeCommanderError = (error) => {
-    if (error instanceof AuthError ||
-        error instanceof ContractMismatchError ||
-        error instanceof NotFoundError ||
-        error instanceof RemoteRequestError ||
-        error instanceof UnexpectedError ||
-        error instanceof ValidationError) {
-        return error;
-    }
-    if (error instanceof CommanderError) {
-        return new ValidationError({
-            details: error.message,
-            message: "Invalid CLI usage",
-        });
-    }
-    if (error instanceof Error) {
-        return new UnexpectedError({
-            cause: error,
-            message: error.message,
-        });
-    }
-    return new UnexpectedError({
-        cause: error,
-        message: "Unexpected CLI failure",
-    });
-};
-const normalizeCliArgv = (argv) => {
-    if (argv[0] === "--") {
-        return argv.slice(1);
-    }
-    return argv;
-};
-const commandFromArgv = (argv) => {
-    const normalized = normalizeCliArgv(argv);
-    if (normalized.length === 0) {
-        return "ogment";
-    }
-    return `ogment ${normalized.join(" ")}`;
-};
-export const runCli = async (argv = process.argv.slice(2), runtime = createRuntime()) => {
-    const program = createProgram(runtime);
-    try {
-        await program.parseAsync(normalizeCliArgv(argv), { from: "user" });
-        return EXIT_CODE.success;
-    }
-    catch (error) {
-        if (error instanceof CliExitError) {
-            return error.exitCode;
-        }
-        if (error instanceof CommanderError && error.exitCode === EXIT_CODE.success) {
-            return EXIT_CODE.success;
-        }
-        const normalized = normalizeCommanderError(error);
-        runtime.output.error(normalized, {
-            command: commandFromArgv(argv),
-            entity: null,
-            nextActions: nextActionsForError(normalized),
-        });
-        return exitCodeForError(normalized);
-    }
-};
-export const executeCli = async () => {
-    const code = await runCli();
-    process.exitCode = code;
-};
-const toCanonicalFileHref = (path) => {
-    return pathToFileURL(realpathSync(path)).href;
-};
-export const shouldExecuteCli = (importMetaUrl, argv1) => {
-    if (argv1 === undefined) {
-        return false;
-    }
-    try {
-        const invokedFileHref = toCanonicalFileHref(argv1);
-        const moduleFileHref = toCanonicalFileHref(fileURLToPath(importMetaUrl));
-        return invokedFileHref === moduleFileHref;
-    }
-    catch {
-        return false;
-    }
-};
+import { executeCli, runCli, shouldExecuteCli } from "./cli/run.js";
+export { executeCli, runCli, shouldExecuteCli };
 if (shouldExecuteCli(import.meta.url, process.argv[1])) {
     await executeCli();
 }