@_nazmiforreal/agent-browser-mcp 0.2.0

package/dist/tools/executor.js

@@ -0,0 +1,1067 @@
+import { spawn } from "child_process";
+import { discoverActiveBrowser } from "../browsers/discover.js";
+const AGENT_BROWSER_PATH = process.env.AGENT_BROWSER_PATH || "agent-browser";
+let cachedBrowserPath = undefined;
+function getExecutablePath() {
+    if (cachedBrowserPath !== undefined)
+        return cachedBrowserPath;
+    const envPath = process.env.AGENT_BROWSER_EXECUTABLE_PATH;
+    if (envPath) {
+        cachedBrowserPath = envPath;
+        return envPath;
+    }
+    const active = discoverActiveBrowser();
+    if (active) {
+        cachedBrowserPath = active.path;
+        process.env.AGENT_BROWSER_EXECUTABLE_PATH = active.path;
+        return active.path;
+    }
+    cachedBrowserPath = null;
+    return null;
+}
+/**
+ * Command mapping from MCP tool names to agent-browser CLI commands.
+ * The agent-browser CLI uses positional arguments.
+ */
+const COMMAND_MAP = {
+    // Navigation
+    navigate: "open",
+    goto: "goto",
+    pushstate: "pushstate",
+    go_back: "back",
+    go_forward: "forward",
+    reload: "reload",
+    // Core Actions
+    click: "click",
+    dblclick: "dblclick",
+    fill: "fill",
+    type: "type",
+    hover: "hover",
+    focus: "focus",
+    check: "check",
+    uncheck: "uncheck",
+    select: "select",
+    drag: "drag",
+    upload: "upload",
+    download: "download",
+    tap: "tap",
+    swipe: "swipe",
+    // Keyboard
+    press: "press",
+    keydown: "keydown",
+    keyup: "keyup",
+    keyboard_type: "keyboard type",
+    keyboard_inserttext: "keyboard inserttext",
+    // Mouse
+    mouse_move: "mouse move",
+    mouse_down: "mouse down",
+    mouse_up: "mouse up",
+    mouse_wheel: "mouse wheel",
+    // Scroll
+    scroll: "scroll",
+    scroll_into_view: "scrollintoview",
+    // Get Info
+    get_text: "get text",
+    get_html: "get html",
+    get_value: "get value",
+    get_attribute: "get attr",
+    get_url: "get url",
+    get_title: "get title",
+    get_cdp_url: "get cdp-url",
+    get_count: "get count",
+    get_bounding_box: "get box",
+    get_styles: "get styles",
+    // State Checks
+    is_visible: "is visible",
+    is_enabled: "is enabled",
+    is_checked: "is checked",
+    // Find (Locators)
+    find_role: "find role",
+    find_text: "find text",
+    find_label: "find label",
+    find_placeholder: "find placeholder",
+    find_alt: "find alt",
+    find_title: "find title",
+    find_testid: "find testid",
+    find_first: "find first",
+    find_last: "find last",
+    find_nth: "find nth",
+    // Wait
+    wait: "wait",
+    wait_for_selector: "wait",
+    wait_for_url: "wait",
+    wait_for_load_state: "wait",
+    wait_for_function: "wait",
+    wait_for_text: "wait",
+    wait_for_download: "wait",
+    // Screenshot/PDF
+    screenshot: "screenshot",
+    pdf: "pdf",
+    // Snapshot
+    snapshot: "snapshot",
+    // Eval
+    evaluate: "eval",
+    evaluate_base64: "eval -b",
+    // Batch
+    batch: "batch",
+    // Clipboard
+    clipboard_read: "clipboard read",
+    clipboard_write: "clipboard write",
+    clipboard_copy: "clipboard copy",
+    clipboard_paste: "clipboard paste",
+    // Settings
+    set_viewport: "set viewport",
+    set_device: "set device",
+    set_geolocation: "set geo",
+    set_offline: "set offline",
+    set_headers: "set headers",
+    set_credentials: "set credentials",
+    set_media: "set media",
+    // Cookies
+    get_cookies: "cookies",
+    set_cookie: "cookies set",
+    set_cookies_from_file: "cookies set --curl",
+    clear_cookies: "cookies clear",
+    // Storage
+    storage_get_local: "storage local get",
+    storage_get_session: "storage session get",
+    storage_set_local: "storage local set",
+    storage_set_session: "storage session set",
+    storage_clear_local: "storage local clear",
+    storage_clear_session: "storage session clear",
+    // Network
+    network_route: "network route",
+    network_unroute: "network unroute",
+    network_requests: "network requests",
+    network_request_detail: "network request",
+    network_har_start: "network har start",
+    network_har_stop: "network har stop",
+    // Tabs
+    tab_list: "tab list",
+    tab_new: "tab new",
+    tab_switch: "tab",
+    tab_close: "tab close",
+    window_new: "window new",
+    // Frames
+    frame_switch: "frame",
+    frame_main: "frame main",
+    // Dialogs
+    dialog_accept: "dialog accept",
+    dialog_dismiss: "dialog dismiss",
+    dialog_status: "dialog status",
+    // Debug
+    trace_start: "trace start",
+    trace_stop: "trace stop",
+    profiler_start: "profiler start",
+    profiler_stop: "profiler stop",
+    get_console: "console",
+    get_errors: "errors",
+    highlight: "highlight",
+    inspect: "inspect",
+    // State Management
+    state_save: "state save",
+    state_load: "state load",
+    state_list: "state list",
+    state_show: "state show",
+    state_rename: "state rename",
+    state_clear: "state clear",
+    state_clean: "state clean",
+    // Recording
+    record_start: "record start",
+    record_stop: "record stop",
+    record_restart: "record restart",
+    // Auth Vault
+    auth_save: "auth save",
+    auth_login: "auth login",
+    auth_list: "auth list",
+    auth_delete: "auth delete",
+    auth_show: "auth show",
+    // Diff
+    diff_snapshot: "diff snapshot",
+    diff_screenshot: "diff screenshot",
+    diff_url: "diff url",
+    // React
+    react_tree: "react tree",
+    react_inspect: "react inspect",
+    react_renders_start: "react renders start",
+    react_renders_stop: "react renders stop",
+    react_suspense: "react suspense",
+    // Vitals
+    vitals: "vitals",
+    // Init Scripts
+    remove_init_script: "removeinitscript",
+    // Session
+    session_show: "session",
+    session_list: "session list",
+    // Streaming
+    stream_enable: "stream enable",
+    stream_disable: "stream disable",
+    stream_status: "stream status",
+    // Dashboard
+    dashboard_start: "dashboard start",
+    dashboard_stop: "dashboard stop",
+    // iOS
+    device_list: "device list",
+    // Confirm/Deny
+    confirm_action: "confirm",
+    deny_action: "deny",
+    // Connect CDP
+    connect: "connect",
+    // Session management (MCP-specific)
+    close_session: "close",
+    new_session: "session",
+    // Legacy/compat aliases
+    set_cookies: "cookies set",
+    wait_for_navigation: "wait",
+    get_network: "network requests",
+};
+/**
+ * Helper to check if a value is defined and non-empty for required args.
+ */
+function isDefined(value) {
+    return value !== undefined && value !== null && value !== "";
+}
+/**
+ * Build positional arguments for each command based on agent-browser CLI syntax.
+ */
+function buildPositionalArgs(command, options) {
+    const args = [];
+    switch (command) {
+        // Navigation: open <url>
+        case "navigate":
+        case "goto":
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        case "pushstate":
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        // Simple selector commands
+        case "click":
+        case "dblclick":
+        case "hover":
+        case "focus":
+        case "check":
+        case "uncheck":
+        case "tap":
+        case "highlight":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            break;
+        // Selector + value
+        case "fill":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (options.value !== undefined && options.value !== null) {
+                args.push(String(options.value));
+            }
+            break;
+        case "type":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (options.text !== undefined && options.text !== null) {
+                args.push(String(options.text));
+            }
+            break;
+        // Press: press <key>
+        case "press":
+        case "keydown":
+        case "keyup":
+            if (isDefined(options.key))
+                args.push(String(options.key));
+            break;
+        // Keyboard subactions
+        case "keyboard_type":
+            if (options.text !== undefined && options.text !== null) {
+                args.push(String(options.text));
+            }
+            break;
+        case "keyboard_inserttext":
+            if (options.text !== undefined && options.text !== null) {
+                args.push(String(options.text));
+            }
+            break;
+        // Scroll: scroll [direction] [amount] [--selector]
+        case "scroll":
+            if (isDefined(options.direction))
+                args.push(String(options.direction));
+            if (options.amount !== undefined && options.amount !== null) {
+                args.push(String(options.amount));
+            }
+            break;
+        case "scroll_into_view":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            break;
+        // Select: select <selector> <values...>
+        case "select":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (Array.isArray(options.values)) {
+                for (const v of options.values) {
+                    if (isDefined(v))
+                        args.push(String(v));
+                }
+            }
+            else if (isDefined(options.value)) {
+                args.push(String(options.value));
+            }
+            break;
+        // Drag: drag <source> <target>
+        case "drag":
+            if (isDefined(options.source))
+                args.push(String(options.source));
+            if (isDefined(options.target))
+                args.push(String(options.target));
+            break;
+        // Upload: upload <selector> <files...>
+        case "upload":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (Array.isArray(options.files)) {
+                for (const f of options.files) {
+                    if (isDefined(f))
+                        args.push(String(f));
+                }
+            }
+            else if (isDefined(options.file)) {
+                args.push(String(options.file));
+            }
+            break;
+        // Download: download <selector> <path>
+        case "download":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            break;
+        // Swipe: swipe <direction> [distance]
+        case "swipe":
+            if (isDefined(options.direction))
+                args.push(String(options.direction));
+            if (options.distance !== undefined && options.distance !== null) {
+                args.push(String(options.distance));
+            }
+            break;
+        // Mouse subcommands
+        case "mouse_move":
+            if (options.x !== undefined && options.x !== null)
+                args.push(String(options.x));
+            if (options.y !== undefined && options.y !== null)
+                args.push(String(options.y));
+            break;
+        case "mouse_down":
+        case "mouse_up":
+            if (isDefined(options.button))
+                args.push(String(options.button));
+            break;
+        case "mouse_wheel":
+            if (options.deltaY !== undefined && options.deltaY !== null) {
+                args.push(String(options.deltaY));
+            }
+            if (options.deltaX !== undefined && options.deltaX !== null) {
+                args.push(String(options.deltaX));
+            }
+            break;
+        // Get text/html/value: get text|html|value <selector>
+        case "get_text":
+        case "get_html":
+        case "get_value":
+        case "get_count":
+        case "get_bounding_box":
+        case "get_styles":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            break;
+        // Get attribute: get attr <selector> <name>
+        case "get_attribute":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (isDefined(options.attribute))
+                args.push(String(options.attribute));
+            break;
+        // Is visible/enabled/checked: is <state> <selector>
+        case "is_visible":
+        case "is_enabled":
+        case "is_checked":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            break;
+        // Find locators: find <type> <value> [action] [--name] [--exact]
+        case "find_role":
+        case "find_text":
+        case "find_label":
+        case "find_placeholder":
+        case "find_alt":
+        case "find_title":
+        case "find_testid":
+        case "find_first":
+        case "find_last":
+            if (isDefined(options.value))
+                args.push(String(options.value));
+            if (isDefined(options.subaction))
+                args.push(String(options.subaction));
+            if (command === "find_role" && isDefined(options.name)) {
+                args.push("--name", String(options.name));
+            }
+            if (options.exact)
+                args.push("--exact");
+            break;
+        case "find_nth":
+            if (options.index !== undefined && options.index !== null) {
+                args.push(String(options.index));
+            }
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (isDefined(options.subaction))
+                args.push(String(options.subaction));
+            break;
+        // Wait (default: selector or ms)
+        case "wait":
+            if (isDefined(options.target))
+                args.push(String(options.target));
+            break;
+        case "wait_for_selector":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            break;
+        // Screenshot: screenshot [selector] [path] [--full]
+        case "screenshot":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            break;
+        // PDF: pdf <path>
+        case "pdf":
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            break;
+        // Eval: eval <script>
+        case "evaluate":
+            if (isDefined(options.script))
+                args.push(String(options.script));
+            break;
+        case "evaluate_base64":
+            if (isDefined(options.script))
+                args.push(String(options.script));
+            break;
+        // Batch: batch [--bail] <commands...>
+        case "batch":
+            if (Array.isArray(options.commands)) {
+                for (const c of options.commands) {
+                    if (isDefined(c))
+                        args.push(String(c));
+                }
+            }
+            break;
+        // Clipboard write: clipboard write <text>
+        case "clipboard_write":
+            if (options.text !== undefined && options.text !== null) {
+                args.push(String(options.text));
+            }
+            break;
+        // Settings
+        case "set_viewport":
+            if (options.width !== undefined && options.width !== null)
+                args.push(String(options.width));
+            if (options.height !== undefined && options.height !== null)
+                args.push(String(options.height));
+            if (options.scale !== undefined && options.scale !== null)
+                args.push(String(options.scale));
+            break;
+        case "set_device":
+            if (isDefined(options.device))
+                args.push(String(options.device));
+            break;
+        case "set_geolocation":
+            if (options.latitude !== undefined && options.latitude !== null)
+                args.push(String(options.latitude));
+            if (options.longitude !== undefined && options.longitude !== null)
+                args.push(String(options.longitude));
+            break;
+        case "set_offline":
+            if (options.offline !== undefined && options.offline !== null) {
+                args.push(options.offline ? "on" : "off");
+            }
+            break;
+        case "set_headers":
+            if (isDefined(options.headers))
+                args.push(String(options.headers));
+            break;
+        case "set_credentials":
+            if (isDefined(options.username))
+                args.push(String(options.username));
+            if (isDefined(options.password))
+                args.push(String(options.password));
+            break;
+        case "set_media":
+            if (isDefined(options.colorScheme))
+                args.push(String(options.colorScheme));
+            if (options.reducedMotion)
+                args.push("reduced-motion");
+            break;
+        // Cookies
+        case "set_cookie":
+            if (isDefined(options.name))
+                args.push(String(options.name));
+            if (options.value !== undefined && options.value !== null) {
+                args.push(String(options.value));
+            }
+            break;
+        case "set_cookies":
+            if (Array.isArray(options.cookies) && options.cookies.length > 0) {
+                args.push(String(options.cookies[0].name));
+                args.push(String(options.cookies[0].value));
+            }
+            break;
+        case "set_cookies_from_file":
+            if (isDefined(options.file))
+                args.push(String(options.file));
+            break;
+        // Storage
+        case "storage_set_local":
+        case "storage_set_session":
+            if (isDefined(options.key))
+                args.push(String(options.key));
+            if (options.value !== undefined && options.value !== null) {
+                args.push(String(options.value));
+            }
+            break;
+        case "storage_get_local":
+        case "storage_get_session":
+            if (isDefined(options.key))
+                args.push(String(options.key));
+            break;
+        // Network
+        case "network_route":
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        case "network_unroute":
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        case "network_request_detail":
+            if (isDefined(options.requestId))
+                args.push(String(options.requestId));
+            break;
+        case "network_har_stop":
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            break;
+        // Tabs
+        case "tab_new":
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        case "tab_switch":
+            if (isDefined(options.tabId))
+                args.push(String(options.tabId));
+            break;
+        case "tab_close":
+            if (isDefined(options.tabId))
+                args.push(String(options.tabId));
+            break;
+        // Frames
+        case "frame_switch":
+            if (isDefined(options.selector))
+                args.push(String(options.selector));
+            break;
+        // Dialogs
+        case "dialog_accept":
+        case "dialog_dismiss":
+            if (isDefined(options.promptText))
+                args.push(String(options.promptText));
+            break;
+        // Debug
+        case "trace_stop":
+        case "profiler_stop":
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            break;
+        // State Management
+        case "state_save":
+        case "state_load":
+        case "state_show":
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            break;
+        case "state_rename":
+            if (isDefined(options.oldName))
+                args.push(String(options.oldName));
+            if (isDefined(options.newName))
+                args.push(String(options.newName));
+            break;
+        case "state_clean":
+            if (options.days !== undefined && options.days !== null) {
+                args.push("--older-than", String(options.days));
+            }
+            break;
+        case "state_clear":
+            if (isDefined(options.sessionName))
+                args.push(String(options.sessionName));
+            break;
+        // Recording
+        case "record_start":
+        case "record_restart":
+            if (isDefined(options.path))
+                args.push(String(options.path));
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        // Auth
+        case "auth_save":
+            if (isDefined(options.name))
+                args.push(String(options.name));
+            if (isDefined(options.url))
+                args.push("--url", String(options.url));
+            if (isDefined(options.username))
+                args.push("--username", String(options.username));
+            if (isDefined(options.password))
+                args.push("--password", String(options.password));
+            if (isDefined(options.usernameSelector)) {
+                args.push("--username-selector", String(options.usernameSelector));
+            }
+            if (isDefined(options.passwordSelector)) {
+                args.push("--password-selector", String(options.passwordSelector));
+            }
+            if (isDefined(options.submitSelector)) {
+                args.push("--submit-selector", String(options.submitSelector));
+            }
+            break;
+        case "auth_login":
+        case "auth_delete":
+        case "auth_show":
+            if (isDefined(options.name))
+                args.push(String(options.name));
+            break;
+        // Diff
+        case "diff_snapshot":
+            if (isDefined(options.baseline))
+                args.push("--baseline", String(options.baseline));
+            if (isDefined(options.selector))
+                args.push("--selector", String(options.selector));
+            if (options.compact)
+                args.push("--compact");
+            if (options.depth !== undefined && options.depth !== null) {
+                args.push("--depth", String(options.depth));
+            }
+            break;
+        case "diff_screenshot":
+            if (isDefined(options.baseline))
+                args.push("--baseline", String(options.baseline));
+            if (isDefined(options.output))
+                args.push("--output", String(options.output));
+            if (options.threshold !== undefined && options.threshold !== null) {
+                args.push("--threshold", String(options.threshold));
+            }
+            if (isDefined(options.selector))
+                args.push("--selector", String(options.selector));
+            if (options.fullPage)
+                args.push("--full");
+            break;
+        case "diff_url":
+            if (isDefined(options.url1))
+                args.push(String(options.url1));
+            if (isDefined(options.url2))
+                args.push(String(options.url2));
+            if (options.screenshot)
+                args.push("--screenshot");
+            if (options.fullPage)
+                args.push("--full");
+            if (isDefined(options.waitUntil))
+                args.push("--wait-until", String(options.waitUntil));
+            if (isDefined(options.selector))
+                args.push("--selector", String(options.selector));
+            if (options.compact)
+                args.push("--compact");
+            if (options.depth !== undefined && options.depth !== null) {
+                args.push("--depth", String(options.depth));
+            }
+            break;
+        // React
+        case "react_inspect":
+            if (options.fiberId !== undefined && options.fiberId !== null) {
+                args.push(String(options.fiberId));
+            }
+            break;
+        // Vitals
+        case "vitals":
+            if (isDefined(options.url))
+                args.push(String(options.url));
+            break;
+        // Init Scripts
+        case "remove_init_script":
+            if (isDefined(options.identifier))
+                args.push(String(options.identifier));
+            break;
+        // Confirm/Deny
+        case "confirm_action":
+        case "deny_action":
+            if (isDefined(options.confirmationId))
+                args.push(String(options.confirmationId));
+            break;
+        // Connect CDP
+        case "connect":
+            if (isDefined(options.endpoint))
+                args.push(String(options.endpoint));
+            break;
+        // Streaming
+        case "stream_enable":
+            break;
+        // Dashboard
+        case "dashboard_start":
+            if (isDefined(options.port))
+                args.push("--port", String(options.port));
+            break;
+        // Commands with no positional args
+        case "go_back":
+        case "go_forward":
+        case "reload":
+        case "get_url":
+        case "get_title":
+        case "get_cdp_url":
+        case "snapshot":
+        case "get_cookies":
+        case "clear_cookies":
+        case "get_console":
+        case "get_errors":
+        case "inspect":
+        case "close_session":
+        case "tab_list":
+        case "frame_main":
+        case "dialog_status":
+        case "trace_start":
+        case "profiler_start":
+        case "state_list":
+        case "record_stop":
+        case "auth_list":
+        case "session_show":
+        case "session_list":
+        case "stream_disable":
+        case "stream_status":
+        case "dashboard_stop":
+        case "device_list":
+        case "react_tree":
+        case "react_renders_start":
+        case "react_renders_stop":
+        case "react_suspense":
+        case "clipboard_read":
+        case "clipboard_copy":
+        case "clipboard_paste":
+        case "storage_clear_local":
+        case "storage_clear_session":
+        case "window_new":
+        case "network_requests":
+        case "network_har_start":
+        case "get_storage_local":
+        case "get_storage_session":
+        case "wait_for_url":
+        case "wait_for_navigation":
+        case "wait_for_load_state":
+        case "wait_for_function":
+        case "wait_for_text":
+        case "wait_for_download":
+        case "get_network":
+        case "new_session":
+            break;
+    }
+    return args;
+}
+/**
+ * Build optional flags for commands that support them.
+ */
+function buildOptionalFlags(command, options) {
+    const flags = [];
+    switch (command) {
+        case "screenshot":
+            if (options.fullPage)
+                flags.push("-f");
+            if (options.annotate)
+                flags.push("--annotate");
+            if (isDefined(options.format))
+                flags.push("--screenshot-format", String(options.format));
+            if (options.quality !== undefined && options.quality !== null) {
+                flags.push("--screenshot-quality", String(options.quality));
+            }
+            if (isDefined(options.screenshotDir)) {
+                flags.push("--screenshot-dir", String(options.screenshotDir));
+            }
+            break;
+        case "snapshot":
+            if (options.interactive)
+                flags.push("-i");
+            if (options.compact)
+                flags.push("-c");
+            if (options.cursor)
+                flags.push("-C");
+            if (options.urls)
+                flags.push("-u");
+            if (options.depth !== undefined && options.depth !== null) {
+                flags.push("-d", String(options.depth));
+            }
+            if (isDefined(options.selector)) {
+                flags.push("-s", String(options.selector));
+            }
+            break;
+        case "scroll":
+            if (isDefined(options.selector)) {
+                flags.push("--selector", String(options.selector));
+            }
+            break;
+        case "click":
+            if (options.newTab)
+                flags.push("--new-tab");
+            break;
+        case "batch":
+            if (options.bail)
+                flags.push("--bail");
+            break;
+        case "tab_new":
+            if (isDefined(options.label))
+                flags.push("--label", String(options.label));
+            break;
+        case "stream_enable":
+            if (options.port !== undefined && options.port !== null) {
+                flags.push("--port", String(options.port));
+            }
+            break;
+        case "wait":
+            if (isDefined(options.text))
+                flags.push("--text", String(options.text));
+            if (options.timeout !== undefined && options.timeout !== null) {
+                if (!isDefined(options.text) && command === "wait") {
+                    // timeout alone doesn't need --timeout flag for raw wait
+                }
+                else {
+                    flags.push("--timeout", String(options.timeout));
+                }
+            }
+            break;
+        case "wait_for_url":
+        case "wait_for_navigation":
+            if (isDefined(options.url))
+                flags.push("--url", String(options.url));
+            if (options.timeout !== undefined && options.timeout !== null) {
+                flags.push("--timeout", String(options.timeout));
+            }
+            break;
+        case "wait_for_text":
+            if (isDefined(options.text))
+                flags.push("--text", String(options.text));
+            if (options.timeout !== undefined && options.timeout !== null) {
+                flags.push("--timeout", String(options.timeout));
+            }
+            break;
+        case "wait_for_load_state":
+            if (isDefined(options.state))
+                flags.push("--load", String(options.state));
+            if (options.timeout !== undefined && options.timeout !== null) {
+                flags.push("--timeout", String(options.timeout));
+            }
+            break;
+        case "wait_for_function":
+            if (isDefined(options.expression))
+                flags.push("--fn", String(options.expression));
+            if (options.timeout !== undefined && options.timeout !== null) {
+                flags.push("--timeout", String(options.timeout));
+            }
+            break;
+        case "wait_for_download":
+            if (isDefined(options.path)) {
+                flags.push("--download", String(options.path));
+            }
+            else {
+                flags.push("--download");
+            }
+            if (options.timeout !== undefined && options.timeout !== null) {
+                flags.push("--timeout", String(options.timeout));
+            }
+            break;
+        case "profiler_start":
+            if (isDefined(options.categories)) {
+                flags.push("--categories", String(options.categories));
+            }
+            break;
+        case "get_console":
+        case "get_errors":
+            if (options.clear)
+                flags.push("--clear");
+            break;
+        case "network_requests":
+        case "get_network":
+            if (options.clear)
+                flags.push("--clear");
+            if (isDefined(options.filter))
+                flags.push("--filter", String(options.filter));
+            if (isDefined(options.type))
+                flags.push("--type", String(options.type));
+            if (isDefined(options.method))
+                flags.push("--method", String(options.method));
+            if (isDefined(options.status))
+                flags.push("--status", String(options.status));
+            break;
+        case "network_route":
+            if (options.abort)
+                flags.push("--abort");
+            if (isDefined(options.body))
+                flags.push("--body", String(options.body));
+            if (isDefined(options.resourceType)) {
+                flags.push("--resource-type", String(options.resourceType));
+            }
+            break;
+        case "set_cookie":
+        case "set_cookies":
+            if (isDefined(options.url))
+                flags.push("--url", String(options.url));
+            if (isDefined(options.domain))
+                flags.push("--domain", String(options.domain));
+            if (isDefined(options.path))
+                flags.push("--path", String(options.path));
+            if (options.httpOnly)
+                flags.push("--httpOnly");
+            if (options.secure)
+                flags.push("--secure");
+            if (isDefined(options.sameSite))
+                flags.push("--sameSite", String(options.sameSite));
+            if (options.expires !== undefined && options.expires !== null) {
+                flags.push("--expires", String(options.expires));
+            }
+            break;
+        case "set_cookies_from_file":
+            if (isDefined(options.domain))
+                flags.push("--domain", String(options.domain));
+            if (isDefined(options.url))
+                flags.push("--url", String(options.url));
+            break;
+        case "evaluate":
+        case "evaluate_base64":
+            if (options.stdin)
+                flags.push("--stdin");
+            break;
+        case "react_tree":
+        case "react_inspect":
+        case "react_renders_stop":
+        case "react_suspense":
+            if (options.json)
+                flags.push("--json");
+            if (options.onlyDynamic)
+                flags.push("--only-dynamic");
+            break;
+        case "vitals":
+            if (options.json)
+                flags.push("--json");
+            break;
+        case "state_clear":
+            if (options.all)
+                flags.push("--all");
+            break;
+        case "diff_snapshot":
+            if (isDefined(options.baseline))
+                flags.push("--baseline", String(options.baseline));
+            if (isDefined(options.selector))
+                flags.push("--selector", String(options.selector));
+            if (options.compact)
+                flags.push("--compact");
+            if (options.depth !== undefined && options.depth !== null) {
+                flags.push("--depth", String(options.depth));
+            }
+            break;
+        case "diff_screenshot":
+            if (isDefined(options.baseline))
+                flags.push("--baseline", String(options.baseline));
+            if (isDefined(options.output))
+                flags.push("--output", String(options.output));
+            if (options.threshold !== undefined && options.threshold !== null) {
+                flags.push("--threshold", String(options.threshold));
+            }
+            if (isDefined(options.selector))
+                flags.push("--selector", String(options.selector));
+            if (options.fullPage)
+                flags.push("--full");
+            break;
+        case "diff_url":
+            if (options.screenshot)
+                flags.push("--screenshot");
+            if (options.fullPage)
+                flags.push("--full");
+            if (isDefined(options.waitUntil))
+                flags.push("--wait-until", String(options.waitUntil));
+            if (isDefined(options.selector))
+                flags.push("--selector", String(options.selector));
+            if (options.compact)
+                flags.push("--compact");
+            if (options.depth !== undefined && options.depth !== null) {
+                flags.push("--depth", String(options.depth));
+            }
+            break;
+    }
+    return flags;
+}
+/**
+ * Execute an agent-browser command and return the result.
+ */
+export async function execBrowser(command, options = {}, sessionId) {
+    const cliCommand = COMMAND_MAP[command];
+    if (!cliCommand) {
+        throw new Error(`Unknown command: ${command}`);
+    }
+    const commandParts = cliCommand.split(" ");
+    const args = [...commandParts];
+    const execPath = getExecutablePath();
+    if (execPath) {
+        args.push("--executable-path", execPath);
+    }
+    if (sessionId) {
+        args.push("--session", sessionId);
+    }
+    const positionalArgs = buildPositionalArgs(command, options);
+    args.push(...positionalArgs);
+    const optionalFlags = buildOptionalFlags(command, options);
+    args.push(...optionalFlags);
+    if (process.env.DEBUG) {
+        console.error(`[agent-browser-mcp] Executing: ${AGENT_BROWSER_PATH} ${args.join(" ")}`);
+    }
+    return new Promise((resolve, reject) => {
+        const proc = spawn(AGENT_BROWSER_PATH, args, {
+            env: {
+                ...process.env,
+                ...(sessionId && { AGENT_BROWSER_SESSION: sessionId }),
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout.trim() || "Command executed successfully");
+            }
+            else {
+                reject(new Error(`agent-browser exited with code ${code}: ${stderr || stdout}`));
+            }
+        });
+        proc.on("error", (err) => {
+            reject(new Error(`Failed to execute agent-browser: ${err.message}`));
+        });
+    });
+}
+/**
+ * Check if agent-browser is available.
+ */
+export async function checkAgentBrowser() {
+    try {
+        await execBrowser("snapshot", {});
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=executor.js.map