open-multi-agent-kit 0.78.0

package/dist/browser/browser-observer.js

@@ -0,0 +1,159 @@
+import { join } from "path";
+import { writeFile, appendFile, readFile, mkdir } from "fs/promises";
+import { pathExists } from "../util/fs.js";
+import { getBrowserSessionDir } from "./browser-session.js";
+const observedPages = new WeakSet();
+export async function observeBrowserPage(session, projectRoot) {
+    const sessionDir = getBrowserSessionDir(projectRoot, session.sessionId);
+    await mkdir(sessionDir, { recursive: true });
+    const page = session.page;
+    const consolePath = join(sessionDir, "console.jsonl");
+    const networkPath = join(sessionDir, "network.jsonl");
+    if (!observedPages.has(page)) {
+        observedPages.add(page);
+        page.on("console", async (msg) => {
+            try {
+                const { appendFile: append } = await import("fs/promises");
+                const text = typeof msg.text === "function"
+                    ? msg.text()
+                    : String(msg);
+                const type = typeof msg.type === "function"
+                    ? msg.type()
+                    : "log";
+                const line = JSON.stringify({ type, text, time: new Date().toISOString() }) + "\n";
+                await append(consolePath, line, "utf-8");
+                if (type === "error") {
+                    const location = typeof msg.location === "function"
+                        ? msg.location()
+                        : undefined;
+                    import("../hooks/hook-bus.js")
+                        .then(({ emit }) => emit({
+                        type: "browser.console.error",
+                        payload: {
+                            sessionId: session.sessionId,
+                            message: text,
+                            url: location?.url,
+                        },
+                    }))
+                        .catch(() => {
+                        // ignore hook emission failures
+                    });
+                }
+            }
+            catch {
+                // ignore write errors
+            }
+        });
+        page.on("pageerror", async (err) => {
+            try {
+                const { appendFile: append } = await import("fs/promises");
+                const line = JSON.stringify({
+                    type: "pageerror",
+                    text: err instanceof Error ? err.message : String(err),
+                    time: new Date().toISOString(),
+                }) + "\n";
+                await append(consolePath, line, "utf-8");
+            }
+            catch {
+                // ignore write errors
+            }
+        });
+        page.on("requestfailed", async (req) => {
+            try {
+                const { appendFile: append } = await import("fs/promises");
+                const url = typeof req.url === "function"
+                    ? req.url()
+                    : String(req);
+                const line = JSON.stringify({ type: "requestfailed", url, time: new Date().toISOString() }) + "\n";
+                await append(networkPath, line, "utf-8");
+                import("../hooks/hook-bus.js")
+                    .then(({ emit }) => emit({
+                    type: "browser.network.failed",
+                    payload: {
+                        sessionId: session.sessionId,
+                        url,
+                    },
+                }))
+                    .catch(() => {
+                    // ignore hook emission failures
+                });
+            }
+            catch {
+                // ignore write errors
+            }
+        });
+    }
+    const screenshotPath = join(sessionDir, "screenshot.png");
+    const domSnapshotPath = join(sessionDir, "dom.html");
+    const accessibilityPath = join(sessionDir, "accessibility.json");
+    await page.screenshot({ path: screenshotPath, fullPage: true });
+    const domContent = await page.content();
+    await writeFile(domSnapshotPath, domContent, "utf-8");
+    let accessibilityData;
+    try {
+        accessibilityData = await page.accessibility.snapshot();
+        await writeFile(accessibilityPath, JSON.stringify(accessibilityData, null, 2), "utf-8");
+    }
+    catch {
+        // accessibility optional
+    }
+    const title = await page.title();
+    const viewportSize = page.viewportSize() ?? { width: 1280, height: 720 };
+    const viewport = {
+        width: viewportSize.width,
+        height: viewportSize.height,
+        deviceScaleFactor: session.deviceScaleFactor ?? 1,
+    };
+    const capturedAt = new Date().toISOString();
+    const observation = {
+        sessionId: session.sessionId,
+        url: session.url,
+        title,
+        viewport,
+        screenshotPath,
+        domSnapshotPath,
+        consoleEventsPath: consolePath,
+        networkEventsPath: networkPath,
+        ...(accessibilityData !== undefined ? { accessibilityPath } : {}),
+        capturedAt,
+    };
+    const manifestPath = join(sessionDir, "observation.json");
+    await writeFile(manifestPath, JSON.stringify(observation, null, 2) + "\n", "utf-8");
+    import("../hooks/hook-bus.js")
+        .then(({ emit }) => emit({
+        type: "browser.observation.captured",
+        payload: {
+            sessionId: session.sessionId,
+            observationPath: manifestPath,
+            screenshotPath: observation.screenshotPath,
+        },
+    }))
+        .catch(() => {
+        // ignore hook emission failures
+    });
+    return observation;
+}
+export async function writeBrowserFeedback(sessionId, feedbackText, projectRoot) {
+    const sessionDir = getBrowserSessionDir(projectRoot, sessionId);
+    const feedbackPath = join(sessionDir, "feedback.md");
+    const entry = `## Feedback — ${new Date().toISOString()}\n\n${feedbackText}\n\n`;
+    await appendFile(feedbackPath, entry, "utf-8");
+}
+export async function readBrowserObservation(sessionId, projectRoot) {
+    const sessionDir = getBrowserSessionDir(projectRoot, sessionId);
+    const manifestPath = join(sessionDir, "observation.json");
+    if (!(await pathExists(manifestPath)))
+        return undefined;
+    try {
+        const content = await readFile(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function saveBrowserObservation(observation, projectRoot) {
+    const sessionDir = getBrowserSessionDir(projectRoot, observation.sessionId);
+    const manifestPath = join(sessionDir, "observation.json");
+    await writeFile(manifestPath, JSON.stringify(observation, null, 2) + "\n", "utf-8");
+}

package/dist/browser/browser-session.d.ts

@@ -0,0 +1,26 @@
+export interface BrowserSession {
+    sessionId: string;
+    url: string;
+    page: unknown;
+    browser: unknown;
+    createdAt: string;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    deviceScaleFactor?: number;
+}
+export interface CreateSessionOptions {
+    url: string;
+    headless?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    deviceScaleFactor?: number;
+}
+export declare function getActiveBrowserSession(): BrowserSession | undefined;
+export declare function setActiveBrowserSession(session: BrowserSession | undefined): void;
+export declare function getBrowserSessionDir(projectRoot?: string, sessionId?: string): string;
+export declare function createBrowserSession(options: CreateSessionOptions): Promise<BrowserSession>;
+export declare function closeBrowserSession(session?: BrowserSession): Promise<void>;

package/dist/browser/browser-session.js

@@ -0,0 +1,63 @@
+import { join } from "path";
+import { CliError } from "../util/cli-contract.js";
+import { getProjectRoot } from "../util/fs.js";
+let activeSession;
+export function getActiveBrowserSession() {
+    return activeSession;
+}
+export function setActiveBrowserSession(session) {
+    activeSession = session;
+}
+export function getBrowserSessionDir(projectRoot, sessionId) {
+    const root = projectRoot ?? getProjectRoot();
+    if (sessionId) {
+        return join(root, ".omk", "browser", sessionId);
+    }
+    return join(root, ".omk", "browser");
+}
+export async function createBrowserSession(options) {
+    const playwrightModuleName = process.env.NODE_ENV === "test"
+        ? process.env.OMK_PLAYWRIGHT_MODULE ?? "playwright"
+        : "playwright";
+    let playwright;
+    try {
+        playwright = await import(playwrightModuleName);
+    }
+    catch {
+        throw new CliError("Playwright is not installed. Run: npm install -D playwright");
+    }
+    const pw = playwright;
+    const browser = await pw.chromium.launch({
+        headless: options.headless ?? true,
+    });
+    const context = await browser.newContext({
+        viewport: options.viewport ?? { width: 1280, height: 720 },
+        deviceScaleFactor: options.deviceScaleFactor ?? 1,
+    });
+    const page = await context.newPage();
+    await page.goto(options.url, { waitUntil: "networkidle" });
+    const sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const session = {
+        sessionId,
+        url: options.url,
+        page,
+        browser,
+        createdAt: new Date().toISOString(),
+        viewport: options.viewport ?? { width: 1280, height: 720 },
+        deviceScaleFactor: options.deviceScaleFactor ?? 1,
+    };
+    activeSession = session;
+    return session;
+}
+export async function closeBrowserSession(session) {
+    const target = session ?? activeSession;
+    if (!target)
+        return;
+    const browser = target.browser;
+    if (browser && typeof browser.close === "function") {
+        await browser.close();
+    }
+    if (activeSession?.sessionId === target.sessionId) {
+        activeSession = undefined;
+    }
+}

package/dist/cli/command-registry.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerCliCommands(program: Command): void;

package/dist/cli/command-registry.js

@@ -0,0 +1,20 @@
+import { registerBasicCommands } from "./register-basic-commands.js";
+import { registerWorkflowCommands } from "./register-workflow-commands.js";
+import { registerProviderCommands } from "./register-provider-commands.js";
+import { registerOpenAiCodexCommands } from "./register-openai-codex-commands.js";
+import { registerToolCommands } from "./register-tool-commands.js";
+import { registerSpecAgentGoalCommands } from "./register-spec-agent-goal-commands.js";
+import { registerMcpDagCronScreenshotCommands } from "./register-mcp-dag-cron-screenshot-commands.js";
+import { registerIntegrationCommands } from "./register-integration-commands.js";
+import { registerAwarenessCommands } from "./register-awareness-commands.js";
+export function registerCliCommands(program) {
+    registerBasicCommands(program);
+    registerWorkflowCommands(program);
+    registerProviderCommands(program);
+    registerOpenAiCodexCommands(program);
+    registerToolCommands(program);
+    registerSpecAgentGoalCommands(program);
+    registerIntegrationCommands(program);
+    registerAwarenessCommands(program);
+    registerMcpDagCronScreenshotCommands(program);
+}

package/dist/cli/input/argv-parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase 1 — ArgvParser
+ * Parses raw process.argv into a structured format before Commander swallows it.
+ * We still use Commander for subcommand dispatch, but this layer extracts
+ * input-source metadata (stdin hints, file paths, positional args) early.
+ */
+import type { InputSource } from "../runtime/types.js";
+export interface ParsedArgv {
+    readonly raw: readonly string[];
+    readonly command?: string;
+    readonly positionalArgs: readonly string[];
+    readonly flags: Record<string, string | boolean | undefined>;
+    readonly hasStdinPipe: boolean;
+}
+export declare function parseArgv(argv: readonly string[]): ParsedArgv;
+export declare function inferInputSource(parsed: ParsedArgv): InputSource;

package/dist/cli/input/argv-parser.js

@@ -0,0 +1,50 @@
+/**
+ * Phase 1 — ArgvParser
+ * Parses raw process.argv into a structured format before Commander swallows it.
+ * We still use Commander for subcommand dispatch, but this layer extracts
+ * input-source metadata (stdin hints, file paths, positional args) early.
+ */
+export function parseArgv(argv) {
+    const raw = argv.slice(2);
+    const hasStdinPipe = !process.stdin.isTTY;
+    // Detect command (first non-flag token)
+    let command;
+    const positionalArgs = [];
+    const flags = {};
+    let i = 0;
+    while (i < raw.length) {
+        const arg = raw[i];
+        if (arg.startsWith("-")) {
+            const next = raw[i + 1];
+            if (next && !next.startsWith("-")) {
+                flags[arg.replace(/^-+/, "")] = next;
+                i += 2;
+            }
+            else {
+                flags[arg.replace(/^-+/, "")] = true;
+                i += 1;
+            }
+            continue;
+        }
+        if (!command) {
+            command = arg;
+        }
+        else {
+            positionalArgs.push(arg);
+        }
+        i += 1;
+    }
+    return { raw, command, positionalArgs, flags, hasStdinPipe };
+}
+export function inferInputSource(parsed) {
+    // Positional args always win over stdin pipe detection
+    if (parsed.positionalArgs.length > 0)
+        return "argv";
+    if (parsed.hasStdinPipe)
+        return "stdin";
+    if (parsed.flags["goal-file"] || parsed.flags["file"])
+        return "file";
+    if (parsed.flags["interactive"] || parsed.flags["i"])
+        return "interactive";
+    return "argv";
+}

package/dist/cli/input/command-envelope.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase 1 — CommandEnvelope builder
+ * Assembles the canonical envelope from parsed argv, config, and resolved theme.
+ */
+import type { CommandKind, CommandEnvelope } from "../runtime/types.js";
+export interface BuildEnvelopeOptions {
+    readonly argv: readonly string[];
+    readonly defaultCommand?: CommandKind;
+}
+export declare function buildCommandEnvelope(opts: BuildEnvelopeOptions): Promise<{
+    envelope: CommandEnvelope;
+    validation: {
+        valid: boolean;
+        errors: readonly import("../runtime/types.js").NormalizedCliError[];
+    };
+}>;

package/dist/cli/input/command-envelope.js

@@ -0,0 +1,64 @@
+/**
+ * Phase 1 — CommandEnvelope builder
+ * Assembles the canonical envelope from parsed argv, config, and resolved theme.
+ */
+import { parseArgv, inferInputSource } from "./argv-parser.js";
+import { loadProjectConfig, loadUserConfig, resolveConfigValue } from "./config-loader.js";
+import { resolveInput } from "./input-resolver.js";
+import { validateInput } from "./validator.js";
+export async function buildCommandEnvelope(opts) {
+    const parsed = parseArgv(opts.argv);
+    const cwd = process.cwd();
+    const invokedAt = new Date().toISOString();
+    const command = parsed.command ?? opts.defaultCommand ?? "run";
+    const source = inferInputSource(parsed);
+    const projectCfg = loadProjectConfig(cwd);
+    const userCfg = loadUserConfig();
+    const input = await resolveInput({
+        source,
+        positionalArgs: parsed.positionalArgs,
+        flags: parsed.flags,
+        hasStdinPipe: parsed.hasStdinPipe,
+        cwd,
+    });
+    const normalizedInput = {
+        ...input,
+        rawArgs: parsed.raw,
+        metadata: { cwd, invokedAt, isTty: Boolean(process.stdout.isTTY) },
+    };
+    const validation = validateInput(normalizedInput);
+    const outputProfile = {
+        format: resolveConfigValue(parsed.flags["output"], process.env.OMK_OUTPUT, projectCfg?.data.outputFormat, userCfg?.data.outputFormat, "json"),
+        pretty: resolveConfigValue(Boolean(parsed.flags["pretty"]), process.env.OMK_PRETTY === "1", projectCfg?.data.pretty, userCfg?.data.pretty, false),
+        includeMessages: resolveConfigValue(Boolean(parsed.flags["messages"]), process.env.OMK_MESSAGES !== "0", projectCfg?.data.includeMessages, userCfg?.data.includeMessages, true),
+        includeTrace: resolveConfigValue(Boolean(parsed.flags["trace"]), process.env.OMK_TRACE === "1", projectCfg?.data.includeTrace, userCfg?.data.includeTrace, false),
+        stream: resolveConfigValue(Boolean(parsed.flags["stream"]), process.env.OMK_STREAM === "1", projectCfg?.data.stream, userCfg?.data.stream, false),
+        destination: "stdout",
+        outputFile: typeof parsed.flags["out"] === "string" ? parsed.flags["out"] : undefined,
+    };
+    const resolvedTheme = {
+        name: resolveConfigValue(parsed.flags["theme"], process.env.OMK_THEME, projectCfg?.data.theme, userCfg?.data.theme, "omk"),
+        mode: resolveConfigValue(parsed.flags["mode"], process.env.OMK_THEME_MODE, projectCfg?.data.themeMode, userCfg?.data.themeMode, "auto"),
+    };
+    const runtime = {
+        runId: typeof parsed.flags["run-id"] === "string" ? parsed.flags["run-id"] : undefined,
+        workers: typeof parsed.flags["workers"] === "string" ? parsed.flags["workers"] : undefined,
+        provider: typeof parsed.flags["provider"] === "string" ? parsed.flags["provider"] : undefined,
+        sudo: Boolean(parsed.flags["sudo"]),
+    };
+    const config = {
+        cwd,
+        env: process.env,
+        projectConfig: projectCfg?.data,
+        userConfig: userCfg?.data,
+    };
+    const envelope = {
+        kind: command,
+        input: normalizedInput,
+        config,
+        output: outputProfile,
+        theme: resolvedTheme,
+        runtime,
+    };
+    return { envelope, validation };
+}

package/dist/cli/input/config-loader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase 1 — ConfigLoader
+ * Resolves config with priority:
+ *   1. CLI flag
+ *   2. environment variable
+ *   3. project config: .omkrc.json / omk.config.json
+ *   4. user config: ~/.omk/config.json
+ *   5. default
+ */
+export interface LoadedConfig {
+    readonly source: string;
+    readonly data: Record<string, unknown>;
+}
+export declare function loadProjectConfig(cwd: string): LoadedConfig | undefined;
+export declare function loadUserConfig(): LoadedConfig | undefined;
+export declare function resolveConfigValue<T>(flagValue: T | undefined, envValue: T | undefined, projectValue: T | undefined, userValue: T | undefined, defaultValue: T): T;

package/dist/cli/input/config-loader.js

@@ -0,0 +1,48 @@
+/**
+ * Phase 1 — ConfigLoader
+ * Resolves config with priority:
+ *   1. CLI flag
+ *   2. environment variable
+ *   3. project config: .omkrc.json / omk.config.json
+ *   4. user config: ~/.omk/config.json
+ *   5. default
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+const PROJECT_CONFIG_NAMES = [".omkrc.json", "omk.config.json"];
+const USER_CONFIG_PATH = join(homedir(), ".omk", "config.json");
+function loadJsonIfExists(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const text = readFileSync(path, "utf-8");
+        const data = JSON.parse(text);
+        return { source: path, data };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function loadProjectConfig(cwd) {
+    for (const name of PROJECT_CONFIG_NAMES) {
+        const cfg = loadJsonIfExists(resolve(cwd, name));
+        if (cfg)
+            return cfg;
+    }
+    return undefined;
+}
+export function loadUserConfig() {
+    return loadJsonIfExists(USER_CONFIG_PATH);
+}
+export function resolveConfigValue(flagValue, envValue, projectValue, userValue, defaultValue) {
+    if (flagValue !== undefined)
+        return flagValue;
+    if (envValue !== undefined)
+        return envValue;
+    if (projectValue !== undefined)
+        return projectValue;
+    if (userValue !== undefined)
+        return userValue;
+    return defaultValue;
+}

package/dist/cli/input/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Phase 1 — CLI Input pipeline barrel export
+ */
+export * from "./argv-parser.js";
+export * from "./config-loader.js";
+export * from "./input-resolver.js";
+export * from "./validator.js";
+export * from "./command-envelope.js";

package/dist/cli/input/index.js

@@ -0,0 +1,8 @@
+/**
+ * Phase 1 — CLI Input pipeline barrel export
+ */
+export * from "./argv-parser.js";
+export * from "./config-loader.js";
+export * from "./input-resolver.js";
+export * from "./validator.js";
+export * from "./command-envelope.js";

package/dist/cli/input/input-resolver.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Phase 1 — InputResolver
+ * Resolves the actual goal/content from argv, stdin, or file.
+ */
+import type { NormalizedInput, InputSource } from "../runtime/types.js";
+export interface ResolveInputOptions {
+    readonly source: InputSource;
+    readonly positionalArgs: readonly string[];
+    readonly flags: Record<string, string | boolean | undefined>;
+    readonly hasStdinPipe: boolean;
+    readonly cwd: string;
+}
+export declare function resolveInput(opts: ResolveInputOptions): Promise<Pick<NormalizedInput, "source" | "goal" | "goalFile" | "teamFile" | "taskFile" | "orchestratorFile" | "coordinatorFile">>;

package/dist/cli/input/input-resolver.js

@@ -0,0 +1,50 @@
+/**
+ * Phase 1 — InputResolver
+ * Resolves the actual goal/content from argv, stdin, or file.
+ */
+import { readFileSync } from "node:fs";
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        process.stdin.on("error", reject);
+    });
+}
+export async function resolveInput(opts) {
+    let goal;
+    let goalFile;
+    const teamFile = typeof opts.flags["team"] === "string" ? opts.flags["team"] : undefined;
+    const taskFile = typeof opts.flags["file"] === "string" ? opts.flags["file"] : undefined;
+    const orchestratorFile = typeof opts.flags["orchestrator"] === "string" ? opts.flags["orchestrator"] : undefined;
+    const coordinatorFile = typeof opts.flags["coordinator"] === "string" ? opts.flags["coordinator"] : undefined;
+    if (opts.source === "stdin" && opts.hasStdinPipe) {
+        goal = await readStdin();
+    }
+    else if (opts.source === "file") {
+        const path = typeof opts.flags["goal-file"] === "string" ? opts.flags["goal-file"] : undefined;
+        if (path) {
+            goalFile = path;
+            goal = readFileSync(path, "utf-8");
+        }
+    }
+    else {
+        // argv positional goal
+        if (opts.positionalArgs.length > 0) {
+            goal = opts.positionalArgs.join(" ");
+        }
+        // fallback to --goal flag
+        if (!goal && typeof opts.flags["goal"] === "string") {
+            goal = opts.flags["goal"];
+        }
+    }
+    return {
+        source: opts.source,
+        goal: goal?.trim() || undefined,
+        goalFile,
+        teamFile,
+        taskFile,
+        orchestratorFile,
+        coordinatorFile,
+    };
+}

package/dist/cli/input/validator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Phase 1 — Validator
+ * Lightweight validation for resolved input before building CommandEnvelope.
+ */
+import type { NormalizedInput, NormalizedCliError } from "../runtime/types.js";
+export interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly NormalizedCliError[];
+}
+export declare function validateInput(input: NormalizedInput): ValidationResult;

package/dist/cli/input/validator.js

@@ -0,0 +1,37 @@
+/**
+ * Phase 1 — Validator
+ * Lightweight validation for resolved input before building CommandEnvelope.
+ */
+import { existsSync } from "node:fs";
+export function validateInput(input) {
+    const errors = [];
+    if (!input.goal && !input.taskFile) {
+        errors.push({
+            kind: "validation",
+            message: "A goal or task file is required.",
+            hint: "Provide a positional goal, --goal, --goal-file, or pipe via stdin. For fixed tasks use --file.",
+        });
+    }
+    if (input.teamFile && !existsSync(input.teamFile)) {
+        errors.push({
+            kind: "validation",
+            message: `Team file not found: ${input.teamFile}`,
+            hint: "Check the path or generate one with `omk init`.",
+        });
+    }
+    if (input.taskFile && !existsSync(input.taskFile)) {
+        errors.push({
+            kind: "validation",
+            message: `Task file not found: ${input.taskFile}`,
+            hint: "Check the path or use `omk task --generate` to scaffold one.",
+        });
+    }
+    if (input.goalFile && !existsSync(input.goalFile)) {
+        errors.push({
+            kind: "validation",
+            message: `Goal file not found: ${input.goalFile}`,
+            hint: "Check the path.",
+        });
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function createOmkProgram(): Command;
+export declare function runCli(argv?: readonly string[]): Promise<void>;
+export declare function handleCliError(err: unknown): void;

package/dist/cli/main.js

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import { CliError } from "../util/cli-contract.js";
+import { formatOmkVersionFooter, getOmkVersionSync } from "../util/version.js";
+import { configureRootProgram } from "./root.js";
+import { registerCliCommands } from "./command-registry.js";
+export function createOmkProgram() {
+    const omkVersion = getOmkVersionSync();
+    const program = new Command();
+    configureRootProgram(program, omkVersion, formatOmkVersionFooter(omkVersion));
+    registerCliCommands(program);
+    return program;
+}
+export async function runCli(argv = process.argv) {
+    const program = createOmkProgram();
+    try {
+        await program.parseAsync([...argv]);
+    }
+    catch (err) {
+        handleCliError(err);
+    }
+}
+export function handleCliError(err) {
+    if (err instanceof Error && err.name === "ExitPromptError") {
+        process.exit(0);
+    }
+    if (err instanceof CliError) {
+        if (process.exitCode === undefined) {
+            process.exitCode = err.exitCode;
+        }
+        return;
+    }
+    console.error("Unexpected error:", err);
+    process.exit(1);
+}