@openruntime/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1579 @@
+#!/usr/bin/env node
+import { once } from "node:events";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createBridgeServer } from "@openruntime/bridge";
+import { createPackageInfo, OPEN_RUNTIME_BRIDGE_DEFAULT_PORT, OPEN_RUNTIME_SESSION_QUERY_PARAM } from "@openruntime/core";
+import { getNumberOption, getOptionValue, getOptionValues, parseCliArgs } from "./args.js";
+import { exportAuthProfileWithConnector } from "./auth-connector.js";
+import { createConsoleLogScript, createGetWindowScript, createInteractiveTextClickScript, createNextBrowserRunner, createWaitEvalScript, parseBrowserJsonOutput } from "./browser.js";
+import { canAutoStartBridge, createFileBridgeStateStore, createDetachedBridgeStarter, ensureBridge, stopManagedBridge, waitForSelectedRuntime } from "./bridge-process.js";
+import { fetchInputOptions, fetchRuntimeResource, fetchRuntimes, normalizeBridgeUrl, runRuntimeAction, selectRuntime, waitForRuntime } from "./client.js";
+import { isEntryPoint } from "./entry.js";
+import { cliCommandReferences, createHelpText } from "./help.js";
+import { validateCommandSkill } from "./command-skill.js";
+import { createFileOperationLogStore, createOperationSessionId, normalizeOpenRuntimeUrlForMatch } from "./operation-log.js";
+import { clearProfile, getProfileDirectory, importProfile, listProfile, readProfileInput, readProfileInputFile } from "./profile.js";
+import { createInternalExtensionRecords, loadExternalCliExtensions } from "./external-extensions.js";
+import { createOpenRuntimeExtensionApi } from "./extension-api.js";
+import { createError, createCommandOutput, writeErrorOutput } from "./output.js";
+import { runRecordCommand } from "./record.js";
+export const cliPackageInfo = createPackageInfo("@openruntime/cli", "agent command line");
+const PROFILE_INLINE_OUTPUT_MAX_CHARS = 32_768;
+const BROWSER_COMMAND_NAMES = [
+    "open",
+    "goto",
+    "page-snapshot",
+    "click",
+    "fill",
+    "eval",
+    "wait-eval",
+    "get-window",
+    "screenshot",
+    "network",
+    "console",
+    "close"
+];
+const RUNTIME_RESOURCE_COMMAND_NAMES = [
+    "targets",
+    "snapshot",
+    "events",
+    "actions"
+];
+export function getCliCommandName() {
+    return "openruntime";
+}
+export function createOpenRuntimeCli(options = {}) {
+    const extensions = options.extensions ?? [];
+    const extensionRegistry = createExtensionRegistry(extensions);
+    const commandReferences = [
+        ...cliCommandReferences,
+        ...extensions.flatMap((extension) => extension.commandReferences ?? [])
+    ];
+    const commandSkillReferences = extensions.flatMap(createCommandSkillReferences);
+    const config = {
+        commandReferences,
+        commandSkillReferences,
+        extensionRegistry,
+        extensionLoadRecords: options.extensionLoadRecords ?? createInternalExtensionRecords(extensions)
+    };
+    const packageInfo = options.packageInfo ?? cliPackageInfo;
+    return {
+        packageInfo,
+        extensions: [...extensions],
+        run: async (argv = process.argv.slice(2), runOptions = {}) => await runCliWithConfig(config, argv, runOptions),
+        createHelpText: () => createHelpText({
+            commandReferences,
+            commandSkillReferences
+        }),
+        getCommandReferences: () => [...commandReferences]
+    };
+}
+export const defaultOpenRuntimeCli = createOpenRuntimeCli();
+export async function runCli(argv = process.argv.slice(2), options = {}) {
+    const stderr = options.stderr ?? process.stderr;
+    const loaded = await createOpenRuntimeCliWithExternalExtensions();
+    for (const record of loaded.extensionLoadRecords) {
+        if (record.source === "external" && record.status !== "loaded") {
+            stderr.write(formatExternalExtensionWarning(record));
+        }
+    }
+    return await loaded.cli.run(argv, {
+        ...options,
+        stderr
+    });
+}
+export async function createOpenRuntimeCliWithExternalExtensions(options = {}, env = process.env) {
+    const internalExtensions = options.extensions ?? [];
+    const reservedNames = [
+        ...createBuiltInCommandNameSet(),
+        ...internalExtensions.map((extension) => extension.name)
+    ];
+    const external = await loadExternalCliExtensions({
+        reservedNames,
+        env
+    });
+    const extensionLoadRecords = [
+        ...createInternalExtensionRecords(internalExtensions),
+        ...external.records
+    ];
+    return {
+        cli: createOpenRuntimeCli({
+            ...options,
+            extensions: [
+                ...internalExtensions,
+                ...external.extensions
+            ],
+            extensionLoadRecords
+        }),
+        extensionLoadRecords
+    };
+}
+function formatExternalExtensionWarning(record) {
+    const location = record.path === undefined ? record.name : record.path;
+    const reason = record.reason ?? "unknown reason";
+    return `Skipped external OpenRuntime command ${location}: ${reason}\n`;
+}
+async function runCliWithConfig(config, argv, options) {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const fetcher = options.fetcher ?? fetch;
+    const browserRunner = options.browserRunner ?? createNextBrowserRunner();
+    const bridgeStarter = options.bridgeStarter ?? createDetachedBridgeStarter(import.meta.url);
+    const operationLogStore = createFileOperationLogStore(process.cwd(), options.operationLogDirectory);
+    const args = parseCliArgs(argv);
+    try {
+        if (args.command.length === 0 || hasOption(args, "help")) {
+            stdout.write(`${createHelpText({
+                commandReferences: config.commandReferences,
+                commandSkillReferences: config.commandSkillReferences
+            })}\n`);
+            return 0;
+        }
+        if (args.command[0] === "__bridge-server") {
+            return await runBridgeServerCommand(args, stdout, options.waitUntilClosed);
+        }
+        if (args.command[0] === "start") {
+            return await runStartCommand(args, stdout, fetcher, bridgeStarter, createBridgeStateStore(args, options.bridgeStateDirectory));
+        }
+        if (args.command[0] === "stop") {
+            return await runStopCommand(args, stdout, browserRunner, createBridgeStateStore(args, options.bridgeStateDirectory), operationLogStore, options.bridgeProcessController);
+        }
+        if (args.command[0] === "auth") {
+            return await runAuthCommand(args, stdout, browserRunner, options.authConnectorExporter ?? exportAuthProfileWithConnector, options.authStateApplier);
+        }
+        if (args.command[0] === "record") {
+            return await runRecordCommand({
+                args,
+                stdout,
+                fetcher,
+                browserRunner,
+                bridgeUrl: createBridgeUrl(args),
+                bridgeStarter,
+                bridgeStateStore: createBridgeStateStore(args, options.bridgeStateDirectory)
+            });
+        }
+        if (isBrowserCommand(args.command[0])) {
+            return await runBrowserCliCommand(args, stdout, stderr, fetcher, browserRunner, bridgeStarter, createBridgeStateStore(args, options.bridgeStateDirectory), operationLogStore);
+        }
+        if (args.command[0] === "runtimes") {
+            const bridgeUrl = await ensureLocalBridgeForRuntimeCommand(args, fetcher, bridgeStarter, createBridgeStateStore(args, options.bridgeStateDirectory));
+            const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+            writeJson(stdout, {
+                bridgeUrl,
+                runtimes
+            });
+            return 0;
+        }
+        if (isRuntimeResourceCommand(args.command[0])) {
+            const resourceCommand = args.command[0];
+            const commandArgs = applyOpenContextDefaultsOrThrow(args, await operationLogStore.read(), "unless-selector");
+            const bridgeUrl = await ensureLocalBridgeForRuntimeCommand(commandArgs, fetcher, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory));
+            const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+            const runtime = selectRuntime(runtimes, createRuntimeSelector(commandArgs));
+            const result = await fetchRuntimeResource(fetcher, bridgeUrl, runtime, resourceCommand, createQuery(commandArgs, resourceCommand));
+            writeJson(stdout, result);
+            return 0;
+        }
+        if (args.command[0] === "input-options") {
+            const actionName = requireOption(args, "action");
+            const inputName = requireOption(args, "input");
+            const payload = parsePayloadOption(args);
+            const commandArgs = applyOpenContextDefaultsOrThrow(args, await operationLogStore.read(), "unless-selector");
+            const bridgeUrl = await ensureLocalBridgeForRuntimeCommand(commandArgs, fetcher, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory));
+            const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+            const runtime = selectRuntime(runtimes, createRuntimeSelector(commandArgs));
+            const result = await fetchInputOptions(fetcher, bridgeUrl, runtime, actionName, inputName, payload, getNumberOption(args, "timeout"));
+            writeJson(stdout, result);
+            return 0;
+        }
+        if (args.command[0] === "run-action") {
+            const actionName = requireCommandArgument(args, 1, "action name");
+            const payload = parsePayloadOption(args);
+            const commandArgs = applyOpenContextDefaultsOrThrow(args, await operationLogStore.read(), "unless-selector");
+            const bridgeUrl = await ensureLocalBridgeForRuntimeCommand(commandArgs, fetcher, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory));
+            const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+            const runtime = selectRuntime(runtimes, createRuntimeSelector(commandArgs));
+            const result = await runRuntimeAction(fetcher, bridgeUrl, runtime, actionName, payload);
+            writeJson(stdout, result);
+            return 0;
+        }
+        if (args.command[0] === "verify") {
+            const targetId = requireCommandArgument(args, 1, "target id");
+            const status = requireCommandArgument(args, 2, "status");
+            const commandArgs = applyOpenContextDefaultsOrThrow(args, await operationLogStore.read(), "unless-selector");
+            const bridgeUrl = await ensureLocalBridgeForRuntimeCommand(commandArgs, fetcher, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory));
+            const where = parseWhereOptions(commandArgs);
+            try {
+                const result = await runVerifyCommand(commandArgs, fetcher, bridgeUrl, browserRunner, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory), targetId, status, where);
+                writeJson(stdout, result);
+                return result.result.success === true ? 0 : 1;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                writeJson(stdout, createVerifyCommandFailure(targetId, status, where, reason));
+                stderr.write(`${reason}\n`);
+                return 1;
+            }
+        }
+        if (args.command[0] === "wait-for") {
+            const targetId = requireCommandArgument(args, 1, "target id");
+            const status = requireCommandArgument(args, 2, "status");
+            const commandArgs = applyOpenContextDefaultsOrThrow(args, await operationLogStore.read(), "unless-selector");
+            const bridgeUrl = await ensureLocalBridgeForRuntimeCommand(commandArgs, fetcher, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory));
+            const where = parseWhereOptions(commandArgs);
+            try {
+                const result = await waitForRuntimeCommand(commandArgs, fetcher, bridgeUrl, browserRunner, bridgeStarter, createBridgeStateStore(commandArgs, options.bridgeStateDirectory), targetId, status, where);
+                writeJson(stdout, result);
+                return isFailedWaitResult(result.result) ? 1 : 0;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                writeJson(stdout, createWaitForFailure(targetId, status, where, reason));
+                stderr.write(`${reason}\n`);
+                return 1;
+            }
+        }
+        const command = args.command[0];
+        if (command === undefined) {
+            throw createError({
+                code: "CLI_COMMAND_MISSING",
+                kind: "validation",
+                message: "Missing command.",
+                hint: "Run `openruntime --help` to see available commands."
+            });
+        }
+        const extension = config.extensionRegistry.get(command);
+        if (extension !== undefined) {
+            if (hasOption(args, "skill")) {
+                if (args.command.length !== 1 || getOptionValue(args, "skill") !== "true") {
+                    throw createError({
+                        code: "CLI_COMMAND_SKILL_USAGE_INVALID",
+                        kind: "validation",
+                        message: `Command skill lookup only accepts the command name.`,
+                        hint: `Run \`openruntime ${command} --skill\`.`
+                    });
+                }
+                if (extension.skill === undefined) {
+                    throw createError({
+                        code: "CLI_COMMAND_SKILL_UNAVAILABLE",
+                        kind: "not_found",
+                        message: `Command "${command}" does not provide a skill.`,
+                        hint: "Run `openruntime --help` to see commands with available skills."
+                    });
+                }
+                const skill = validateCommandSkill(extension.skill, extension.name);
+                stdout.write(`${skill.path}\n`);
+                return 0;
+            }
+            const openContext = await operationLogStore.read();
+            const extensionArgs = applyOpenContextDefaults(args, openContext);
+            const bridgeStateStore = createBridgeStateStore(extensionArgs, options.bridgeStateDirectory);
+            return await extension.run({
+                args: extensionArgs,
+                stdout,
+                stderr,
+                fetcher,
+                ...(openContext === undefined ? {} : { page: createExtensionPageContext(openContext) }),
+                openruntime: createOpenRuntimeExtensionApi({
+                    args: extensionArgs,
+                    fetcher,
+                    browserRunner,
+                    bridgeStarter,
+                    bridgeStateStore,
+                    ...(openContext === undefined ? {} : { openContext })
+                }),
+                output: createCommandOutput(stdout, extensionArgs.command.join(" "))
+            });
+        }
+        throw createError({
+            code: "CLI_UNKNOWN_COMMAND",
+            kind: "validation",
+            message: `Unknown command "${args.command.join(" ")}".`,
+            hint: "Run `openruntime --help` to see available commands."
+        });
+    }
+    catch (error) {
+        writeErrorOutput(stdout, args.command.join(" ") || "openruntime", error);
+        return 1;
+    }
+}
+function createExtensionRegistry(extensions) {
+    const registry = new Map();
+    const builtInCommandNames = createBuiltInCommandNameSet();
+    for (const extension of extensions) {
+        if (extension.name.length === 0) {
+            throw new Error("CLI command name must not be empty.");
+        }
+        if (builtInCommandNames.has(extension.name)) {
+            throw new Error(`CLI command "${extension.name}" conflicts with a built-in command.`);
+        }
+        if (registry.has(extension.name)) {
+            throw new Error(`CLI command "${extension.name}" is registered more than once.`);
+        }
+        if (extension.skill !== undefined) {
+            validateCommandSkill(extension.skill, extension.name);
+        }
+        registry.set(extension.name, extension);
+    }
+    return registry;
+}
+function createCommandSkillReferences(extension) {
+    if (extension.skill === undefined)
+        return [];
+    let category;
+    for (const reference of extension.commandReferences ?? []) {
+        if (reference.category === "Commands" || reference.category === "External Commands") {
+            category = reference.category;
+            break;
+        }
+    }
+    if (category === undefined)
+        return [];
+    return [{
+            category,
+            command: extension.name
+        }];
+}
+function createBuiltInCommandNameSet() {
+    return new Set([
+        "__bridge-server",
+        "start",
+        "stop",
+        "auth",
+        "record",
+        "runtimes",
+        "input-options",
+        "run-action",
+        "verify",
+        "wait-for",
+        ...BROWSER_COMMAND_NAMES,
+        ...RUNTIME_RESOURCE_COMMAND_NAMES
+    ]);
+}
+function createRuntimeSelector(args, options = {}) {
+    const selector = {};
+    const runtimeId = getOptionValue(args, "runtime");
+    const sessionId = getOptionValue(args, "session");
+    const url = getOptionValue(args, "url");
+    if (runtimeId !== undefined && options.ignoreRuntimeId !== true)
+        selector.runtimeId = runtimeId;
+    if (sessionId !== undefined)
+        selector.sessionId = sessionId;
+    if (url !== undefined)
+        selector.url = withOpenRuntimeSession(url, sessionId);
+    return selector;
+}
+async function ensureLocalBridgeForRuntimeCommand(args, fetcher, bridgeStarter, bridgeStateStore) {
+    const bridgeUrl = createBridgeUrl(args);
+    if (!canAutoStartBridge(bridgeUrl)) {
+        return bridgeUrl;
+    }
+    await ensureBridge({
+        fetcher,
+        bridgeUrl,
+        starter: bridgeStarter,
+        stateStore: bridgeStateStore,
+        ...createOptionalNumberProperty("port", getNumberOption(args, "port"))
+    });
+    return bridgeUrl;
+}
+function requireOption(args, name) {
+    const value = getOptionValue(args, name);
+    if (value === undefined || value.length === 0) {
+        throw createError({
+            code: "CLI_REQUIRED_OPTION_MISSING",
+            kind: "validation",
+            message: `Missing required option "--${name}".`,
+            details: {
+                option: name
+            }
+        });
+    }
+    return value;
+}
+function requireCommandArgument(args, index, label) {
+    const value = args.command[index];
+    if (value === undefined || value.length === 0) {
+        throw createError({
+            code: "CLI_REQUIRED_ARGUMENT_MISSING",
+            kind: "validation",
+            message: `Missing required ${label}.`,
+            details: {
+                argument: label,
+                index
+            }
+        });
+    }
+    return value;
+}
+function parsePayloadOption(args) {
+    const payload = getOptionValue(args, "payload");
+    if (payload === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw createError({
+            code: "CLI_PAYLOAD_INVALID_JSON",
+            kind: "validation",
+            message: "--payload must be valid JSON.",
+            hint: "Pass --payload as a JSON object string."
+        });
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw createError({
+            code: "CLI_PAYLOAD_INVALID_SHAPE",
+            kind: "validation",
+            message: "--payload must be a JSON object.",
+            hint: "Pass --payload as a JSON object string."
+        });
+    }
+    return parsed;
+}
+function parseWhereOptions(args) {
+    const values = getOptionValues(args, "where");
+    if (values.length === 0)
+        return undefined;
+    return values.map((value) => {
+        const equalsIndex = value.indexOf("=");
+        if (equalsIndex <= 0) {
+            throw new Error("--where must use the form path=value.");
+        }
+        const path = value.slice(0, equalsIndex).trim();
+        if (path.length === 0) {
+            throw new Error("--where path must not be empty.");
+        }
+        return {
+            path,
+            equals: parseWhereValue(value.slice(equalsIndex + 1))
+        };
+    });
+}
+function parseWhereValue(rawValue) {
+    const value = rawValue.trim();
+    if (value.length === 0)
+        return "";
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function createWaitForFailure(targetId, status, where, reason) {
+    const condition = {
+        id: targetId,
+        status
+    };
+    if (where !== undefined) {
+        condition.where = where;
+    }
+    return {
+        result: {
+            success: false,
+            condition,
+            reason
+        }
+    };
+}
+async function runVerifyCommand(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore, targetId, status, where) {
+    const waitResult = await waitForRuntimeCommand(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore, targetId, status, where);
+    const targetDefinitions = await fetchVerifyTargetDefinitions(fetcher, bridgeUrl, waitResult.runtime);
+    const waitPayload = waitResult.result;
+    const target = getVerifyTarget(targetId, waitPayload, targetDefinitions);
+    const targetClass = classifyVerifyTarget(target);
+    const businessTargetHints = getBusinessTargetHints(waitPayload, targetDefinitions, targetId);
+    const hasBusinessTarget = businessTargetHints.length > 0 || targetClass === "business";
+    const visibility = targetClass === "business" || hasBusinessTarget
+        ? createSkippedVisibility("Business target evidence is available.")
+        : await readVerifyVisibility(browserRunner);
+    const evidence = createVerifyEvidence({
+        targetId,
+        targetClass,
+        targetFound: target !== undefined,
+        waitPayload,
+        visibility,
+        businessTargetHints
+    });
+    const condition = {
+        id: targetId,
+        status
+    };
+    if (where !== undefined) {
+        condition.where = where;
+    }
+    return {
+        runtime: waitResult.runtime,
+        result: {
+            success: evidence.level === "business" && getWaitSuccess(waitPayload) === true,
+            condition,
+            evidence,
+            wait: waitPayload,
+            visibility
+        }
+    };
+}
+function createVerifyCommandFailure(targetId, status, where, reason) {
+    const waitFailure = createWaitForFailure(targetId, status, where, reason).result;
+    const condition = {
+        id: targetId,
+        status
+    };
+    if (where !== undefined) {
+        condition.where = where;
+    }
+    return {
+        result: {
+            success: false,
+            condition,
+            evidence: {
+                level: "insufficient",
+                scope: "none",
+                targetClass: "unknown",
+                businessVerified: false,
+                message: "OpenRuntime could not read enough runtime evidence to verify the requested result.",
+                nextStep: "Open or connect the page runtime first, then rerun verify; if no business target exists, use one one-time page check or add a minimal business target."
+            },
+            wait: waitFailure,
+            visibility: createSkippedVisibility("Runtime evidence was unavailable.")
+        }
+    };
+}
+async function fetchVerifyTargetDefinitions(fetcher, bridgeUrl, runtime) {
+    try {
+        const result = await fetchRuntimeResource(fetcher, bridgeUrl, runtime, "targets", new URLSearchParams());
+        return Array.isArray(result.result) ? result.result : [];
+    }
+    catch {
+        return [];
+    }
+}
+function createVerifyEvidence(options) {
+    const waitSuccess = getWaitSuccess(options.waitPayload);
+    if (options.targetClass === "business") {
+        if (waitSuccess === true) {
+            return {
+                level: "business",
+                scope: "business-result",
+                targetClass: "business",
+                businessVerified: true,
+                message: "The requested business target reached the expected status."
+            };
+        }
+        return {
+            level: "business",
+            scope: "business-result",
+            targetClass: "business",
+            businessVerified: false,
+            message: "The requested business target did not reach the expected status.",
+            nextStep: "Use the target error, current status, or related events to fix the business failure."
+        };
+    }
+    if (options.targetFound && options.targetClass !== "unknown") {
+        const nextStep = options.businessTargetHints.length > 0
+            ? `Use a business target for final verification, for example "${options.businessTargetHints[0]}".`
+            : getVisibilityNextStep(options.visibility);
+        return {
+            level: "runtime",
+            scope: "runtime-layer",
+            targetClass: options.targetClass,
+            businessVerified: false,
+            message: waitSuccess === true
+                ? "The requested runtime-layer target reached the expected status, but this does not prove the business result."
+                : "The requested runtime-layer target did not reach the expected status.",
+            nextStep,
+            ...(options.businessTargetHints.length === 0 ? {} : { businessTargetHints: options.businessTargetHints })
+        };
+    }
+    return {
+        level: "insufficient",
+        scope: "none",
+        targetClass: "unknown",
+        businessVerified: false,
+        message: "The requested target was not available as OpenRuntime evidence.",
+        nextStep: getVisibilityNextStep(options.visibility)
+    };
+}
+function getVisibilityNextStep(visibility) {
+    if (visibility.status === "blank") {
+        return "Treat the page as not verified; investigate the blank page or add a minimal business target before claiming success.";
+    }
+    if (visibility.status === "visible") {
+        return "For repeated verification, add a minimal business target; for a one-time check, label this as browser visibility evidence, not OpenRuntime business evidence.";
+    }
+    if (visibility.status === "unavailable") {
+        return "Use one one-time page check or add a minimal business target; do not claim business success from runtime-layer evidence alone.";
+    }
+    return "Add a minimal business target or perform one explicit page check before claiming business success.";
+}
+function getVerifyTarget(targetId, waitPayload, targetDefinitions) {
+    const waitTarget = getRecordField(waitPayload, "target");
+    if (isRuntimeSnapshotTargetLike(waitTarget)) {
+        return waitTarget;
+    }
+    const snapshot = getRuntimeSnapshot(waitPayload);
+    const snapshotTarget = snapshot?.targets[targetId];
+    if (snapshotTarget !== undefined) {
+        return snapshotTarget;
+    }
+    return targetDefinitions.find((target) => target.id === targetId);
+}
+function getBusinessTargetHints(waitPayload, targetDefinitions, requestedTargetId) {
+    const candidates = new Map();
+    for (const target of targetDefinitions) {
+        candidates.set(target.id, target);
+    }
+    const snapshot = getRuntimeSnapshot(waitPayload);
+    if (snapshot !== undefined) {
+        for (const target of Object.values(snapshot.targets)) {
+            candidates.set(target.id, target);
+        }
+    }
+    return [...candidates.values()]
+        .filter((target) => target.id !== requestedTargetId && classifyVerifyTarget(target) === "business")
+        .map((target) => target.id)
+        .slice(0, 5);
+}
+function classifyVerifyTarget(target) {
+    if (target === undefined)
+        return "unknown";
+    const id = target.id.toLowerCase();
+    const type = target.type.toLowerCase();
+    const source = target.source?.toLowerCase() ?? "";
+    const haystack = `${id} ${type} ${source}`;
+    if (id.startsWith("modern:garfish") || type.includes("garfish") || source.includes("garfish")) {
+        return "garfish";
+    }
+    if (id.startsWith("mf:") || type.startsWith("mf.") || source.includes("module-federation") || source === "mf") {
+        return "module-federation";
+    }
+    if (haystack.includes("vmok")) {
+        return "vmok";
+    }
+    if (id.startsWith("modern:") || type.startsWith("modern.") || source.includes("modern")) {
+        return "modern";
+    }
+    if (id.startsWith("openruntime:") || type.startsWith("openruntime.") || source === "openruntime") {
+        return "openruntime";
+    }
+    return "business";
+}
+async function readVerifyVisibility(browserRunner) {
+    const result = await browserRunner.run(["eval", createPageVisibilityScript()]);
+    if (result.exitCode !== 0) {
+        return {
+            checked: true,
+            status: "unavailable",
+            blank: null,
+            reason: result.stderr.trim() || result.stdout.trim() || "Browser visibility check failed."
+        };
+    }
+    try {
+        const parsed = parseBrowserJsonOutput(result.stdout);
+        if (!isRecord(parsed)) {
+            return {
+                checked: true,
+                status: "unknown",
+                blank: null,
+                reason: "Browser visibility check did not return an object."
+            };
+        }
+        const blank = typeof parsed.blank === "boolean" ? parsed.blank : null;
+        return {
+            checked: true,
+            status: blank === true ? "blank" : blank === false ? "visible" : "unknown",
+            blank,
+            details: {
+                ...createOptionalStringProperty("url", getStringValue(parsed.url)),
+                ...createOptionalStringProperty("title", getStringValue(parsed.title)),
+                ...createOptionalNumberProperty("textLength", getNumberValue(parsed.textLength)),
+                ...createOptionalNumberProperty("visibleElementCount", getNumberValue(parsed.visibleElementCount)),
+                ...createOptionalNumberProperty("bodyChildElementCount", getNumberValue(parsed.bodyChildElementCount)),
+                ...createOptionalNumberProperty("rootChildElementCount", getNumberValue(parsed.rootChildElementCount))
+            }
+        };
+    }
+    catch (error) {
+        return {
+            checked: true,
+            status: "unknown",
+            blank: null,
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function createSkippedVisibility(reason) {
+    return {
+        checked: false,
+        status: "unknown",
+        blank: null,
+        reason
+    };
+}
+function createPageVisibilityScript() {
+    return [
+        "(() => {",
+        "  const body = document.body;",
+        "  if (!body) return { blank: true, url: location.href, title: document.title, textLength: 0, visibleElementCount: 0, bodyChildElementCount: 0, rootChildElementCount: 0 };",
+        "  const isVisible = (element) => {",
+        "    const style = window.getComputedStyle(element);",
+        "    const rect = element.getBoundingClientRect();",
+        "    return style.visibility !== 'hidden' && style.display !== 'none' && rect.width > 0 && rect.height > 0;",
+        "  };",
+        "  const visibleElementCount = Array.from(body.querySelectorAll('*')).filter(isVisible).length;",
+        "  const textLength = (body.innerText || '').replace(/\\s+/g, ' ').trim().length;",
+        "  const root = document.querySelector('#root, #app, [data-openruntime-root], main, [role=\"main\"]');",
+        "  const bodyChildElementCount = body.children.length;",
+        "  const rootChildElementCount = root ? root.children.length : 0;",
+        "  const blank = textLength === 0 && visibleElementCount <= 1 && bodyChildElementCount <= 1 && rootChildElementCount === 0;",
+        "  return { blank, url: location.href, title: document.title, textLength, visibleElementCount, bodyChildElementCount, rootChildElementCount };",
+        "})()"
+    ].join("\n");
+}
+function getWaitSuccess(waitPayload) {
+    if (!isRecord(waitPayload))
+        return undefined;
+    return typeof waitPayload.success === "boolean" ? waitPayload.success : undefined;
+}
+function getRuntimeSnapshot(waitPayload) {
+    const snapshot = getRecordField(waitPayload, "snapshot");
+    if (!isRecord(snapshot) || !isRecord(snapshot.targets))
+        return undefined;
+    return snapshot;
+}
+function getRecordField(value, field) {
+    return isRecord(value) ? value[field] : undefined;
+}
+function isRuntimeSnapshotTargetLike(value) {
+    return isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.type === "string" &&
+        typeof value.status === "string";
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getStringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function getNumberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+async function runBrowserCliCommand(args, stdout, stderr, fetcher, browserRunner, bridgeStarter, bridgeStateStore, operationLogStore) {
+    const command = args.command[0];
+    if (command === "open") {
+        const url = requireCommandArgument(args, 1, "URL");
+        const sessionId = getOpenCommandSessionId(args);
+        const openedUrl = withOpenRuntimeSession(url, sessionId);
+        const bridgeUrl = hasOption(args, "no-bridge") ? null : createBridgeUrl(args);
+        await operationLogStore.remove();
+        if (!hasOption(args, "no-bridge")) {
+            await ensureBridge({
+                fetcher,
+                bridgeUrl: createBridgeUrl(args),
+                starter: bridgeStarter,
+                stateStore: bridgeStateStore,
+                ...createOptionalNumberProperty("port", getNumberOption(args, "port"))
+            });
+        }
+        const result = await browserRunner.run(createOpenBrowserArgs(args, url, sessionId), { ui: hasOption(args, "ui") });
+        if (result.exitCode !== 0) {
+            throw createError({
+                code: "PAGE_OPEN_FAILED",
+                kind: "browser",
+                message: result.stderr.trim() || result.stdout.trim() || "Could not open the page.",
+                details: {
+                    url,
+                    openedUrl,
+                    ...(result.stdout.trim().length === 0 ? {} : { stdout: result.stdout.trim() }),
+                    ...(result.stderr.trim().length === 0 ? {} : { stderr: result.stderr.trim() })
+                }
+            });
+        }
+        const openedAt = Date.now();
+        const normalizedUrl = normalizeOpenRuntimeUrlForMatch(openedUrl);
+        await operationLogStore.write({
+            command: "open",
+            url,
+            normalizedUrl,
+            bridgeUrl,
+            sessionId,
+            openedAt,
+            exitCode: result.exitCode
+        });
+        createCommandOutput(stdout, args.command.join(" ")).ok({
+            url,
+            openedUrl,
+            normalizedUrl,
+            bridgeUrl,
+            sessionId,
+            openedAt
+        }, "Page opened.");
+        return 0;
+    }
+    if (command === "close") {
+        const exitCode = await runBrowserAndPipe(browserRunner, createBrowserCommandArgs(args), stdout, stderr);
+        await operationLogStore.remove();
+        return exitCode;
+    }
+    const commandArgs = isBrowserPageCommand(command)
+        ? applyOpenContextDefaultsOrThrow(args, await operationLogStore.read(), "always")
+        : args;
+    if (command === "get-window") {
+        const path = requireCommandArgument(commandArgs, 1, "window path");
+        return await runBrowserAndPipe(browserRunner, ["eval", createGetWindowScript(path)], stdout, stderr);
+    }
+    if (command === "click") {
+        return await runClickCommand(commandArgs, stdout, stderr, browserRunner);
+    }
+    if (command === "wait-eval") {
+        const script = requireCommandArgument(commandArgs, 1, "eval script");
+        const result = await waitForBrowserEval(browserRunner, script, getNumberOption(commandArgs, "timeout"));
+        writeJson(stdout, result);
+        return 0;
+    }
+    if (command === "network") {
+        return await runNetworkCommand(commandArgs, stdout, stderr, browserRunner);
+    }
+    if (command === "console") {
+        return await runConsoleCommand(commandArgs, stdout, stderr, browserRunner);
+    }
+    return await runBrowserAndPipe(browserRunner, createBrowserCommandArgs(commandArgs), stdout, stderr);
+}
+async function runClickCommand(args, stdout, stderr, browserRunner) {
+    const target = requireCommandArgument(args, 1, "ref, selector, or text");
+    if (!shouldPreferInteractiveTextClick(target)) {
+        return await runBrowserAndPipe(browserRunner, ["click", target], stdout, stderr);
+    }
+    const result = await browserRunner.run(["eval", createInteractiveTextClickScript(target)]);
+    if (result.exitCode === 0) {
+        stdout.write("clicked\n");
+        return 0;
+    }
+    if (result.stdout.length > 0) {
+        stdout.write(result.stdout.endsWith("\n") ? result.stdout : `${result.stdout}\n`);
+    }
+    if (result.stderr.length > 0) {
+        stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+    }
+    return result.exitCode;
+}
+async function waitForRuntimeCommand(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore, targetId, status, where) {
+    if (hasOption(args, "next") && hasOption(args, "strict")) {
+        throw new Error("--next cannot be used with --strict.");
+    }
+    if (hasOption(args, "strict")) {
+        const runtime = await selectRuntimeForWait(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore);
+        return await waitForRuntime(fetcher, bridgeUrl, runtime, targetId, status, getNumberOption(args, "timeout"), where);
+    }
+    return await waitForLatestRuntime(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore, targetId, status, where);
+}
+async function selectRuntimeForWait(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore) {
+    const selector = createRuntimeSelector(args);
+    try {
+        const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+        return selectRuntime(runtimes, selector);
+    }
+    catch (error) {
+        if (!hasOption(args, "open")) {
+            throw addOpenHint(error, selector);
+        }
+        const url = requireOption(args, "url");
+        await ensureBridge({
+            fetcher,
+            bridgeUrl,
+            starter: bridgeStarter,
+            stateStore: bridgeStateStore,
+            ...createOptionalNumberProperty("port", getNumberOption(args, "port"))
+        });
+        await runBrowserOrThrow(browserRunner, ["open", withOpenRuntimeSession(url, selector.sessionId)]);
+        return await waitForSelectedRuntime({
+            fetcher,
+            bridgeUrl,
+            selector,
+            ...createOptionalNumberProperty("timeout", getNumberOption(args, "timeout"))
+        });
+    }
+}
+async function waitForLatestRuntime(args, fetcher, bridgeUrl, browserRunner, bridgeStarter, bridgeStateStore, targetId, status, where) {
+    const selector = createRuntimeSelector(args, { ignoreRuntimeId: true });
+    const timeout = getNumberOption(args, "timeout") ?? 5000;
+    const deadline = Date.now() + timeout;
+    const ignoredRuntimeIds = hasOption(args, "next")
+        ? await collectConnectedRuntimeIds(fetcher, bridgeUrl, selector)
+        : new Set();
+    let lastError;
+    let lastResult;
+    let didOpen = false;
+    while (Date.now() <= deadline) {
+        const remainingTimeout = Math.max(1, deadline - Date.now());
+        try {
+            const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+            const runtime = selectRuntime(ignoredRuntimeIds.size === 0
+                ? runtimes
+                : runtimes.filter((item) => !ignoredRuntimeIds.has(item.runtimeId)), selector);
+            const result = await waitForRuntime(fetcher, bridgeUrl, runtime, targetId, status, remainingTimeout, where);
+            if (!isRetryableWaitResult(result.result)) {
+                return result;
+            }
+            lastResult = result;
+        }
+        catch (error) {
+            lastError = error;
+            if (!isRetryableWaitError(error)) {
+                throw error;
+            }
+            if (hasOption(args, "open") && !didOpen) {
+                didOpen = true;
+                const url = requireOption(args, "url");
+                await ensureBridge({
+                    fetcher,
+                    bridgeUrl,
+                    starter: bridgeStarter,
+                    stateStore: bridgeStateStore,
+                    ...createOptionalNumberProperty("port", getNumberOption(args, "port"))
+                });
+                await runBrowserOrThrow(browserRunner, ["open", withOpenRuntimeSession(url, selector.sessionId)]);
+            }
+        }
+        await sleep(100);
+    }
+    if (lastResult !== undefined) {
+        return lastResult;
+    }
+    if (hasOption(args, "next")) {
+        throw addOpenHint(new Error("No new connected runtime was found before timeout."), selector);
+    }
+    throw addOpenHint(lastError ?? new Error("No connected runtime was found before timeout."), selector);
+}
+async function collectConnectedRuntimeIds(fetcher, bridgeUrl, selector) {
+    const runtimes = await fetchRuntimes(fetcher, bridgeUrl);
+    const matchingConnectedRuntimes = filterConnectedRuntimes(runtimes, selector);
+    return new Set(matchingConnectedRuntimes.map((runtime) => runtime.runtimeId));
+}
+function filterConnectedRuntimes(runtimes, selector) {
+    if (selector.runtimeId !== undefined) {
+        return runtimes.filter((runtime) => runtime.runtimeId === selector.runtimeId && runtime.status === "connected");
+    }
+    const sessionId = selector.sessionId ?? (selector.url === undefined ? undefined : getOpenRuntimeSessionId(selector.url));
+    const normalizedUrl = selector.url === undefined ? undefined : normalizeUrlWithoutOpenRuntimeSession(selector.url);
+    return runtimes.filter((runtime) => runtime.status === "connected" &&
+        (sessionId === undefined || runtime.sessionId === sessionId || getOpenRuntimeSessionId(runtime.url) === sessionId) &&
+        (normalizedUrl === undefined || normalizeUrlWithoutOpenRuntimeSession(runtime.url) === normalizedUrl));
+}
+function normalizeUrlWithoutOpenRuntimeSession(input) {
+    return normalizeOpenRuntimeUrlForMatch(input);
+}
+function getOpenRuntimeSessionId(input) {
+    try {
+        const sessionId = new URL(input).searchParams.get(OPEN_RUNTIME_SESSION_QUERY_PARAM);
+        return sessionId === null || sessionId.length === 0 ? undefined : sessionId;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runStartCommand(args, stdout, fetcher, bridgeStarter, bridgeStateStore) {
+    const result = await ensureBridge({
+        fetcher,
+        bridgeUrl: createBridgeUrl(args),
+        starter: bridgeStarter,
+        stateStore: bridgeStateStore,
+        ...createOptionalNumberProperty("port", getNumberOption(args, "port"))
+    });
+    writeJson(stdout, result);
+    return 0;
+}
+async function runStopCommand(args, stdout, browserRunner, bridgeStateStore, operationLogStore, bridgeProcessController) {
+    const closeResult = await browserRunner.run(["close"]);
+    await operationLogStore.remove();
+    const bridgeResult = await stopManagedBridge({
+        bridgeUrl: createBridgeUrl(args),
+        stateStore: bridgeStateStore,
+        ...createOptionalObjectProperty("processController", bridgeProcessController)
+    });
+    writeJson(stdout, {
+        browser: {
+            command: "close",
+            exitCode: closeResult.exitCode
+        },
+        bridge: bridgeResult
+    });
+    return 0;
+}
+async function runAuthCommand(args, stdout, browserRunner, authConnectorExporter, authStateApplier) {
+    const action = args.command[1];
+    if (action === "export") {
+        return await runAuthExportCommand(args, stdout, authConnectorExporter);
+    }
+    if (action === "import") {
+        return await runAuthImportCommand(args, stdout, browserRunner, authStateApplier);
+    }
+    if (action === "list") {
+        writeJson(stdout, await listProfile({
+            profileDirectory: getProfileDirectory()
+        }));
+        return 0;
+    }
+    if (action === "clear") {
+        const url = getOptionValue(args, "url") ?? args.command[2];
+        await closeBrowserForProfileCommand(browserRunner, {
+            allowMissingBrowser: true
+        });
+        writeJson(stdout, await clearProfile({
+            profileDirectory: getProfileDirectory(),
+            ...createOptionalStringProperty("url", url)
+        }));
+        return 0;
+    }
+    throw createError({
+        code: "AUTH_COMMAND_INVALID",
+        kind: "validation",
+        message: "auth requires export, import, list, or clear.",
+        outputCommand: "auth",
+        hint: "Use `openruntime auth export --url <url>`, `openruntime auth import --input <path>`, `openruntime auth list`, or `openruntime auth clear --url <url>`."
+    });
+}
+async function runAuthExportCommand(args, stdout, authConnectorExporter) {
+    const requestedUrl = getOptionValue(args, "url") ?? args.command[2];
+    if (requestedUrl === undefined || requestedUrl.length === 0) {
+        throw createError({
+            code: "AUTH_EXPORT_URL_REQUIRED",
+            kind: "validation",
+            message: "auth export requires --url <url>.",
+            hint: "Use `openruntime auth export --url https://app.example.com`."
+        });
+    }
+    const result = await authConnectorExporter({
+        requestedUrl: normalizeAuthExportUrl(requestedUrl),
+        ...createOptionalStringProperty("outputPath", getOptionValue(args, "output")),
+        ...createOptionalNumberProperty("timeout", getNumberOption(args, "timeout")),
+        ...createOptionalStringProperty("extensionDirectory", getOptionValue(args, "extension-dir")),
+        ...createOptionalStringProperty("extensionInstallUrl", getOptionValue(args, "extension-install-url")),
+        ...createOptionalStringProperty("extensionIconPath", getOptionValue(args, "extension-icon"))
+    });
+    stdout.write(`${await getPrintableProfileExportResult(result)}\n`);
+    return 0;
+}
+async function runAuthImportCommand(args, stdout, browserRunner, authStateApplier) {
+    await closeBrowserForProfileCommand(browserRunner);
+    const inputPath = getOptionValue(args, "input");
+    const input = inputPath === undefined
+        ? await readProfileInput(args.command[2])
+        : await readProfileInputFile(inputPath);
+    const result = await importProfile({
+        input,
+        profileDirectory: getProfileDirectory(),
+        ...createOptionalObjectProperty("applyAuthState", authStateApplier)
+    });
+    writeJson(stdout, result);
+    return 0;
+}
+function normalizeAuthExportUrl(input) {
+    let url;
+    const trimmed = input.trim();
+    const urlLike = hasUrlScheme(trimmed) ? trimmed : `https://${trimmed}`;
+    try {
+        url = new URL(urlLike);
+    }
+    catch {
+        throw createError({
+            code: "AUTH_EXPORT_URL_INVALID",
+            kind: "validation",
+            message: `Invalid auth export URL "${input}".`,
+            hint: "Pass an http or https URL, or a plain domain."
+        });
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw createError({
+            code: "AUTH_EXPORT_URL_UNSUPPORTED",
+            kind: "validation",
+            message: "Auth export URL must use http or https.",
+            hint: "Pass an http or https URL, or a plain domain."
+        });
+    }
+    return url.href;
+}
+function hasUrlScheme(input) {
+    return /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(input);
+}
+async function getPrintableProfileExportResult(result) {
+    if (result.path !== undefined)
+        return result.path;
+    if (result.content === undefined) {
+        throw new Error("Profile export did not return content.");
+    }
+    if (result.content.length <= PROFILE_INLINE_OUTPUT_MAX_CHARS)
+        return result.content;
+    const directory = await mkdtemp(join(tmpdir(), "openruntime-profile-export-"));
+    const path = join(directory, "openruntime-profile.oprprofile");
+    await writeFile(path, `${result.content}\n`, {
+        encoding: "utf8",
+        mode: 0o600
+    });
+    return path;
+}
+async function closeBrowserForProfileCommand(browserRunner, options = {}) {
+    const result = await browserRunner.run(["close"]);
+    if (result.exitCode !== 0) {
+        const message = result.stderr.trim() || result.stdout.trim() || "Could not close OpenRuntime browser.";
+        if (options.allowMissingBrowser === true && isMissingBrowserCloseError(message)) {
+            return;
+        }
+        throw new Error(message);
+    }
+}
+function isMissingBrowserCloseError(message) {
+    return message.includes("daemon failed to start")
+        || message.includes("ECONNREFUSED")
+        || message.includes("ENOENT");
+}
+function createBridgeUrl(args) {
+    const bridge = getOptionValue(args, "bridge");
+    if (bridge !== undefined) {
+        return normalizeBridgeUrl(bridge);
+    }
+    const port = getNumberOption(args, "port");
+    if (port !== undefined) {
+        return `http://localhost:${port}`;
+    }
+    return normalizeBridgeUrl(undefined);
+}
+function createBridgeStateStore(args, stateDirectory) {
+    return createFileBridgeStateStore(createBridgeUrl(args), stateDirectory);
+}
+function createOpenBrowserArgs(args, url, sessionId) {
+    const browserArgs = ["open", withOpenRuntimeSession(url, sessionId)];
+    const cookies = getOptionValue(args, "cookies");
+    if (cookies !== undefined) {
+        browserArgs.push("--cookies", cookies);
+    }
+    return browserArgs;
+}
+function getOpenCommandSessionId(args) {
+    return getOptionValue(args, "session") ?? createOperationSessionId();
+}
+function createBrowserCommandArgs(args) {
+    const command = args.command[0];
+    if (command === "goto") {
+        return ["goto", withOpenRuntimeSession(requireCommandArgument(args, 1, "URL"), getOptionValue(args, "session"))];
+    }
+    if (command === "page-snapshot") {
+        return ["snapshot"];
+    }
+    if (command === "click") {
+        return ["click", requireCommandArgument(args, 1, "ref, selector, or text")];
+    }
+    if (command === "fill") {
+        return [
+            "fill",
+            requireCommandArgument(args, 1, "ref or selector"),
+            requireCommandArgument(args, 2, "value")
+        ];
+    }
+    if (command === "eval") {
+        const file = getOptionValue(args, "file");
+        if (file !== undefined) {
+            return ["eval", "--file", file];
+        }
+        return ["eval", requireCommandArgument(args, 1, "eval script")];
+    }
+    if (command === "screenshot") {
+        const browserArgs = ["screenshot", ...args.command.slice(1)];
+        if (hasOption(args, "full-page")) {
+            browserArgs.push("--full-page");
+        }
+        return browserArgs;
+    }
+    return ["close"];
+}
+function shouldPreferInteractiveTextClick(target) {
+    const trimmed = target.trim();
+    if (trimmed.length === 0)
+        return false;
+    if (/^e\d+$/.test(trimmed))
+        return false;
+    return !/^(css=|text=|role=|#|\[|\.|\w+\s*>)/.test(trimmed);
+}
+function withOpenRuntimeSession(input, sessionId) {
+    if (sessionId === undefined || sessionId.length === 0)
+        return input;
+    try {
+        const url = new URL(input);
+        url.searchParams.set(OPEN_RUNTIME_SESSION_QUERY_PARAM, sessionId);
+        return url.toString();
+    }
+    catch {
+        return input;
+    }
+}
+async function runBrowserAndPipe(browserRunner, browserArgs, stdout, stderr, options) {
+    const result = await browserRunner.run(browserArgs, options);
+    if (result.stdout.length > 0) {
+        stdout.write(result.stdout.endsWith("\n") ? result.stdout : `${result.stdout}\n`);
+    }
+    if (result.stderr.length > 0) {
+        stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+    }
+    return result.exitCode;
+}
+async function runNetworkCommand(args, stdout, stderr, browserRunner) {
+    const result = await browserRunner.run(["network"]);
+    const urlQuery = getOptionValue(args, "url");
+    const output = result.exitCode === 0 && urlQuery !== undefined
+        ? filterNetworkOutputByUrl(result.stdout, urlQuery)
+        : normalizeNetworkOutput(result.stdout);
+    if (output.length > 0) {
+        stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+    }
+    if (result.stderr.length > 0) {
+        stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+    }
+    return result.exitCode;
+}
+async function runConsoleCommand(args, stdout, stderr, browserRunner) {
+    const result = await browserRunner.run(["eval", createConsoleLogScript()]);
+    if (result.exitCode !== 0) {
+        if (result.stdout.length > 0) {
+            stdout.write(result.stdout.endsWith("\n") ? result.stdout : `${result.stdout}\n`);
+        }
+        if (result.stderr.length > 0) {
+            stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+        }
+        return result.exitCode;
+    }
+    const entries = filterConsoleEntries(parseConsoleEntries(parseBrowserJsonOutput(result.stdout)), {
+        ...createOptionalObjectProperty("levels", parseConsoleLevels(args)),
+        ...createOptionalStringProperty("query", getOptionValue(args, "query")),
+        ...createOptionalNumberProperty("limit", getNumberOption(args, "limit"))
+    });
+    writeJson(stdout, {
+        entries,
+        summary: summarizeConsoleEntries(entries)
+    });
+    return 0;
+}
+function parseConsoleEntries(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (entry === null || typeof entry !== "object")
+            return [];
+        const item = entry;
+        const level = normalizeConsoleLevel(item.level);
+        if (level === undefined)
+            return [];
+        return [{
+                level,
+                args: typeof item.args === "string" ? item.args : String(item.args ?? ""),
+                ...createOptionalNumberProperty("timestamp", typeof item.timestamp === "number" ? item.timestamp : undefined)
+            }];
+    });
+}
+function parseConsoleLevels(args) {
+    const values = getOptionValues(args, "level");
+    if (values.length === 0)
+        return undefined;
+    const levels = new Set();
+    for (const value of values) {
+        for (const rawLevel of value.split(",")) {
+            const level = normalizeConsoleLevel(rawLevel.trim());
+            if (level === undefined) {
+                throw new Error(`Unsupported console level "${rawLevel}". Use log, info, warn, or error.`);
+            }
+            levels.add(level);
+        }
+    }
+    return levels;
+}
+function normalizeConsoleLevel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (normalized === "warning")
+        return "warn";
+    if (normalized === "log" || normalized === "info" || normalized === "warn" || normalized === "error") {
+        return normalized;
+    }
+    return undefined;
+}
+function filterConsoleEntries(entries, options) {
+    const normalizedQuery = options.query?.toLowerCase();
+    const filtered = entries.filter((entry) => (options.levels === undefined || options.levels.has(entry.level)) &&
+        (normalizedQuery === undefined ||
+            entry.level.includes(normalizedQuery) ||
+            entry.args.toLowerCase().includes(normalizedQuery)));
+    if (options.limit === undefined || options.limit < 0)
+        return filtered;
+    return filtered.slice(-options.limit);
+}
+function summarizeConsoleEntries(entries) {
+    const summary = {
+        total: entries.length,
+        log: 0,
+        info: 0,
+        warn: 0,
+        error: 0
+    };
+    for (const entry of entries) {
+        summary[entry.level] += 1;
+    }
+    return summary;
+}
+function filterNetworkOutputByUrl(output, query) {
+    const normalized = normalizeNetworkOutput(output);
+    if (normalized.trim() === "(no requests)")
+        return normalized;
+    const lines = normalized.split(/\r?\n/);
+    const filtered = lines.filter((line) => {
+        if (line.length === 0 || line.startsWith("#"))
+            return true;
+        return getNetworkLineUrl(line)?.includes(query) ?? false;
+    });
+    return filtered.join("\n");
+}
+function normalizeNetworkOutput(output) {
+    return output.split(/\r?\n/).filter((line) => !line.includes("network <idx>")).join("\n");
+}
+function getNetworkLineUrl(line) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 6)
+        return undefined;
+    return parts[5];
+}
+async function runBrowserOrThrow(browserRunner, browserArgs) {
+    const result = await browserRunner.run(browserArgs);
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr.trim() || result.stdout.trim() || `next-browser ${browserArgs[0]} failed.`);
+    }
+}
+async function waitForBrowserEval(browserRunner, script, timeout) {
+    const deadline = Date.now() + (timeout ?? 5000);
+    let lastValue;
+    let lastError;
+    while (Date.now() <= deadline) {
+        const result = await browserRunner.run(["eval", createWaitEvalScript(script)]);
+        if (result.exitCode === 0) {
+            try {
+                lastValue = parseBrowserJsonOutput(result.stdout);
+                if (lastValue === true) {
+                    return {
+                        success: true,
+                        condition: { script },
+                        value: lastValue
+                    };
+                }
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        else {
+            lastError = result.stderr.trim() || result.stdout.trim();
+        }
+        await sleep(100);
+    }
+    const failure = {
+        success: false,
+        condition: { script }
+    };
+    if (lastValue !== undefined) {
+        failure.value = lastValue;
+    }
+    failure.reason = lastError === undefined
+        ? "Condition did not become true before timeout."
+        : `Condition did not become true before timeout. Last error: ${lastError}`;
+    return failure;
+}
+function hasOption(args, name) {
+    return args.options.has(name);
+}
+function applyOpenContextDefaults(args, openContext) {
+    if (openContext === undefined) {
+        return args;
+    }
+    const options = cloneOptions(args.options);
+    if (openContext.bridgeUrl !== null) {
+        setDefaultOption(options, "bridge", openContext.bridgeUrl);
+    }
+    if (!hasRuntimeSelectorOption(args)) {
+        setDefaultOption(options, "url", openContext.url);
+        if (openContext.sessionId !== null) {
+            setDefaultOption(options, "session", openContext.sessionId);
+        }
+    }
+    return {
+        command: args.command,
+        options
+    };
+}
+function createExtensionPageContext(openContext) {
+    return {
+        url: openContext.url,
+        openedUrl: withOpenRuntimeSession(openContext.url, openContext.sessionId ?? undefined),
+        normalizedUrl: openContext.normalizedUrl,
+        bridgeUrl: openContext.bridgeUrl,
+        sessionId: openContext.sessionId,
+        openedAt: openContext.openedAt
+    };
+}
+function applyOpenContextDefaultsOrThrow(args, openContext, requirement) {
+    if (openContext === undefined && (requirement === "always" || (!hasRuntimeSelectorOption(args) && !hasOption(args, "bridge")))) {
+        throw createOpenContextRequiredError(args);
+    }
+    if (openContext !== undefined &&
+        openContext.bridgeUrl === null &&
+        requirement === "unless-selector" &&
+        !hasRuntimeSelectorOption(args) &&
+        !hasOption(args, "bridge")) {
+        throw createError({
+            code: "OPEN_CONTEXT_REQUIRES_BRIDGE",
+            kind: "validation",
+            message: "The opened page context was created without a Bridge.",
+            retryable: false,
+            hint: "Run `openruntime open <url>` without `--no-bridge`, or pass `--bridge <url>` explicitly."
+        });
+    }
+    return applyOpenContextDefaults(args, openContext);
+}
+function createOpenContextRequiredError(args) {
+    const command = args.command.join(" ") || "openruntime";
+    return createError({
+        code: "OPEN_CONTEXT_REQUIRED",
+        kind: "validation",
+        message: "No opened page context was found.",
+        retryable: false,
+        hint: `Run \`openruntime open <url>\` before \`openruntime ${command}\`.`,
+        details: {
+            command
+        }
+    });
+}
+function hasRuntimeSelectorOption(args) {
+    return hasOption(args, "runtime") || hasOption(args, "session") || hasOption(args, "url");
+}
+function cloneOptions(options) {
+    return new Map([...options.entries()].map(([name, values]) => [name, [...values]]));
+}
+function setDefaultOption(options, name, value) {
+    if (!options.has(name)) {
+        options.set(name, [value]);
+    }
+}
+function isRetryableWaitResult(result) {
+    if (result === null || typeof result !== "object")
+        return false;
+    const value = result;
+    return value.success === false && value.reason === "Target is not registered.";
+}
+function isFailedWaitResult(result) {
+    if (result === null || typeof result !== "object")
+        return false;
+    return result.success === false;
+}
+function isRetryableWaitError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.startsWith("No connected runtime") ||
+        /^Runtime ".*" was not found\.$/.test(message) ||
+        /^Runtime ".*" is disconnected\.$/.test(message) ||
+        message === "Runtime is disconnected.";
+}
+function addOpenHint(error, selector) {
+    if (error instanceof Error && selector.url !== undefined && error.message.startsWith("No connected runtime matched")) {
+        return new Error(`${error.message}\nRun \`openruntime open <url>\` before waiting.`);
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+function createOptionalNumberProperty(name, value) {
+    return value === undefined ? {} : { [name]: value };
+}
+function createOptionalStringProperty(name, value) {
+    return value === undefined ? {} : { [name]: value };
+}
+function createOptionalObjectProperty(name, value) {
+    return value === undefined ? {} : { [name]: value };
+}
+function isBrowserCommand(command) {
+    return BROWSER_COMMAND_NAMES.includes(command);
+}
+function isBrowserPageCommand(command) {
+    return isBrowserCommand(command) && command !== "open" && command !== "goto" && command !== "close";
+}
+async function runBridgeServerCommand(args, stdout, waitUntilClosed) {
+    const server = createBridgeServer();
+    const address = await server.listen({
+        port: getNumberOption(args, "port") ?? OPEN_RUNTIME_BRIDGE_DEFAULT_PORT
+    });
+    stdout.write(`OpenRuntime Bridge listening on ${address.url}\n`);
+    if (waitUntilClosed !== undefined) {
+        await waitUntilClosed(server);
+    }
+    else {
+        await waitForProcessExit(server);
+    }
+    return 0;
+}
+function createQuery(args, command) {
+    const params = new URLSearchParams();
+    const names = getQueryOptionNames(command);
+    for (const name of names) {
+        for (const value of getOptionValues(args, name)) {
+            params.append(name, value);
+        }
+    }
+    return params;
+}
+function getQueryOptionNames(command) {
+    if (command === "targets" || command === "snapshot") {
+        return ["id", "type", "source", "status", "query"];
+    }
+    if (command === "events") {
+        return ["since", "target-id", "action", "type", "source", "status", "limit", "query"];
+    }
+    return ["name", "source", "risk", "enabled", "query"];
+}
+function isRuntimeResourceCommand(command) {
+    return RUNTIME_RESOURCE_COMMAND_NAMES.includes(command);
+}
+async function waitForProcessExit(server) {
+    const close = async () => {
+        await server.close();
+    };
+    process.once("SIGINT", () => {
+        void close();
+    });
+    process.once("SIGTERM", () => {
+        void close();
+    });
+    await once(process, "beforeExit");
+}
+function writeJson(stdout, value) {
+    stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function sleep(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}
+function isCliEntryPoint() {
+    return isEntryPoint(process.argv[1], import.meta.url);
+}
+if (isCliEntryPoint()) {
+    runCli().then((exitCode) => {
+        process.exitCode = exitCode;
+    });
+}
+export { getNumberOption, getOptionValue, getOptionValues, parseCliArgs } from "./args.js";
+export { createOpenRuntimeExtensionApi } from "./extension-api.js";
+export { convertAuthConnectorPayloadToStorageState, exportAuthProfileWithConnector, getDefaultAuthConnectorExtensionDirectory, openAuthConnectorSetupPage, writeAuthConnectorExtension } from "./auth-connector.js";
+export { createDefaultBrowserProfileDirectory, createNextBrowserEnvironment, createNextBrowserRunner, parseBrowserJsonOutput } from "./browser.js";
+export { fetchInputOptions, fetchRuntimeResource, fetchRuntimes, normalizeBridgeUrl, requestJson, runRuntimeAction, selectRuntime, waitForRuntime } from "./client.js";
+export { isEntryPoint } from "./entry.js";
+export { cliCommandReferences, createCliReferenceMarkdown, createHelpText } from "./help.js";
+export { defineCommand, validateCommand } from "./command-definition.js";
+export { createError, createCommandOutput, isCommandError, runWithOutputErrorBoundary, writeErrorOutput, writeNeedsInputOutput, writeOkOutput } from "./output.js";
+//# sourceMappingURL=index.js.map