@vibebrowser/mcp 0.2.4 → 0.2.5

package/dist/browser-cli.js

@@ -0,0 +1,1473 @@
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ExtensionConnection } from './connection.js';
+import { DEFAULT_WS_PORT } from './types.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_BROWSER_PROFILE = process.env.VIBE_BROWSER_PROFILE || 'user';
+const DEFAULT_REMOTE_UUID = process.env.VIBE_EXTENSION_UUID || process.env.VIBE_RELAY_UUID;
+const DEFAULT_REMOTE_RELAY_URL = process.env.VIBE_REMOTE_RELAY_URL || process.env.VIBE_RELAY_URL;
+export function registerBrowserCommand(program) {
+    const browser = buildBrowserCommand(program.command('browser'));
+    registerBrowserSubcommands(browser);
+}
+export function registerStandaloneBrowserCli(program) {
+    const browser = buildBrowserCommand(program);
+    registerBrowserSubcommands(browser);
+}
+function buildBrowserCommand(command) {
+    return command
+        .description('OpenClaw-compatible browser CLI for the connected Vibe browser session')
+        .option('--browser-profile <name>', 'Compatibility profile name', DEFAULT_BROWSER_PROFILE)
+        .option('--target <target>', 'OpenClaw compatibility target selector (accepted, not used by the Vibe browser CLI)')
+        .option('-p, --port <number>', 'WebSocket port for local relay (agent) connection', String(DEFAULT_WS_PORT))
+        .option('-d, --debug', 'Enable debug logging', false)
+        .option('-r, --remote <uuid>', 'Connect to a remote extension via public relay (provide the extension UUID)', DEFAULT_REMOTE_UUID)
+        .option('--relay-url <url>', 'Custom relay server URL', DEFAULT_REMOTE_RELAY_URL)
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .option('--timeout <ms>', 'Command timeout in milliseconds', String(DEFAULT_TIMEOUT_MS));
+}
+function registerBrowserSubcommands(browser) {
+    browser
+        .command('status')
+        .description('Show browser bridge status')
+        .action(async function () {
+        await runBrowserCommand(this, 'status', false, async (ctx) => ctx.status());
+    });
+    browser
+        .command('start')
+        .description('Connect to the browser bridge and verify the session is reachable')
+        .action(async function () {
+        await runBrowserCommand(this, 'start', false, async (ctx) => {
+            const status = await ctx.status();
+            return {
+                ...status,
+                started: status.extensionConnected,
+                managedLifecycle: false,
+                note: status.extensionConnected
+                    ? 'Connected to Vibe browser session'
+                    : 'Vibe uses an attach-only browser session; no managed browser process was started',
+            };
+        });
+    });
+    browser
+        .command('stop')
+        .description('Compatibility no-op: the Vibe browser bridge does not manage browser process lifecycle')
+        .action(async function () {
+        await runBrowserCommand(this, 'stop', false, async (ctx) => ({
+            ...await ctx.status(),
+            stopped: false,
+            managedLifecycle: false,
+            note: 'The Vibe browser bridge does not own the browser process, so stop only disconnects this CLI session',
+        }));
+    });
+    browser
+        .command('tabs')
+        .description('List browser tabs/pages')
+        .action(async function () {
+        await runBrowserCommand(this, 'tabs', true, async (ctx) => ctx.listPages());
+    });
+    const tab = browser.command('tab').description('Tab helpers');
+    tab
+        .action(async function () {
+        await runBrowserCommand(this, 'tab', true, async (ctx) => ctx.listPages());
+    });
+    tab
+        .command('new [url]')
+        .description('Open a new tab')
+        .action(async function (url) {
+        await runBrowserCommand(this, 'tab new', true, async (ctx) => ctx.open(url));
+    });
+    tab
+        .command('select <id>')
+        .description('Focus a tab/page')
+        .action(async function (id) {
+        await runBrowserCommand(this, 'tab select', true, async (ctx) => ctx.focus(id));
+    });
+    tab
+        .command('close <id>')
+        .description('Close a tab/page')
+        .action(async function (id) {
+        await runBrowserCommand(this, 'tab close', true, async (ctx) => ctx.close(id));
+    });
+    browser
+        .command('open <url>')
+        .description('Open a URL in a new page or navigate using the best available tool')
+        .action(async function (url) {
+        await runBrowserCommand(this, 'open', true, async (ctx) => ctx.open(url));
+    });
+    browser
+        .command('navigate <url>')
+        .description('Navigate the active page to a URL')
+        .action(async function (url) {
+        await runBrowserCommand(this, 'navigate', true, async (ctx) => ctx.navigate(url));
+    });
+    browser
+        .command('focus <id>')
+        .description('Focus a tab/page')
+        .action(async function (id) {
+        await runBrowserCommand(this, 'focus', true, async (ctx) => ctx.focus(id));
+    });
+    browser
+        .command('close <id>')
+        .description('Close a tab/page')
+        .action(async function (id) {
+        await runBrowserCommand(this, 'close', true, async (ctx) => ctx.close(id));
+    });
+    browser
+        .command('snapshot')
+        .description('Capture a textual browser snapshot')
+        .option('--format <format>', 'Snapshot format (ai or aria)', 'ai')
+        .option('--limit <count>', 'Max visible lines/items to print in human mode')
+        .option('--interactive', 'Prefer interactive/ARIA-flavored snapshot output', false)
+        .option('--selector <selector>', 'Selector to scope the snapshot to')
+        .option('--frame <selector>', 'Frame selector for the snapshot')
+        .option('--compact', 'Compatibility flag', false)
+        .option('--depth <depth>', 'Compatibility flag')
+        .option('--efficient', 'Compatibility flag', false)
+        .option('--labels', 'Include labels when supported by backend', false)
+        .action(async function () {
+        await runBrowserCommand(this, 'snapshot', true, async (ctx, options) => ctx.snapshot({
+            format: String(options.format || 'ai'),
+            limit: options.limit ? parsePositiveInteger(String(options.limit), '--limit') : undefined,
+            interactive: Boolean(options.interactive),
+            selector: options.selector ? String(options.selector) : undefined,
+            frame: options.frame ? String(options.frame) : undefined,
+            compact: Boolean(options.compact),
+            depth: options.depth ? parsePositiveInteger(String(options.depth), '--depth') : undefined,
+            efficient: Boolean(options.efficient),
+            labels: Boolean(options.labels),
+        }));
+    });
+    browser
+        .command('screenshot')
+        .description('Capture a browser screenshot')
+        .option('--full-page', 'Request a full page screenshot when supported', false)
+        .option('--ref <ref>', 'Element ref/index')
+        .option('--output <path>', 'Write screenshot bytes to a file')
+        .option('--detail <level>', 'Screenshot detail level')
+        .option('--grayscale', 'Use grayscale when supported', false)
+        .action(async function () {
+        await runBrowserCommand(this, 'screenshot', true, async (ctx, options) => ctx.screenshot({
+            fullPage: Boolean(options.fullPage),
+            ref: options.ref ? String(options.ref) : undefined,
+            outputPath: options.output ? String(options.output) : undefined,
+            detail: options.detail ? String(options.detail) : undefined,
+            grayscale: Boolean(options.grayscale),
+        }));
+    });
+    browser
+        .command('pdf')
+        .description('Render the current page as PDF when supported')
+        .option('--output <path>', 'Write PDF bytes to a file')
+        .action(async function () {
+        await runBrowserCommand(this, 'pdf', true, async (ctx, options) => ctx.pdf(options.output ? String(options.output) : undefined));
+    });
+    browser
+        .command('console')
+        .description('List console messages')
+        .option('--level <level>', 'Console level filter')
+        .option('--preserve', 'Include preserved messages when supported', false)
+        .action(async function () {
+        await runBrowserCommand(this, 'console', true, async (ctx, options) => ctx.consoleMessages({
+            level: options.level ? String(options.level) : undefined,
+            preserve: Boolean(options.preserve),
+        }));
+    });
+    browser
+        .command('errors')
+        .description('List console errors')
+        .option('--clear', 'Compatibility flag', false)
+        .action(async function () {
+        await runBrowserCommand(this, 'errors', true, async (ctx) => ctx.consoleMessages({ level: 'error' }));
+    });
+    browser
+        .command('requests')
+        .description('List network requests')
+        .option('--filter <pattern>', 'Substring filter')
+        .option('--limit <count>', 'Maximum requests to print')
+        .option('--clear', 'Compatibility flag', false)
+        .action(async function () {
+        await runBrowserCommand(this, 'requests', true, async (ctx, options) => ctx.requests({
+            filter: options.filter ? String(options.filter) : undefined,
+            limit: options.limit ? parsePositiveInteger(String(options.limit), '--limit') : undefined,
+        }));
+    });
+    browser
+        .command('responsebody [pattern]')
+        .description('Show a matching response body when network inspection is available')
+        .option('--max-chars <count>', 'Truncate response body output')
+        .action(async function (pattern) {
+        await runBrowserCommand(this, 'responsebody', true, async (ctx, options) => ctx.responseBody({
+            pattern,
+            maxChars: options.maxChars
+                ? parsePositiveInteger(String(options.maxChars), '--max-chars')
+                : undefined,
+        }));
+    });
+    browser
+        .command('resize <width> <height>')
+        .description('Resize the browser viewport')
+        .action(async function (width, height) {
+        await runBrowserCommand(this, 'resize', true, async (ctx) => ctx.resize(parsePositiveInteger(width, 'width'), parsePositiveInteger(height, 'height')));
+    });
+    browser
+        .command('click <ref>')
+        .description('Click an element by ref/index')
+        .option('--double', 'Double click when supported', false)
+        .action(async function (ref) {
+        await runBrowserCommand(this, 'click', true, async (ctx, options) => ctx.click(ref, { double: Boolean(options.double) }));
+    });
+    browser
+        .command('type <ref> <text>')
+        .description('Type/fill text into an element')
+        .option('--submit', 'Submit after typing', false)
+        .action(async function (ref, text) {
+        await runBrowserCommand(this, 'type', true, async (ctx, options) => ctx.type(ref, text, { submit: Boolean(options.submit) }));
+    });
+    browser
+        .command('press <keys>')
+        .description('Press a key or key chord')
+        .action(async function (keys) {
+        await runBrowserCommand(this, 'press', true, async (ctx) => ctx.press(keys));
+    });
+    browser
+        .command('hover <ref>')
+        .description('Hover an element by ref/index')
+        .action(async function (ref) {
+        await runBrowserCommand(this, 'hover', true, async (ctx) => ctx.hover(ref));
+    });
+    browser
+        .command('scrollintoview <ref>')
+        .description('Scroll an element into view when supported')
+        .action(async function (ref) {
+        await runBrowserCommand(this, 'scrollintoview', true, async (ctx) => ctx.scrollIntoView(ref));
+    });
+    browser
+        .command('drag <source> <target>')
+        .description('Drag one element to another')
+        .action(async function (source, target) {
+        await runBrowserCommand(this, 'drag', true, async (ctx) => ctx.drag(source, target));
+    });
+    browser
+        .command('select <ref> <values...>')
+        .description('Select one or more values in a field')
+        .action(async function (ref, values) {
+        await runBrowserCommand(this, 'select', true, async (ctx) => ctx.select(ref, values));
+    });
+    browser
+        .command('download <ref> [filename]')
+        .description('Trigger/download an element when supported')
+        .action(async function (ref, filename) {
+        await runBrowserCommand(this, 'download', true, async (ctx) => ctx.download(ref, filename));
+    });
+    browser
+        .command('waitfordownload [filename]')
+        .description('Wait for a download when supported')
+        .action(async function (filename) {
+        await runBrowserCommand(this, 'waitfordownload', true, async (ctx) => ctx.waitForDownload(filename));
+    });
+    browser
+        .command('upload <path>')
+        .description('Upload a file when supported')
+        .option('--ref <ref>', 'Element ref/index')
+        .action(async function (path) {
+        await runBrowserCommand(this, 'upload', true, async (ctx, options) => ctx.upload(path, options.ref ? String(options.ref) : undefined));
+    });
+    browser
+        .command('fill')
+        .description('Fill a form using JSON field descriptors')
+        .requiredOption('--fields <json>', 'JSON array of field descriptors')
+        .action(async function () {
+        await runBrowserCommand(this, 'fill', true, async (ctx, options) => ctx.fillForm(String(options.fields)));
+    });
+    browser
+        .command('dialog')
+        .description('Accept or dismiss a browser dialog')
+        .option('--accept', 'Accept the dialog', false)
+        .option('--dismiss', 'Dismiss the dialog', false)
+        .option('--prompt <text>', 'Prompt text to enter')
+        .action(async function () {
+        await runBrowserCommand(this, 'dialog', true, async (ctx, options) => ctx.dialog({
+            accept: Boolean(options.accept),
+            dismiss: Boolean(options.dismiss),
+            prompt: options.prompt ? String(options.prompt) : undefined,
+        }));
+    });
+    browser
+        .command('wait')
+        .description('Wait for text or a short delay')
+        .option('--text <value...>', 'Texts to wait for')
+        .option('--seconds <seconds>', 'Wait for a fixed number of seconds')
+        .option('--timeout <ms>', 'Override command timeout')
+        .action(async function () {
+        await runBrowserCommand(this, 'wait', true, async (ctx, options, baseOptions) => ctx.wait({
+            text: Array.isArray(options.text) ? options.text.map(String) : undefined,
+            seconds: options.seconds ? Number(options.seconds) : undefined,
+            timeoutMs: options.timeout ? parsePositiveInteger(String(options.timeout), '--timeout') : parsePositiveInteger(baseOptions.timeout, '--timeout'),
+        }));
+    });
+    browser
+        .command('evaluate')
+        .description('Evaluate JavaScript through the browser tool backend')
+        .requiredOption('--fn <function>', 'Function to evaluate')
+        .option('--ref <ref>', 'Element ref/index argument')
+        .option('--args <json>', 'JSON array of additional arguments')
+        .action(async function () {
+        await runBrowserCommand(this, 'evaluate', true, async (ctx, options) => ctx.evaluate({
+            fn: String(options.fn),
+            ref: options.ref ? String(options.ref) : undefined,
+            argsJson: options.args ? String(options.args) : undefined,
+        }));
+    });
+    browser
+        .command('highlight <ref>')
+        .description('Highlight an element when supported')
+        .action(async function (ref) {
+        await runBrowserCommand(this, 'highlight', true, async (ctx) => ctx.highlight(ref));
+    });
+    const trace = browser.command('trace').description('Start/stop browser tracing');
+    trace
+        .command('start')
+        .description('Start a trace')
+        .option('--reload', 'Reload the page during trace start when supported', false)
+        .option('--output <path>', 'Trace output path')
+        .action(async function () {
+        await runBrowserCommand(this, 'trace start', true, async (ctx, options) => ctx.traceStart({
+            reload: Boolean(options.reload),
+            outputPath: options.output ? String(options.output) : undefined,
+        }));
+    });
+    trace
+        .command('stop')
+        .description('Stop an active trace')
+        .option('--output <path>', 'Trace output path')
+        .action(async function () {
+        await runBrowserCommand(this, 'trace stop', true, async (ctx, options) => ctx.traceStop(options.output ? String(options.output) : undefined));
+    });
+}
+async function runBrowserCommand(command, commandName, requireExtension, handler) {
+    const globalOptions = command.optsWithGlobals();
+    const localOptions = command.opts();
+    const ctx = new BrowserCliContext({
+        port: parsePositiveInteger(globalOptions.port, '--port'),
+        debug: Boolean(globalOptions.debug),
+        remoteUuid: globalOptions.remote,
+        relayUrl: globalOptions.relayUrl,
+        profile: globalOptions.browserProfile || DEFAULT_BROWSER_PROFILE,
+        json: Boolean(globalOptions.json),
+        timeoutMs: parsePositiveInteger(globalOptions.timeout, '--timeout'),
+        target: globalOptions.target,
+    });
+    try {
+        await ctx.connect();
+        if (requireExtension) {
+            await ctx.ensureExtensionConnected();
+        }
+        const output = await handler(ctx, localOptions, globalOptions);
+        emitOutput(Boolean(globalOptions.json), output, formatHumanOutput(commandName, output));
+    }
+    catch (error) {
+        emitError(Boolean(globalOptions.json), commandName, ctx, error);
+        process.exitCode = 1;
+    }
+    finally {
+        await ctx.shutdown();
+    }
+}
+class BrowserCliContext {
+    connection;
+    profile;
+    json;
+    timeoutMs;
+    remoteUuid;
+    target;
+    toolsLoaded = false;
+    tools = [];
+    ignoredCompatibilityOptions;
+    constructor(init) {
+        this.connection = new ExtensionConnection(init.port, init.debug, init.remoteUuid ? { uuid: init.remoteUuid, relayUrl: init.relayUrl } : undefined);
+        this.profile = init.profile;
+        this.json = init.json;
+        this.timeoutMs = init.timeoutMs;
+        this.remoteUuid = init.remoteUuid;
+        this.target = init.target;
+        this.ignoredCompatibilityOptions = [];
+        if (this.target) {
+            this.ignoredCompatibilityOptions.push(`target=${this.target}`);
+        }
+    }
+    async connect() {
+        await this.connection.start();
+        await delay(100);
+        await this.connection.waitForToolsUpdate(500);
+    }
+    async shutdown() {
+        await this.connection.stop();
+    }
+    async ensureExtensionConnected() {
+        if (this.connection.isExtensionConnected()) {
+            return;
+        }
+        await this.ensureToolsLoaded();
+        if (!this.connection.isExtensionConnected()) {
+            throw new Error('No browser extension is connected to the Vibe relay');
+        }
+    }
+    async status() {
+        if (this.connection.isExtensionConnected()) {
+            await this.ensureToolsLoaded();
+        }
+        return {
+            ok: true,
+            command: 'status',
+            profile: this.profile,
+            mode: this.remoteUuid ? 'remote' : 'local',
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            relayConnected: this.connection.getStatus() === 'connected',
+            extensionConnected: this.connection.isExtensionConnected(),
+            managedLifecycle: false,
+            transport: 'vibebrowser-mcp',
+            toolCount: this.tools.length,
+            tools: this.tools.map((tool) => tool.name),
+        };
+    }
+    async listPages() {
+        const invocation = await this.callTool('tabs', [
+            { names: ['list_pages', 'get_tabs'] },
+        ], {});
+        const pages = extractPages(invocation.result);
+        return {
+            ok: true,
+            command: 'tabs',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            pages,
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async open(url) {
+        if (!url) {
+            return this.callGenericCommand('open', [{ names: ['new_page', 'create_new_tab'] }], {});
+        }
+        const invocation = await this.callTool('open', [
+            {
+                names: ['new_page', 'create_new_tab'],
+                buildArgs: (tool) => withUrlArgs(tool, url),
+            },
+            {
+                names: ['navigate_page', 'navigate_to_url'],
+                buildArgs: (tool) => withNavigateArgs(tool, url),
+            },
+        ], {});
+        return this.outputFromInvocation('open', invocation);
+    }
+    async navigate(url) {
+        const invocation = await this.callTool('navigate', [
+            {
+                names: ['navigate_page', 'navigate_to_url'],
+                buildArgs: (tool) => withNavigateArgs(tool, url),
+            },
+            {
+                names: ['new_page', 'create_new_tab'],
+                buildArgs: (tool) => withUrlArgs(tool, url),
+            },
+        ], {});
+        return this.outputFromInvocation('navigate', invocation);
+    }
+    async focus(id) {
+        const invocation = await this.callTool('focus', [
+            {
+                names: ['select_page', 'switch_to_tab', 'focus_tab'],
+                buildArgs: (tool) => withPageArgs(tool, id),
+            },
+        ], {});
+        return this.outputFromInvocation('focus', invocation);
+    }
+    async close(id) {
+        const invocation = await this.callTool('close', [
+            {
+                names: ['close_page', 'close_tab'],
+                buildArgs: (tool) => withPageArgs(tool, id),
+            },
+        ], {});
+        return this.outputFromInvocation('close', invocation);
+    }
+    async snapshot(options) {
+        const wantsAria = options.format === 'aria' || options.interactive || Boolean(options.selector) || Boolean(options.frame);
+        if (!wantsAria) {
+            const result = await this.connection.getSnapshot();
+            return {
+                ok: true,
+                command: 'snapshot',
+                profile: this.profile,
+                mode: this.mode(),
+                ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+                format: options.format,
+                url: result.url,
+                title: result.title,
+                snapshot: limitText(result.snapshot, options.limit),
+            };
+        }
+        const invocation = await this.callTool('snapshot', [
+            {
+                names: ['take_a11y_snapshot'],
+                buildArgs: (tool) => withSnapshotArgs(tool, options),
+            },
+            {
+                names: ['take_snapshot', 'get_page_content'],
+                buildArgs: (tool) => withSnapshotArgs(tool, options),
+            },
+        ], {});
+        const text = firstText(invocation.result);
+        return {
+            ok: true,
+            command: 'snapshot',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            format: wantsAria ? 'aria' : options.format,
+            snapshot: limitText(text, options.limit),
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async screenshot(options) {
+        const invocation = await this.callTool('screenshot', [
+            {
+                names: ['take_screenshot', 'screenshot'],
+                buildArgs: (tool) => withScreenshotArgs(tool, options),
+            },
+        ], {});
+        const savedPath = maybeWriteBinaryOutput(invocation.result, options.outputPath);
+        return {
+            ok: true,
+            command: 'screenshot',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            outputPath: savedPath || options.outputPath,
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async pdf(outputPath) {
+        const invocation = await this.callTool('pdf', [{ names: ['pdf', 'generate_pdf'] }], {});
+        const savedPath = maybeWriteBinaryOutput(invocation.result, outputPath);
+        return {
+            ok: true,
+            command: 'pdf',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            outputPath: savedPath || outputPath,
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async consoleMessages(options) {
+        const invocation = await this.callTool('console', [
+            {
+                names: ['list_console_messages'],
+                buildArgs: (tool) => withConsoleArgs(tool, options),
+            },
+        ], {});
+        return {
+            ok: true,
+            command: options.level === 'error' ? 'errors' : 'console',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            messages: extractMessages(invocation.result),
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async requests(options) {
+        const invocation = await this.callTool('requests', [
+            {
+                names: ['list_network_requests'],
+                buildArgs: (tool) => withRequestListArgs(tool, options),
+            },
+        ], {});
+        let requests = extractRequests(invocation.result);
+        if (options.filter) {
+            const needle = options.filter.toLowerCase();
+            requests = requests.filter((request) => JSON.stringify(request).toLowerCase().includes(needle));
+        }
+        if (options.limit) {
+            requests = requests.slice(0, options.limit);
+        }
+        return {
+            ok: true,
+            command: 'requests',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            requests,
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async responseBody(options) {
+        const requests = await this.requests({ filter: options.pattern, limit: 1 });
+        const list = Array.isArray(requests.requests) ? requests.requests : [];
+        const first = list[0];
+        const requestId = first?.requestId ?? guessRequestId(requests.raw);
+        if (!requestId) {
+            throw new Error('No matching network request found');
+        }
+        const invocation = await this.callTool('responsebody', [
+            {
+                names: ['get_network_request'],
+                buildArgs: (tool) => withRequestDetailsArgs(tool, requestId),
+            },
+        ], {});
+        const body = limitText(extractResponseBody(invocation.result), options.maxChars);
+        return {
+            ok: true,
+            command: 'responsebody',
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            requestId,
+            tool: invocation.tool,
+            responseBody: body,
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    async resize(width, height) {
+        const invocation = await this.callTool('resize', [
+            {
+                names: ['resize_page'],
+                buildArgs: (tool) => withResizeArgs(tool, width, height),
+            },
+        ], {});
+        return this.outputFromInvocation('resize', invocation);
+    }
+    async click(ref, options) {
+        const invocation = await this.callTool('click', [
+            {
+                names: ['click'],
+                buildArgs: (tool) => withRefArgs(tool, ref, { dblClick: options.double }),
+            },
+        ], {});
+        return this.outputFromInvocation('click', invocation);
+    }
+    async type(ref, text, options) {
+        const invocation = await this.callTool('type', [
+            {
+                names: ['fill'],
+                buildArgs: (tool) => withFillArgs(tool, ref, text),
+            },
+            {
+                names: ['type_text', 'type'],
+                buildArgs: (tool) => withTypeArgs(tool, text, options.submit ? 'Enter' : undefined),
+            },
+        ], {});
+        return this.outputFromInvocation('type', invocation);
+    }
+    async press(keys) {
+        const invocation = await this.callTool('press', [
+            {
+                names: ['press_key', 'keyboard_shortcut'],
+                buildArgs: (tool) => withKeysArgs(tool, keys),
+            },
+        ], {});
+        return this.outputFromInvocation('press', invocation);
+    }
+    async hover(ref) {
+        const invocation = await this.callTool('hover', [
+            {
+                names: ['hover'],
+                buildArgs: (tool) => withRefArgs(tool, ref),
+            },
+        ], {});
+        return this.outputFromInvocation('hover', invocation);
+    }
+    async scrollIntoView(ref) {
+        const invocation = await this.callTool('scrollintoview', [
+            {
+                names: ['scroll_into_view', 'scrollintoview'],
+                buildArgs: (tool) => withRefArgs(tool, ref),
+            },
+        ], {});
+        return this.outputFromInvocation('scrollintoview', invocation);
+    }
+    async drag(source, target) {
+        const invocation = await this.callTool('drag', [
+            {
+                names: ['drag'],
+                buildArgs: (tool) => withDragArgs(tool, source, target),
+            },
+        ], {});
+        return this.outputFromInvocation('drag', invocation);
+    }
+    async select(ref, values) {
+        const invocation = await this.callTool('select', [
+            {
+                names: ['fill'],
+                buildArgs: (tool) => withFillArgs(tool, ref, values.length === 1 ? values[0] : values),
+            },
+            {
+                names: ['select_option', 'select'],
+                buildArgs: (tool) => withSelectArgs(tool, ref, values),
+            },
+        ], {});
+        return this.outputFromInvocation('select', invocation);
+    }
+    async download(ref, filename) {
+        const invocation = await this.callTool('download', [
+            {
+                names: ['download'],
+                buildArgs: (tool) => withDownloadArgs(tool, ref, filename),
+            },
+            {
+                names: ['click'],
+                buildArgs: (tool) => withRefArgs(tool, ref),
+            },
+        ], {});
+        return this.outputFromInvocation('download', invocation);
+    }
+    async waitForDownload(filename) {
+        const invocation = await this.callTool('waitfordownload', [
+            {
+                names: ['wait_for_download', 'waitfordownload'],
+                buildArgs: (tool) => withFilenameArgs(tool, filename),
+            },
+        ], {});
+        return this.outputFromInvocation('waitfordownload', invocation);
+    }
+    async upload(path, ref) {
+        const invocation = await this.callTool('upload', [
+            {
+                names: ['upload_file'],
+                buildArgs: (tool) => withUploadArgs(tool, path, ref),
+            },
+        ], {});
+        return this.outputFromInvocation('upload', invocation);
+    }
+    async fillForm(fieldsJson) {
+        const fields = parseJsonValue(fieldsJson, '--fields');
+        if (!Array.isArray(fields)) {
+            throw new Error('--fields must be a JSON array');
+        }
+        const invocation = await this.callTool('fill', [
+            {
+                names: ['fill_form'],
+                buildArgs: (tool) => withFillFormArgs(tool, fields),
+            },
+        ], {});
+        return this.outputFromInvocation('fill', invocation);
+    }
+    async dialog(options) {
+        const action = options.accept ? 'accept' : options.dismiss ? 'dismiss' : 'accept';
+        const invocation = await this.callTool('dialog', [
+            {
+                names: ['handle_dialog'],
+                buildArgs: (tool) => withDialogArgs(tool, action, options.prompt),
+            },
+        ], {});
+        return this.outputFromInvocation('dialog', invocation);
+    }
+    async wait(options) {
+        if (options.text && options.text.length > 0) {
+            const invocation = await this.callTool('wait', [
+                {
+                    names: ['wait_for'],
+                    buildArgs: (tool) => withWaitArgs(tool, options.text, options.timeoutMs),
+                },
+            ], {});
+            return this.outputFromInvocation('wait', invocation);
+        }
+        if (typeof options.seconds === 'number' && Number.isFinite(options.seconds) && options.seconds >= 0) {
+            await delay(Math.round(options.seconds * 1000));
+            return {
+                ok: true,
+                command: 'wait',
+                profile: this.profile,
+                mode: this.mode(),
+                ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+                waitedSeconds: options.seconds,
+            };
+        }
+        throw new Error('wait requires either --text or --seconds');
+    }
+    async evaluate(options) {
+        const invocation = await this.callTool('evaluate', [
+            {
+                names: ['evaluate_script'],
+                buildArgs: (tool) => withEvaluateArgs(tool, options.fn, options.ref, options.argsJson),
+            },
+        ], {});
+        return this.outputFromInvocation('evaluate', invocation);
+    }
+    async highlight(ref) {
+        const invocation = await this.callTool('highlight', [
+            {
+                names: ['highlight'],
+                buildArgs: (tool) => withRefArgs(tool, ref),
+            },
+            {
+                names: ['hover'],
+                buildArgs: (tool) => withRefArgs(tool, ref, { duration: 1500 }),
+            },
+        ], {});
+        return this.outputFromInvocation('highlight', invocation);
+    }
+    async traceStart(options) {
+        const invocation = await this.callTool('trace start', [
+            {
+                names: ['performance_start_trace'],
+                buildArgs: (tool) => withTraceStartArgs(tool, options),
+            },
+        ], {});
+        return this.outputFromInvocation('trace start', invocation);
+    }
+    async traceStop(outputPath) {
+        const invocation = await this.callTool('trace stop', [
+            {
+                names: ['performance_stop_trace'],
+                buildArgs: (tool) => withTraceStopArgs(tool, outputPath),
+            },
+        ], {});
+        return this.outputFromInvocation('trace stop', invocation);
+    }
+    async callGenericCommand(commandName, candidates, canonicalArgs) {
+        const invocation = await this.callTool(commandName, candidates, canonicalArgs);
+        return this.outputFromInvocation(commandName, invocation);
+    }
+    async callTool(commandName, candidates, canonicalArgs) {
+        await this.ensureToolsLoaded();
+        const available = new Map(this.tools.map((tool) => [normalizeName(tool.name), tool]));
+        for (const candidate of candidates) {
+            for (const candidateName of candidate.names) {
+                const tool = available.get(normalizeName(candidateName));
+                if (!tool) {
+                    continue;
+                }
+                const args = candidate.buildArgs
+                    ? candidate.buildArgs(tool)
+                    : withCanonicalArgs(tool, canonicalArgs);
+                const result = await this.connection.callTool(tool.name, args);
+                return { tool: tool.name, args, result: result };
+            }
+        }
+        const requested = candidates.flatMap((candidate) => candidate.names);
+        throw new Error(`No compatible browser tool found for "${commandName}". Tried ${requested.join(', ')}. Available tools: ${this.tools.map((tool) => tool.name).join(', ')}`);
+    }
+    async ensureToolsLoaded() {
+        if (this.toolsLoaded && this.tools.length > 0) {
+            return;
+        }
+        if (this.connection.isExtensionConnected()) {
+            try {
+                this.tools = await this.connection.refreshTools(this.timeoutMs);
+            }
+            catch {
+                this.tools = await this.connection.waitForToolsUpdate(1_000);
+            }
+        }
+        else {
+            this.tools = this.connection.getTools();
+        }
+        this.toolsLoaded = true;
+    }
+    outputFromInvocation(commandName, invocation) {
+        return {
+            ok: !invocation.result.isError,
+            command: commandName,
+            profile: this.profile,
+            mode: this.mode(),
+            ignoredCompatibilityOptions: this.ignoredCompatibilityOptions,
+            tool: invocation.tool,
+            raw: normalizeToolResult(invocation.result),
+        };
+    }
+    mode() {
+        return this.remoteUuid ? 'remote' : 'local';
+    }
+}
+function emitOutput(asJson, data, humanOutput) {
+    if (asJson) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(humanOutput);
+}
+function emitError(asJson, commandName, ctx, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (asJson) {
+        console.log(JSON.stringify({
+            ok: false,
+            command: commandName,
+            profile: DEFAULT_BROWSER_PROFILE,
+            mode: 'local',
+            error: message,
+        }, null, 2));
+        return;
+    }
+    console.error(`Error: ${message}`);
+}
+function formatHumanOutput(commandName, output) {
+    switch (commandName) {
+        case 'status':
+        case 'start':
+        case 'stop':
+            return [
+                `Profile: ${String(output.profile)}`,
+                `Mode: ${String(output.mode)}`,
+                `Relay connected: ${boolText(output.relayConnected)}`,
+                `Extension connected: ${boolText(output.extensionConnected)}`,
+                `Managed lifecycle: ${boolText(output.managedLifecycle)}`,
+                output.toolCount !== undefined ? `Tools: ${String(output.toolCount)}` : null,
+                output.note ? String(output.note) : null,
+            ].filter(Boolean).join('\n');
+        case 'tabs':
+        case 'tab': {
+            const pages = Array.isArray(output.pages) ? output.pages : [];
+            if (pages.length === 0) {
+                return firstDefinedText(output.raw, 'No tabs reported by browser');
+            }
+            return pages.map((page, index) => `${index + 1}. ${page.active ? '[active] ' : ''}${page.title || '(untitled)'}${page.url ? ` — ${page.url}` : ''}${page.id !== undefined ? ` [id=${page.id}]` : ''}`).join('\n');
+        }
+        case 'snapshot':
+            return [
+                output.title ? `Title: ${String(output.title)}` : null,
+                output.url ? `URL: ${String(output.url)}` : null,
+                output.snapshot ? String(output.snapshot) : firstDefinedText(output.raw, ''),
+            ].filter(Boolean).join('\n');
+        case 'requests': {
+            const requests = Array.isArray(output.requests) ? output.requests : [];
+            if (requests.length === 0) {
+                return firstDefinedText(output.raw, 'No requests reported by browser');
+            }
+            return requests.map((request, index) => `${index + 1}. ${request.method || 'GET'} ${request.url || '(unknown)'}${request.status !== undefined ? ` [${request.status}]` : ''}${request.requestId ? ` [id=${request.requestId}]` : ''}`).join('\n');
+        }
+        case 'console':
+        case 'errors': {
+            const messages = Array.isArray(output.messages) ? output.messages : [];
+            if (messages.length > 0) {
+                return messages.map((message) => stringifyJson(message)).join('\n');
+            }
+            return firstDefinedText(output.raw, 'No console messages reported by browser');
+        }
+        case 'responsebody':
+            return String(output.responseBody ?? firstDefinedText(output.raw, ''));
+        default:
+            if (output.outputPath) {
+                return `Saved to ${String(output.outputPath)}`;
+            }
+            return firstDefinedText(output.raw, JSON.stringify(output, null, 2));
+    }
+}
+function boolText(value) {
+    return value ? 'yes' : 'no';
+}
+function firstDefinedText(value, fallback) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (value && typeof value === 'object' && 'text' in value && typeof value.text === 'string') {
+        return value.text;
+    }
+    return fallback;
+}
+function normalizeToolResult(result) {
+    return sanitizeUnknown(result) ?? null;
+}
+function sanitizeUnknown(value) {
+    if (value === null)
+        return null;
+    if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => sanitizeUnknown(item) ?? null);
+    if (value && typeof value === 'object') {
+        const output = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const sanitized = sanitizeUnknown(entry);
+            if (sanitized !== undefined) {
+                output[key] = sanitized;
+            }
+        }
+        return output;
+    }
+    return undefined;
+}
+function maybeWriteBinaryOutput(result, outputPath) {
+    if (!outputPath) {
+        return undefined;
+    }
+    const image = result.content?.find((item) => item.type === 'image');
+    if (!image || !('data' in image) || typeof image.data !== 'string') {
+        return undefined;
+    }
+    const target = resolve(outputPath);
+    writeFileSync(target, Buffer.from(image.data, 'base64'));
+    return target;
+}
+function extractPages(result) {
+    const direct = extractStructured(result, ['pages', 'tabs', 'targets']);
+    if (Array.isArray(direct)) {
+        return direct.map((entry) => normalizePage(entry));
+    }
+    const parsed = parseResultText(result);
+    if (Array.isArray(parsed)) {
+        return parsed.map((entry) => normalizePage(entry));
+    }
+    if (parsed && typeof parsed === 'object') {
+        for (const key of ['pages', 'tabs', 'targets']) {
+            const candidate = parsed[key];
+            if (Array.isArray(candidate)) {
+                return candidate.map((entry) => normalizePage(entry));
+            }
+        }
+    }
+    return [];
+}
+function normalizePage(value) {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    const record = value;
+    return {
+        ...sanitizeUnknown(record),
+        id: firstDefined(record, ['pageId', 'tabId', 'id', 'targetId']),
+        title: firstString(record, ['title', 'name']),
+        url: firstString(record, ['url']),
+        active: firstBoolean(record, ['active', 'selected', 'focused']),
+    };
+}
+function extractRequests(result) {
+    const direct = extractStructured(result, ['requests']);
+    if (Array.isArray(direct)) {
+        return direct.map((entry) => normalizeRequest(entry));
+    }
+    const parsed = parseResultText(result);
+    if (Array.isArray(parsed)) {
+        return parsed.map((entry) => normalizeRequest(entry));
+    }
+    if (parsed && typeof parsed === 'object') {
+        const requests = parsed.requests;
+        if (Array.isArray(requests)) {
+            return requests.map((entry) => normalizeRequest(entry));
+        }
+    }
+    return [];
+}
+function normalizeRequest(value) {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    const record = value;
+    return {
+        ...sanitizeUnknown(record),
+        requestId: firstString(record, ['requestId', 'reqid', 'id']),
+        url: firstString(record, ['url']),
+        method: firstString(record, ['method']),
+        status: firstNumber(record, ['status']),
+    };
+}
+function extractMessages(result) {
+    const direct = extractStructured(result, ['messages', 'consoleMessages']);
+    if (Array.isArray(direct)) {
+        return direct.map((entry) => sanitizeUnknown(entry) ?? null);
+    }
+    const parsed = parseResultText(result);
+    if (Array.isArray(parsed)) {
+        return parsed.map((entry) => sanitizeUnknown(entry) ?? null);
+    }
+    if (parsed && typeof parsed === 'object') {
+        for (const key of ['messages', 'consoleMessages']) {
+            const candidate = parsed[key];
+            if (Array.isArray(candidate)) {
+                return candidate.map((entry) => sanitizeUnknown(entry) ?? null);
+            }
+        }
+    }
+    const text = firstText(result);
+    return text ? [text] : [];
+}
+function extractResponseBody(result) {
+    const direct = extractStructured(result, ['responseBody', 'body']);
+    if (typeof direct === 'string') {
+        return direct;
+    }
+    const parsed = parseResultText(result);
+    if (parsed && typeof parsed === 'object') {
+        for (const key of ['responseBody', 'body']) {
+            const candidate = parsed[key];
+            if (typeof candidate === 'string') {
+                return candidate;
+            }
+        }
+    }
+    return firstText(result);
+}
+function guessRequestId(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const record = value;
+    if (typeof record.requestId === 'string') {
+        return record.requestId;
+    }
+    return undefined;
+}
+function extractStructured(result, keys) {
+    for (const key of keys) {
+        if (key in result) {
+            return result[key];
+        }
+    }
+    return undefined;
+}
+function parseResultText(result) {
+    const text = firstText(result);
+    if (!text) {
+        return undefined;
+    }
+    return parseJsonText(text);
+}
+function firstText(result) {
+    const item = result.content?.find((entry) => entry.type === 'text');
+    return item && 'text' in item && typeof item.text === 'string' ? item.text : '';
+}
+function parseJsonText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const candidates = [trimmed];
+    if (trimmed.startsWith('```')) {
+        const fenced = trimmed
+            .replace(/^```[a-zA-Z0-9_-]*\n/, '')
+            .replace(/\n```$/, '')
+            .trim();
+        candidates.push(fenced);
+    }
+    for (const candidate of candidates) {
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    return undefined;
+}
+function parseJsonValue(text, label) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${label} must be valid JSON: ${message}`);
+    }
+}
+function stringifyJson(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+}
+function limitText(text, limit) {
+    if (!limit || limit <= 0) {
+        return text;
+    }
+    const lines = text.split('\n');
+    return lines.length <= limit ? text : `${lines.slice(0, limit).join('\n')}\n...`;
+}
+function parsePositiveInteger(value, label) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+    return parsed;
+}
+function normalizeName(value) {
+    return value.replace(/[-\s]/g, '_').toLowerCase();
+}
+function toolProperties(tool) {
+    return tool.inputSchema.properties ?? {};
+}
+function hasProperty(tool, ...names) {
+    const properties = toolProperties(tool);
+    return names.find((name) => Object.prototype.hasOwnProperty.call(properties, name));
+}
+function withCanonicalArgs(tool, canonicalArgs) {
+    const output = {};
+    for (const [key, value] of Object.entries(canonicalArgs)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(toolProperties(tool), key)) {
+            output[key] = value;
+        }
+    }
+    return output;
+}
+function withUrlArgs(tool, url) {
+    const args = {};
+    const urlKey = hasProperty(tool, 'url');
+    if (urlKey)
+        args[urlKey] = url;
+    const typeKey = hasProperty(tool, 'type');
+    if (typeKey && normalizeName(tool.name) === 'navigate_page') {
+        args[typeKey] = 'url';
+    }
+    return args;
+}
+function withNavigateArgs(tool, url) {
+    const args = withUrlArgs(tool, url);
+    const pageIdKey = hasProperty(tool, 'pageId', 'tabId');
+    if (pageIdKey && !(pageIdKey in args)) {
+        args[pageIdKey] = undefined;
+    }
+    return stripUndefined(args);
+}
+function withPageArgs(tool, id) {
+    const args = {};
+    const numeric = Number.parseInt(id, 10);
+    const key = hasProperty(tool, 'pageId', 'tabId', 'id');
+    if (key) {
+        args[key] = Number.isFinite(numeric) && String(numeric) === id ? numeric : id;
+    }
+    return args;
+}
+function withSnapshotArgs(tool, options) {
+    const args = {};
+    maybeAssign(args, tool, 'format', options.format);
+    maybeAssign(args, tool, 'selector', options.selector);
+    maybeAssign(args, tool, 'frame', options.frame);
+    maybeAssign(args, tool, 'compact', options.compact || undefined);
+    maybeAssign(args, tool, 'depth', options.depth);
+    maybeAssign(args, tool, 'efficient', options.efficient || undefined);
+    maybeAssign(args, tool, 'labels', options.labels || undefined);
+    maybeAssign(args, tool, 'a11y', true);
+    maybeAssign(args, tool, 'markdown', false);
+    return args;
+}
+function withScreenshotArgs(tool, options) {
+    const args = {};
+    if (options.ref) {
+        Object.assign(args, withRefArgs(tool, options.ref));
+    }
+    maybeAssign(args, tool, 'fullPage', options.fullPage || undefined);
+    maybeAssign(args, tool, 'detail', options.detail);
+    maybeAssign(args, tool, 'grayscale', options.grayscale || undefined);
+    return args;
+}
+function withConsoleArgs(tool, options) {
+    const args = {};
+    if (options.level) {
+        if (hasProperty(tool, 'types')) {
+            args.types = [options.level];
+        }
+        else {
+            maybeAssign(args, tool, 'level', options.level);
+        }
+    }
+    if (options.preserve) {
+        maybeAssign(args, tool, 'includePreservedMessages', true);
+    }
+    return args;
+}
+function withRequestListArgs(tool, options) {
+    const args = {};
+    if (options.limit) {
+        maybeAssign(args, tool, 'limit', options.limit);
+        maybeAssign(args, tool, 'pageSize', options.limit);
+    }
+    return args;
+}
+function withRequestDetailsArgs(tool, requestId) {
+    const args = {};
+    maybeAssign(args, tool, 'requestId', requestId);
+    maybeAssign(args, tool, 'reqid', requestId);
+    return args;
+}
+function withResizeArgs(tool, width, height) {
+    const args = {};
+    maybeAssign(args, tool, 'width', width);
+    maybeAssign(args, tool, 'height', height);
+    return args;
+}
+function withRefArgs(tool, ref, extra = {}) {
+    const args = { ...extra };
+    const parsedRef = parseRef(ref);
+    if (hasProperty(tool, 'ref')) {
+        args.ref = parsedRef.raw;
+    }
+    if (parsedRef.numeric !== undefined && hasProperty(tool, 'index')) {
+        args.index = parsedRef.numeric;
+    }
+    if (hasProperty(tool, 'uid')) {
+        args.uid = parsedRef.raw;
+    }
+    if (hasProperty(tool, 'selector')) {
+        args.selector = parsedRef.raw;
+    }
+    return args;
+}
+function withFillArgs(tool, ref, value) {
+    const args = withRefArgs(tool, ref);
+    if (hasProperty(tool, 'value')) {
+        args.value = Array.isArray(value) ? value[0] : value;
+    }
+    if (hasProperty(tool, 'text')) {
+        args.text = Array.isArray(value) ? value.join(' ') : value;
+    }
+    return args;
+}
+function withTypeArgs(tool, text, submitKey) {
+    const args = {};
+    maybeAssign(args, tool, 'text', text);
+    maybeAssign(args, tool, 'value', text);
+    if (submitKey) {
+        maybeAssign(args, tool, 'submitKey', submitKey);
+    }
+    return args;
+}
+function withKeysArgs(tool, keys) {
+    const args = {};
+    maybeAssign(args, tool, 'keys', keys);
+    maybeAssign(args, tool, 'shortcut', keys);
+    maybeAssign(args, tool, 'key', keys);
+    return args;
+}
+function withDragArgs(tool, source, target) {
+    const args = {};
+    if (hasProperty(tool, 'source')) {
+        args.source = source;
+    }
+    if (hasProperty(tool, 'target')) {
+        args.target = target;
+    }
+    if (hasProperty(tool, 'from_uid')) {
+        args.from_uid = source;
+    }
+    if (hasProperty(tool, 'to_uid')) {
+        args.to_uid = target;
+    }
+    return args;
+}
+function withSelectArgs(tool, ref, values) {
+    const args = withRefArgs(tool, ref);
+    maybeAssign(args, tool, 'value', values.length === 1 ? values[0] : values);
+    maybeAssign(args, tool, 'values', values);
+    return args;
+}
+function withDownloadArgs(tool, ref, filename) {
+    const args = withRefArgs(tool, ref);
+    maybeAssign(args, tool, 'filename', filename);
+    maybeAssign(args, tool, 'path', filename);
+    return args;
+}
+function withFilenameArgs(tool, filename) {
+    const args = {};
+    maybeAssign(args, tool, 'filename', filename);
+    maybeAssign(args, tool, 'path', filename);
+    return args;
+}
+function withUploadArgs(tool, path, ref) {
+    const args = {};
+    maybeAssign(args, tool, 'filePath', resolve(path));
+    if (ref) {
+        Object.assign(args, withRefArgs(tool, ref));
+    }
+    return args;
+}
+function withFillFormArgs(tool, fields) {
+    const args = {};
+    maybeAssign(args, tool, 'fields', fields);
+    maybeAssign(args, tool, 'elements', fields);
+    return args;
+}
+function withDialogArgs(tool, action, prompt) {
+    const args = {};
+    maybeAssign(args, tool, 'action', action);
+    maybeAssign(args, tool, 'promptText', prompt);
+    return args;
+}
+function withWaitArgs(tool, text, timeoutMs) {
+    const args = {};
+    maybeAssign(args, tool, 'text', text);
+    maybeAssign(args, tool, 'timeout', timeoutMs);
+    return args;
+}
+function withEvaluateArgs(tool, fn, ref, argsJson) {
+    const args = {};
+    maybeAssign(args, tool, 'function', fn);
+    const values = [];
+    if (ref) {
+        values.push(ref);
+    }
+    if (argsJson) {
+        const parsed = parseJsonValue(argsJson, '--args');
+        if (!Array.isArray(parsed)) {
+            throw new Error('--args must be a JSON array');
+        }
+        for (const entry of parsed) {
+            values.push(typeof entry === 'string' ? entry : JSON.stringify(entry));
+        }
+    }
+    if (values.length > 0) {
+        maybeAssign(args, tool, 'args', values);
+    }
+    return args;
+}
+function withTraceStartArgs(tool, options) {
+    const args = {};
+    maybeAssign(args, tool, 'reload', options.reload || undefined);
+    if (options.outputPath) {
+        maybeAssign(args, tool, 'filePath', resolve(options.outputPath));
+    }
+    return args;
+}
+function withTraceStopArgs(tool, outputPath) {
+    const args = {};
+    if (outputPath) {
+        maybeAssign(args, tool, 'filePath', resolve(outputPath));
+    }
+    return args;
+}
+function maybeAssign(target, tool, property, value) {
+    if (value === undefined) {
+        return;
+    }
+    if (hasProperty(tool, property)) {
+        target[property] = value;
+    }
+}
+function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function parseRef(ref) {
+    const numeric = Number.parseInt(ref, 10);
+    return {
+        raw: ref,
+        numeric: Number.isFinite(numeric) && String(numeric) === ref ? numeric : undefined,
+    };
+}
+function firstDefined(record, keys) {
+    for (const key of keys) {
+        if (record[key] !== undefined) {
+            return record[key];
+        }
+    }
+    return undefined;
+}
+function firstString(record, keys) {
+    const value = firstDefined(record, keys);
+    return typeof value === 'string' ? value : undefined;
+}
+function firstBoolean(record, keys) {
+    const value = firstDefined(record, keys);
+    return typeof value === 'boolean' ? value : undefined;
+}
+function firstNumber(record, keys) {
+    const value = firstDefined(record, keys);
+    return typeof value === 'number' ? value : undefined;
+}
+//# sourceMappingURL=browser-cli.js.map