@dyyz1993/agent-browser 0.9.2

package/dist/actions.js

@@ -0,0 +1,2164 @@
+import { mkdirSync, readFileSync, existsSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { getAppDir, getSession, getInstanceId } from './daemon.js';
+import { performDiff } from './diff.js';
+import { MessageBridge } from './message-bridge.js';
+import { detectMainContent, generateContentTips } from './content-detection.js';
+import { humanClick, humanType, humanMoveTo, humanWander, getHumanConfigFromEnv, } from './human-mouse.js';
+import { successResponse, errorResponse } from './protocol.js';
+// Callback for screencast frames - will be set by the daemon when streaming is active
+let screencastFrameCallback = null;
+/**
+ * Set the callback for screencast frames
+ * This is called by the daemon to set up frame streaming
+ */
+export function setScreencastFrameCallback(callback) {
+    screencastFrameCallback = callback;
+}
+// Event callbacks registered by StreamServer or other listeners
+let eventCallbacks = {};
+/**
+ * Set browser event callbacks for real-time broadcasting
+ * This is called by StreamServer to register event listeners
+ */
+export function setEventCallbacks(callbacks) {
+    eventCallbacks = { ...eventCallbacks, ...callbacks };
+}
+/**
+ * Get the current event callbacks
+ * This is called by BrowserManager to trigger events
+ */
+export function getEventCallbacks() {
+    return eventCallbacks;
+}
+/**
+ * Convert Playwright errors to AI-friendly messages
+ * @internal Exported for testing
+ */
+export function toAIFriendlyError(error, selector) {
+    const message = error instanceof Error ? error.message : String(error);
+    // Handle strict mode violation (multiple elements match)
+    if (message.includes('strict mode violation')) {
+        // Extract count if available
+        const countMatch = message.match(/resolved to (\d+) elements/);
+        const count = countMatch ? countMatch[1] : 'multiple';
+        return new Error(`Selector "${selector}" matched ${count} elements. ` +
+            `Run 'snapshot' to get updated refs, or use a more specific CSS selector.`);
+    }
+    // Handle element not interactable (must be checked BEFORE timeout case)
+    // This includes cases where an overlay/modal blocks the element
+    if (message.includes('intercepts pointer events')) {
+        return new Error(`Element "${selector}" is blocked by another element (likely a modal or overlay). ` +
+            `Try dismissing any modals/cookie banners first.`);
+    }
+    // Handle element not visible
+    if (message.includes('not visible') && !message.includes('Timeout')) {
+        return new Error(`Element "${selector}" is not visible. ` +
+            `Try scrolling it into view or check if it's hidden.`);
+    }
+    // Handle general timeout (element exists but action couldn't complete)
+    if (message.includes('Timeout') && message.includes('exceeded')) {
+        return new Error(`Action on "${selector}" timed out. The element may be blocked, still loading, or not interactable. ` +
+            `Run 'snapshot' to check the current page state.`);
+    }
+    // Handle element not found (timeout waiting for element)
+    if (message.includes('waiting for') &&
+        (message.includes('to be visible') || message.includes('Timeout'))) {
+        return new Error(`Element "${selector}" not found or not visible. ` +
+            `Run 'snapshot' to see current page elements.`);
+    }
+    // Return original error for unknown cases
+    return error instanceof Error ? error : new Error(message);
+}
+/**
+ * Execute a command and return a response
+ */
+export async function executeCommand(command, browser) {
+    try {
+        const cmd = command;
+        switch (cmd.action) {
+            case 'launch':
+                return await handleLaunch(cmd, browser);
+            case 'navigate':
+                return await handleNavigate(cmd, browser);
+            case 'click':
+                return await handleClick(cmd, browser);
+            case 'type':
+                return await handleType(cmd, browser);
+            case 'fill':
+                return await handleFill(cmd, browser);
+            case 'check':
+                return await handleCheck(cmd, browser);
+            case 'uncheck':
+                return await handleUncheck(cmd, browser);
+            case 'upload':
+                return await handleUpload(cmd, browser);
+            case 'dblclick':
+                return await handleDoubleClick(cmd, browser);
+            case 'focus':
+                return await handleFocus(cmd, browser);
+            case 'drag':
+                return await handleDrag(cmd, browser);
+            case 'getbyrole':
+                return await handleGetByRole(cmd, browser);
+            case 'getbytext':
+                return await handleGetByText(cmd, browser);
+            case 'getbylabel':
+                return await handleGetByLabel(cmd, browser);
+            case 'getbyplaceholder':
+                return await handleGetByPlaceholder(cmd, browser);
+            case 'press':
+                return await handlePress(cmd, browser);
+            case 'screenshot':
+                return await handleScreenshot(cmd, browser);
+            case 'snapshot':
+                return await handleSnapshot(cmd, browser);
+            case 'evaluate':
+                return await handleEvaluate(cmd, browser);
+            case 'wait':
+                return await handleWait(cmd, browser);
+            case 'scroll':
+                return await handleScroll(cmd, browser);
+            case 'select':
+                return await handleSelect(cmd, browser);
+            case 'hover':
+                return await handleHover(cmd, browser);
+            case 'content':
+                return await handleContent(cmd, browser);
+            case 'close':
+                return await handleClose(cmd, browser);
+            case 'tab_new':
+                return await handleTabNew(cmd, browser);
+            case 'tab_list':
+                return await handleTabList(cmd, browser);
+            case 'tab_switch':
+                return await handleTabSwitch(cmd, browser);
+            case 'tab_close':
+                return await handleTabClose(cmd, browser);
+            case 'window_new':
+                return await handleWindowNew(cmd, browser);
+            case 'cookies_get':
+                return await handleCookiesGet(cmd, browser);
+            case 'cookies_set':
+                return await handleCookiesSet(cmd, browser);
+            case 'cookies_clear':
+                return await handleCookiesClear(cmd, browser);
+            case 'storage_get':
+                return await handleStorageGet(cmd, browser);
+            case 'storage_set':
+                return await handleStorageSet(cmd, browser);
+            case 'storage_clear':
+                return await handleStorageClear(cmd, browser);
+            case 'dialog':
+                return await handleDialog(cmd, browser);
+            case 'pdf':
+                return await handlePdf(cmd, browser);
+            case 'route':
+                return await handleRoute(cmd, browser);
+            case 'unroute':
+                return await handleUnroute(cmd, browser);
+            case 'requests':
+                return await handleRequests(cmd, browser);
+            case 'download':
+                return await handleDownload(cmd, browser);
+            case 'geolocation':
+                return await handleGeolocation(cmd, browser);
+            case 'permissions':
+                return await handlePermissions(cmd, browser);
+            case 'viewport':
+                return await handleViewport(cmd, browser);
+            case 'useragent':
+                return await handleUserAgent(cmd, browser);
+            case 'device':
+                return await handleDevice(cmd, browser);
+            case 'back':
+                return await handleBack(cmd, browser);
+            case 'forward':
+                return await handleForward(cmd, browser);
+            case 'reload':
+                return await handleReload(cmd, browser);
+            case 'url':
+                return await handleUrl(cmd, browser);
+            case 'title':
+                return await handleTitle(cmd, browser);
+            case 'getattribute':
+                return await handleGetAttribute(cmd, browser);
+            case 'gettext':
+                return await handleGetText(cmd, browser);
+            case 'isvisible':
+                return await handleIsVisible(cmd, browser);
+            case 'isenabled':
+                return await handleIsEnabled(cmd, browser);
+            case 'ischecked':
+                return await handleIsChecked(cmd, browser);
+            case 'count':
+                return await handleCount(cmd, browser);
+            case 'boundingbox':
+                return await handleBoundingBox(cmd, browser);
+            case 'styles':
+                return await handleStyles(cmd, browser);
+            case 'video_start':
+                return await handleVideoStart(cmd, browser);
+            case 'video_stop':
+                return await handleVideoStop(cmd, browser);
+            case 'trace_start':
+                return await handleTraceStart(cmd, browser);
+            case 'trace_stop':
+                return await handleTraceStop(cmd, browser);
+            case 'har_start':
+                return await handleHarStart(cmd, browser);
+            case 'har_stop':
+                return await handleHarStop(cmd, browser);
+            case 'state_save':
+                return await handleStateSave(cmd, browser);
+            case 'state_load':
+                return await handleStateLoad(cmd, browser);
+            case 'console':
+                return await handleConsole(cmd, browser);
+            case 'errors':
+                return await handleErrors(cmd, browser);
+            case 'keyboard':
+                return await handleKeyboard(cmd, browser);
+            case 'wheel':
+                return await handleWheel(cmd, browser);
+            case 'tap':
+                return await handleTap(cmd, browser);
+            case 'clipboard':
+                return await handleClipboard(cmd, browser);
+            case 'highlight':
+                return await handleHighlight(cmd, browser);
+            case 'clear':
+                return await handleClear(cmd, browser);
+            case 'selectall':
+                return await handleSelectAll(cmd, browser);
+            case 'innertext':
+                return await handleInnerText(cmd, browser);
+            case 'innerhtml':
+                return await handleInnerHtml(cmd, browser);
+            case 'inputvalue':
+                return await handleInputValue(cmd, browser);
+            case 'setvalue':
+                return await handleSetValue(cmd, browser);
+            case 'dispatch':
+                return await handleDispatch(cmd, browser);
+            case 'evalhandle':
+                return await handleEvalHandle(cmd, browser);
+            case 'expose':
+                return await handleExpose(cmd, browser);
+            case 'addscript':
+                return await handleAddScript(cmd, browser);
+            case 'addstyle':
+                return await handleAddStyle(cmd, browser);
+            case 'emulatemedia':
+                return await handleEmulateMedia(cmd, browser);
+            case 'offline':
+                return await handleOffline(cmd, browser);
+            case 'headers':
+                return await handleHeaders(cmd, browser);
+            case 'pause':
+                return await handlePause(cmd, browser);
+            case 'getbyalttext':
+                return await handleGetByAltText(cmd, browser);
+            case 'getbytitle':
+                return await handleGetByTitle(cmd, browser);
+            case 'getbytestid':
+                return await handleGetByTestId(cmd, browser);
+            case 'nth':
+                return await handleNth(cmd, browser);
+            case 'waitforurl':
+                return await handleWaitForUrl(cmd, browser);
+            case 'waitforloadstate':
+                return await handleWaitForLoadState(cmd, browser);
+            case 'setcontent':
+                return await handleSetContent(cmd, browser);
+            case 'timezone':
+                return await handleTimezone(cmd, browser);
+            case 'locale':
+                return await handleLocale(cmd, browser);
+            case 'credentials':
+                return await handleCredentials(cmd, browser);
+            case 'mousemove':
+                return await handleMouseMove(cmd, browser);
+            case 'mousedown':
+                return await handleMouseDown(cmd, browser);
+            case 'mouseup':
+                return await handleMouseUp(cmd, browser);
+            case 'wander':
+                return await handleWander(cmd, browser);
+            case 'mousetrajectory':
+                return await handleMouseTrajectory(cmd, browser);
+            case 'bringtofront':
+                return await handleBringToFront(cmd, browser);
+            case 'waitforfunction':
+                return await handleWaitForFunction(cmd, browser);
+            case 'scrollintoview':
+                return await handleScrollIntoView(cmd, browser);
+            case 'addinitscript':
+                return await handleAddInitScript(cmd, browser);
+            case 'keydown':
+                return await handleKeyDown(cmd, browser);
+            case 'keyup':
+                return await handleKeyUp(cmd, browser);
+            case 'inserttext':
+                return await handleInsertText(cmd, browser);
+            case 'multiselect':
+                return await handleMultiSelect(cmd, browser);
+            case 'waitfordownload':
+                return await handleWaitForDownload(cmd, browser);
+            case 'responsebody':
+                return await handleResponseBody(cmd, browser);
+            case 'screencast_start':
+                return await handleScreencastStart(cmd, browser);
+            case 'screencast_stop':
+                return await handleScreencastStop(cmd, browser);
+            case 'input_mouse':
+                return await handleInputMouse(cmd, browser);
+            case 'input_keyboard':
+                return await handleInputKeyboard(cmd, browser);
+            case 'input_touch':
+                return await handleInputTouch(cmd, browser);
+            case 'recording_start':
+                return await handleRecordingStart(cmd, browser);
+            case 'recording_stop':
+                return await handleRecordingStop(cmd, browser);
+            case 'recording_restart':
+                return await handleRecordingRestart(cmd, browser);
+            case 'recorder_start':
+                return await handleRecorderStart(cmd, browser);
+            case 'recorder_stop':
+                return await handleRecorderStop(cmd, browser);
+            case 'recorder_status':
+                return await handleRecorderStatus(cmd, browser);
+            case 'recorder_replay':
+                return await handleRecorderReplay(cmd, browser);
+            case 'viewer':
+                return await handleViewer(cmd, browser);
+            case 'ask':
+                return await handleAsk(cmd, browser);
+            case 'config':
+                return handleConfig(cmd);
+            default: {
+                const unknownCommand = cmd;
+                return errorResponse(unknownCommand.id, `Unknown action: ${unknownCommand.action}`);
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResponse(command.id, message);
+    }
+}
+async function handleLaunch(command, browser) {
+    await browser.launch(command);
+    const instanceId = getInstanceId();
+    return successResponse(command.id, {
+        launched: true,
+        instanceId,
+        viewerUrl: `http://localhost:5005/view?instanceId=${instanceId}`,
+    });
+}
+async function handleNavigate(command, browser) {
+    const page = browser.getPage();
+    if (command.headers && Object.keys(command.headers).length > 0) {
+        await browser.setScopedHeaders(command.url, command.headers);
+    }
+    await page.goto(command.url, {
+        waitUntil: command.waitUntil ?? 'load',
+        timeout: command.timeout,
+    });
+    if (browser.isRecordingSession()) {
+        await browser.injectRecorderIfNeeded();
+    }
+    return successResponse(command.id, {
+        url: page.url(),
+        title: await page.title(),
+    });
+}
+async function handleClick(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    if (command.human?.enabled) {
+        const diffResult = await performDiff(locator, command.diffScope, async () => {
+            try {
+                const page = browser.getPage();
+                const box = await locator.boundingBox();
+                if (!box) {
+                    throw new Error(`Element not visible: ${command.selector}`);
+                }
+                const targetX = box.x + box.width / 2;
+                const targetY = box.y + box.height / 2;
+                await humanClick(page, targetX, targetY, command.human, {
+                    button: command.button,
+                    clickCount: command.clickCount,
+                });
+            }
+            catch (error) {
+                throw toAIFriendlyError(error, command.selector);
+            }
+        });
+        const result = { clicked: true, human: true };
+        if (diffResult) {
+            result.diff = diffResult.output;
+            result.diffScope = diffResult.diff.scope;
+        }
+        return successResponse(command.id, result);
+    }
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.click({
+                button: command.button,
+                clickCount: command.clickCount,
+                delay: command.delay,
+                timeout: command.timeout || 5000, // Default 5s timeout for element to appear
+            });
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { clicked: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleType(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    if (command.human?.enabled) {
+        const diffResult = await performDiff(locator, command.diffScope, async () => {
+            try {
+                const page = browser.getPage();
+                const box = await locator.boundingBox();
+                if (!box) {
+                    throw new Error(`Element not visible: ${command.selector}`);
+                }
+                const targetX = box.x + box.width / 2;
+                const targetY = box.y + box.height / 2;
+                await humanClick(page, targetX, targetY, command.human);
+                await locator.focus();
+                await humanType(page, command.text, command.human);
+            }
+            catch (error) {
+                throw toAIFriendlyError(error, command.selector);
+            }
+        });
+        const result = { typed: true, human: true };
+        if (diffResult) {
+            result.diff = diffResult.output;
+            result.diffScope = diffResult.diff.scope;
+        }
+        return successResponse(command.id, result);
+    }
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            if (command.clear) {
+                await locator.fill('');
+            }
+            await locator.pressSequentially(command.text, {
+                delay: command.delay,
+            });
+            await locator.evaluate((el) => {
+                el.dispatchEvent(new Event('input', { bubbles: true }));
+            });
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { typed: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handlePress(command, browser) {
+    const page = browser.getPage();
+    let locator = page.locator('body');
+    if (command.inFrame && command.selector) {
+        const frameLocator = browser.getFrame(command.inFrame);
+        locator = frameLocator.locator(command.selector);
+    }
+    else if (command.selector) {
+        locator = page.locator(command.selector);
+    }
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        if (command.inFrame && command.selector) {
+            const frameLocator = browser.getFrame(command.inFrame);
+            await frameLocator.locator(command.selector).press(command.key);
+        }
+        else {
+            if (command.selector) {
+                await page.press(command.selector, command.key);
+            }
+            else {
+                await page.keyboard.press(command.key);
+            }
+        }
+        // 触发 keydown 事件供录制器捕获
+        // Playwright 的 press 方法不会触发 JavaScript 层面的 keydown 事件
+        // 需要手动触发事件以便录制器能够捕获按键操作
+        await page.evaluate((key) => {
+            const specialKeys = [
+                'Enter',
+                'Tab',
+                'Escape',
+                'Backspace',
+                'ArrowUp',
+                'ArrowDown',
+                'ArrowLeft',
+                'ArrowRight',
+            ];
+            const keyParts = key.split('+');
+            const mainKey = keyParts[keyParts.length - 1];
+            const hasCtrl = keyParts.includes('Control') || keyParts.includes('Ctrl');
+            const hasMeta = keyParts.includes('Meta') || keyParts.includes('Command');
+            const hasAlt = keyParts.includes('Alt');
+            const hasShift = keyParts.includes('Shift');
+            if (specialKeys.includes(mainKey) || hasCtrl || hasMeta || hasAlt) {
+                const event = new KeyboardEvent('keydown', {
+                    key: mainKey,
+                    code: mainKey.length === 1 ? `Key${mainKey.toUpperCase()}` : mainKey,
+                    ctrlKey: hasCtrl,
+                    metaKey: hasMeta,
+                    altKey: hasAlt,
+                    shiftKey: hasShift,
+                    bubbles: true,
+                });
+                document.activeElement?.dispatchEvent(event);
+            }
+        }, command.key);
+    });
+    const result = { pressed: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleScreenshot(command, browser) {
+    const page = browser.getPage();
+    const options = {
+        fullPage: command.fullPage,
+        type: command.format ?? 'png',
+    };
+    if (command.format === 'jpeg' && command.quality !== undefined) {
+        options.quality = command.quality;
+    }
+    let target = page;
+    if (command.inFrame) {
+        const frameLocator = browser.getFrame(command.inFrame);
+        if (command.selector) {
+            target = frameLocator.locator(command.selector);
+        }
+        else {
+            // For full frame screenshot, use locator(':root') on the frame locator
+            target = frameLocator.locator(':root');
+        }
+    }
+    else if (command.selector) {
+        target = browser.getLocator(command.selector);
+    }
+    try {
+        let savePath = command.path;
+        if (!savePath) {
+            const ext = command.format === 'jpeg' ? 'jpg' : 'png';
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const random = Math.random().toString(36).substring(2, 8);
+            const filename = `screenshot-${timestamp}-${random}.${ext}`;
+            const screenshotDir = path.join(getAppDir(), 'tmp', 'screenshots');
+            mkdirSync(screenshotDir, { recursive: true });
+            savePath = path.join(screenshotDir, filename);
+        }
+        await target.screenshot({ ...options, path: savePath });
+        return successResponse(command.id, { path: savePath });
+    }
+    catch (error) {
+        if (command.selector) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+        throw error;
+    }
+}
+async function handleSnapshot(command, browser) {
+    let effectiveSelector = command.selector;
+    let detectionResult = null;
+    // 如果未指定 selector，自动检测主体区域
+    if (!command.selector) {
+        const page = browser.getPage();
+        detectionResult = await detectMainContent(page);
+        effectiveSelector = detectionResult.selector;
+    }
+    const snapshot = await browser.getSnapshot({
+        interactive: command.interactive,
+        cursor: command.cursor,
+        maxDepth: command.maxDepth,
+        compact: command.compact,
+        selector: effectiveSelector,
+        framePath: command.inFrame,
+        path: command.path,
+        attrs: command.attrs,
+    });
+    const simpleRefs = {};
+    const refs = snapshot.refs || {};
+    for (const [ref, data] of Object.entries(refs)) {
+        simpleRefs[ref] = {
+            role: data.role,
+            name: data.name,
+            ...(data.xpath && { xpath: data.xpath }),
+            ...(data.cssPath && { cssPath: data.cssPath }),
+            ...(data.attributes && { attributes: data.attributes }),
+        };
+    }
+    // 生成 tips（只有自动检测到非 body 区域时才提示）
+    const tips = detectionResult ? generateContentTips(detectionResult) : undefined;
+    return successResponse(command.id, {
+        snapshot: snapshot.tree || 'Empty page',
+        refs: Object.keys(simpleRefs).length > 0 ? simpleRefs : undefined,
+    }, tips ?? undefined);
+}
+async function handleEvaluate(command, browser) {
+    try {
+        let script;
+        if (command.file) {
+            if (!existsSync(command.file)) {
+                throw new Error(`Script file not found: ${command.file}`);
+            }
+            script = readFileSync(command.file, 'utf-8');
+        }
+        else if (command.script) {
+            script = command.script;
+        }
+        else {
+            throw new Error('Either script or file must be provided for evaluate command');
+        }
+        let result;
+        if (command.inFrame) {
+            const frameLocator = browser.getFrame(command.inFrame);
+            result = await frameLocator.locator(':root').evaluate(script);
+        }
+        else {
+            const page = browser.getPage();
+            result = await page.evaluate(script);
+        }
+        return successResponse(command.id, { result });
+    }
+    catch (error) {
+        console.error('Error in handleEvaluate:', error);
+        return errorResponse(command.id, error instanceof Error ? error.message : String(error));
+    }
+}
+async function handleWait(command, browser) {
+    const humanConfig = getHumanConfigFromEnv();
+    const page = browser.getPage();
+    // If human mode is enabled and waiting for a duration, do mouse wander
+    if (humanConfig.enabled && command.timeout && !command.selector) {
+        await humanWander(page, humanConfig, { duration: command.timeout });
+        return successResponse(command.id, { waited: true, wandered: true });
+    }
+    if (command.inFrame) {
+        const frame = browser.getFrame(command.inFrame);
+        if (command.selector) {
+            await frame.waitForSelector(command.selector, {
+                state: command.state ?? 'visible',
+                timeout: command.timeout,
+            });
+        }
+        else if (command.timeout) {
+            await frame.waitForTimeout(command.timeout);
+        }
+        else {
+            await frame.waitForLoadState('load');
+        }
+    }
+    else {
+        const frame = browser.getFrame();
+        if (command.selector) {
+            await frame.waitForSelector(command.selector, {
+                state: command.state ?? 'visible',
+                timeout: command.timeout,
+            });
+        }
+        else if (command.timeout) {
+            await frame.waitForTimeout(command.timeout);
+        }
+        else {
+            await frame.waitForLoadState('load');
+        }
+    }
+    return successResponse(command.id, { waited: true });
+}
+async function handleScroll(command, browser) {
+    const page = browser.getPage();
+    if (command.selector) {
+        const element = page.locator(command.selector);
+        await element.scrollIntoViewIfNeeded();
+        if (command.x !== undefined || command.y !== undefined) {
+            await element.evaluate((el, { x, y }) => {
+                if ('scrollBy' in el) {
+                    el.scrollBy(x ?? 0, y ?? 0);
+                }
+            }, { x: command.x, y: command.y });
+        }
+    }
+    else {
+        // Scroll the page
+        let deltaX = command.x ?? 0;
+        let deltaY = command.y ?? 0;
+        if (command.direction) {
+            const amount = command.amount ?? 100;
+            switch (command.direction) {
+                case 'up':
+                    deltaY = -amount;
+                    break;
+                case 'down':
+                    deltaY = amount;
+                    break;
+                case 'left':
+                    deltaX = -amount;
+                    break;
+                case 'right':
+                    deltaX = amount;
+                    break;
+            }
+        }
+        await page.evaluate(`window.scrollBy(${deltaX}, ${deltaY})`);
+    }
+    return successResponse(command.id, { scrolled: true });
+}
+async function handleSelect(command, browser) {
+    const values = Array.isArray(command.values) ? command.values : [command.values];
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.selectOption(values);
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { selected: values };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleHover(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    if (command.human?.enabled) {
+        const diffResult = await performDiff(locator, command.diffScope, async () => {
+            try {
+                const page = browser.getPage();
+                const box = await locator.boundingBox();
+                if (!box) {
+                    throw new Error(`Element not visible: ${command.selector}`);
+                }
+                const targetX = box.x + box.width / 2;
+                const targetY = box.y + box.height / 2;
+                await humanMoveTo(page, { x: targetX, y: targetY }, command.human);
+            }
+            catch (error) {
+                throw toAIFriendlyError(error, command.selector);
+            }
+        });
+        const result = { hovered: true, human: true };
+        if (diffResult) {
+            result.diff = diffResult.output;
+            result.diffScope = diffResult.diff.scope;
+        }
+        return successResponse(command.id, result);
+    }
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.hover();
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { hovered: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleContent(command, browser) {
+    const page = browser.getPage();
+    let html;
+    if (command.selector) {
+        html = await page.locator(command.selector).innerHTML();
+    }
+    else {
+        html = await page.content();
+    }
+    return successResponse(command.id, { html });
+}
+async function handleClose(command, browser) {
+    await browser.close();
+    return successResponse(command.id, { closed: true });
+}
+async function handleTabNew(command, browser) {
+    const result = await browser.newTab();
+    // Navigate to URL if provided (same pattern as handleNavigate)
+    if (command.url) {
+        const page = browser.getPage();
+        await page.goto(command.url, { waitUntil: 'domcontentloaded' });
+    }
+    return successResponse(command.id, result);
+}
+async function handleTabList(command, browser) {
+    const tabs = await browser.listTabs();
+    return successResponse(command.id, {
+        tabs,
+        active: browser.getActiveIndex(),
+    });
+}
+async function handleTabSwitch(command, browser) {
+    const result = await browser.switchTo(command.index);
+    const page = browser.getPage();
+    return successResponse(command.id, {
+        ...result,
+        title: await page.title(),
+    });
+}
+async function handleTabClose(command, browser) {
+    const result = await browser.closeTab(command.index);
+    return successResponse(command.id, result);
+}
+async function handleWindowNew(command, browser) {
+    const result = await browser.newWindow(command.viewport);
+    return successResponse(command.id, result);
+}
+// New handlers for enhanced Playwright parity
+async function handleFill(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    if (command.human?.enabled) {
+        const diffResult = await performDiff(locator, command.diffScope, async () => {
+            try {
+                const page = browser.getPage();
+                const box = await locator.boundingBox();
+                if (!box) {
+                    throw new Error(`Element not visible: ${command.selector}`);
+                }
+                const targetX = box.x + box.width / 2;
+                const targetY = box.y + box.height / 2;
+                await humanClick(page, targetX, targetY, command.human);
+                await locator.focus();
+                // Clear existing content: triple-click to select all, then delete with Backspace
+                await page.mouse.click(targetX, targetY, { clickCount: 3 });
+                await page.keyboard.press('Backspace');
+                await humanType(page, command.value, command.human);
+            }
+            catch (error) {
+                throw toAIFriendlyError(error, command.selector);
+            }
+        });
+        const result = { filled: true, human: true };
+        if (diffResult) {
+            result.diff = diffResult.output;
+            result.diffScope = diffResult.diff.scope;
+        }
+        return successResponse(command.id, result);
+    }
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.fill(command.value);
+            // Trigger input event for recorder to capture
+            // Use page.evaluate to dispatch events in the browser context
+            const page = browser.getPage();
+            if (page) {
+                await page.evaluate((selector) => {
+                    const el = document.querySelector(selector);
+                    if (el) {
+                        el.dispatchEvent(new Event('input', { bubbles: true }));
+                        el.dispatchEvent(new Event('change', { bubbles: true }));
+                    }
+                }, command.selector);
+            }
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { filled: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleCheck(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.check();
+            await locator.evaluate((el) => {
+                el.dispatchEvent(new Event('click', { bubbles: true }));
+            });
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { checked: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleUncheck(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.uncheck();
+            await locator.evaluate((el) => {
+                el.dispatchEvent(new Event('click', { bubbles: true }));
+            });
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { unchecked: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleUpload(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const files = Array.isArray(command.files) ? command.files : [command.files];
+    try {
+        await locator.setInputFiles(files);
+    }
+    catch (error) {
+        throw toAIFriendlyError(error, command.selector);
+    }
+    return successResponse(command.id, { uploaded: files });
+}
+async function handleDoubleClick(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    if (command.human?.enabled) {
+        const diffResult = await performDiff(locator, command.diffScope, async () => {
+            try {
+                const page = browser.getPage();
+                const box = await locator.boundingBox();
+                if (!box) {
+                    throw new Error(`Element not visible: ${command.selector}`);
+                }
+                const targetX = box.x + box.width / 2;
+                const targetY = box.y + box.height / 2;
+                await humanClick(page, targetX, targetY, command.human, {
+                    clickCount: 2,
+                });
+            }
+            catch (error) {
+                throw toAIFriendlyError(error, command.selector);
+            }
+        });
+        const result = { clicked: true, human: true };
+        if (diffResult) {
+            result.diff = diffResult.output;
+            result.diffScope = diffResult.diff.scope;
+        }
+        return successResponse(command.id, result);
+    }
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.dblclick();
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { clicked: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleFocus(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const diffResult = await performDiff(locator, command.diffScope, async () => {
+        try {
+            await locator.focus({ timeout: 5000 });
+        }
+        catch (error) {
+            throw toAIFriendlyError(error, command.selector);
+        }
+    });
+    const result = { focused: true };
+    if (diffResult) {
+        result.diff = diffResult.output;
+        result.diffScope = diffResult.diff.scope;
+    }
+    return successResponse(command.id, result);
+}
+async function handleDrag(command, browser) {
+    const sourceLocator = browser.getLocator(command.source, command.inFrame);
+    const targetLocator = browser.getLocator(command.target, command.inFrame);
+    await sourceLocator.dragTo(targetLocator);
+    return successResponse(command.id, { dragged: true });
+}
+async function handleGetByRole(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByRole(command.role, {
+        name: command.name,
+        exact: command.exact,
+    });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'fill':
+            await locator.fill(command.value ?? '');
+            return successResponse(command.id, { filled: true });
+        case 'check':
+            await locator.check();
+            return successResponse(command.id, { checked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleGetByText(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByText(command.text, { exact: command.exact });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleGetByLabel(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByLabel(command.label, { exact: command.exact });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'fill':
+            await locator.fill(command.value ?? '');
+            return successResponse(command.id, { filled: true });
+        case 'check':
+            await locator.check();
+            return successResponse(command.id, { checked: true });
+    }
+}
+async function handleGetByPlaceholder(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByPlaceholder(command.placeholder, { exact: command.exact });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'fill':
+            await locator.fill(command.value ?? '');
+            return successResponse(command.id, { filled: true });
+    }
+}
+async function handleCookiesGet(command, browser) {
+    const page = browser.getPage();
+    const context = page.context();
+    const cookies = await context.cookies(command.urls);
+    return successResponse(command.id, { cookies });
+}
+async function handleCookiesSet(command, browser) {
+    const page = browser.getPage();
+    const context = page.context();
+    // Auto-fill URL for cookies that don't have domain/path/url set
+    const pageUrl = page.url();
+    const cookies = command.cookies.map((cookie) => {
+        if (!cookie.url && !cookie.domain && !cookie.path) {
+            return { ...cookie, url: pageUrl };
+        }
+        return cookie;
+    });
+    await context.addCookies(cookies);
+    return successResponse(command.id, { set: true });
+}
+async function handleCookiesClear(command, browser) {
+    const page = browser.getPage();
+    const context = page.context();
+    await context.clearCookies();
+    return successResponse(command.id, { cleared: true });
+}
+async function handleStorageGet(command, browser) {
+    const frame = browser.getFrame();
+    const storageType = command.type === 'local' ? 'localStorage' : 'sessionStorage';
+    if (command.key) {
+        const value = await frame.evaluate(`
+      ${storageType}.getItem(${JSON.stringify(command.key)})
+    `);
+        return successResponse(command.id, { key: command.key, value });
+    }
+    else {
+        const data = await frame.evaluate(`
+      (() => {
+        const storage = ${storageType};
+        const result = {};
+        for (let i = 0; i < storage.length; i++) {
+          const key = storage.key(i);
+          if (key) result[key] = storage.getItem(key);
+        }
+        return result;
+      })()
+    `);
+        return successResponse(command.id, { data });
+    }
+}
+async function handleStorageSet(command, browser) {
+    const frame = browser.getFrame();
+    const storageType = command.type === 'local' ? 'localStorage' : 'sessionStorage';
+    await frame.evaluate(`${storageType}.setItem(${JSON.stringify(command.key)}, ${JSON.stringify(command.value)})`);
+    return successResponse(command.id, { set: true });
+}
+async function handleStorageClear(command, browser) {
+    const frame = browser.getFrame();
+    const storageType = command.type === 'local' ? 'localStorage' : 'sessionStorage';
+    await frame.evaluate(`${storageType}.clear()`);
+    return successResponse(command.id, { cleared: true });
+}
+async function handleDialog(command, browser) {
+    browser.setDialogHandler(command.response, command.promptText);
+    return successResponse(command.id, { handler: 'set', response: command.response });
+}
+async function handlePdf(command, browser) {
+    const page = browser.getPage();
+    await page.pdf({
+        path: command.path,
+        format: command.format ?? 'Letter',
+    });
+    return successResponse(command.id, { path: command.path });
+}
+// Network & Request handlers
+async function handleRoute(command, browser) {
+    await browser.addRoute(command.url, {
+        response: command.response,
+        abort: command.abort,
+    });
+    return successResponse(command.id, { routed: command.url });
+}
+async function handleUnroute(command, browser) {
+    await browser.removeRoute(command.url);
+    return successResponse(command.id, { unrouted: command.url ?? 'all' });
+}
+async function handleRequests(command, browser) {
+    if (command.clear) {
+        browser.clearRequests();
+        return successResponse(command.id, { cleared: true });
+    }
+    // Start tracking if not already
+    browser.startRequestTracking();
+    const requests = browser.getRequests(command.filter);
+    return successResponse(command.id, { requests });
+}
+async function handleDownload(command, browser) {
+    const page = browser.getPage();
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const [download] = await Promise.all([page.waitForEvent('download'), locator.click()]);
+    await download.saveAs(command.path);
+    return successResponse(command.id, {
+        path: command.path,
+        suggestedFilename: download.suggestedFilename(),
+    });
+}
+async function handleGeolocation(command, browser) {
+    await browser.setGeolocation(command.latitude, command.longitude, command.accuracy);
+    return successResponse(command.id, {
+        latitude: command.latitude,
+        longitude: command.longitude,
+    });
+}
+async function handlePermissions(command, browser) {
+    await browser.setPermissions(command.permissions, command.grant);
+    return successResponse(command.id, {
+        permissions: command.permissions,
+        granted: command.grant,
+    });
+}
+async function handleViewport(command, browser) {
+    await browser.setViewport(command.width, command.height);
+    return successResponse(command.id, {
+        width: command.width,
+        height: command.height,
+    });
+}
+async function handleUserAgent(command, browser) {
+    const page = browser.getPage();
+    const context = page.context();
+    // Note: Can't change user agent after context is created, but we can for new pages
+    return successResponse(command.id, {
+        note: 'User agent can only be set at launch time. Use device command instead.',
+    });
+}
+async function handleDevice(command, browser) {
+    const device = browser.getDevice(command.device);
+    if (!device) {
+        const available = browser.listDevices().slice(0, 10).join(', ');
+        throw new Error(`Unknown device: ${command.device}. Available: ${available}...`);
+    }
+    // Apply device viewport
+    await browser.setViewport(device.viewport.width, device.viewport.height);
+    // Apply or clear device scale factor
+    if (device.deviceScaleFactor && device.deviceScaleFactor !== 1) {
+        // Apply device scale factor for HiDPI/retina displays
+        await browser.setDeviceScaleFactor(device.deviceScaleFactor, device.viewport.width, device.viewport.height, device.isMobile ?? false);
+    }
+    else {
+        // Clear device scale factor override to restore default (1x)
+        try {
+            await browser.clearDeviceMetricsOverride();
+        }
+        catch {
+            // Ignore error if override was never set
+        }
+    }
+    return successResponse(command.id, {
+        device: command.device,
+        viewport: device.viewport,
+        userAgent: device.userAgent,
+        deviceScaleFactor: device.deviceScaleFactor,
+    });
+}
+async function handleBack(command, browser) {
+    browser.recordStep({ action: 'back' });
+    const page = browser.getPage();
+    await page.goBack();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleForward(command, browser) {
+    browser.recordStep({ action: 'forward' });
+    const page = browser.getPage();
+    await page.goForward();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleReload(command, browser) {
+    browser.recordStep({ action: 'reload' });
+    const page = browser.getPage();
+    await page.reload();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleUrl(command, browser) {
+    if (command.inFrame) {
+        const frameLocator = browser.getFrame(command.inFrame);
+        // Get URL from frame by evaluating JavaScript on root locator
+        const url = await frameLocator.locator(':root').evaluate(() => window.location.href);
+        return successResponse(command.id, { url });
+    }
+    else {
+        const page = browser.getPage();
+        return successResponse(command.id, { url: page.url() });
+    }
+}
+async function handleTitle(command, browser) {
+    if (command.inFrame) {
+        const frameLocator = browser.getFrame(command.inFrame);
+        // Get title from frame by evaluating JavaScript on root locator
+        const title = await frameLocator.locator(':root').evaluate(() => document.title);
+        return successResponse(command.id, { title });
+    }
+    else {
+        const page = browser.getPage();
+        const title = await page.title();
+        return successResponse(command.id, { title });
+    }
+}
+async function handleGetAttribute(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const value = await locator.getAttribute(command.attribute);
+    return successResponse(command.id, { attribute: command.attribute, value });
+}
+async function handleGetText(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const text = await locator.textContent();
+    return successResponse(command.id, { text });
+}
+async function handleIsVisible(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const visible = await locator.isVisible({ timeout: 5000 });
+    return successResponse(command.id, { visible });
+}
+async function handleIsEnabled(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const enabled = await locator.isEnabled({ timeout: 5000 });
+    return successResponse(command.id, { enabled });
+}
+async function handleIsChecked(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const checked = await locator.isChecked({ timeout: 5000 });
+    return successResponse(command.id, { checked });
+}
+async function handleCount(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const count = await locator.count();
+    return successResponse(command.id, { count });
+}
+async function handleBoundingBox(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const box = await locator.boundingBox();
+    return successResponse(command.id, { box });
+}
+async function handleStyles(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    // Shared extraction logic as a string to be eval'd in browser context
+    const extractStylesScript = `(function(el) {
+    const s = getComputedStyle(el);
+    const r = el.getBoundingClientRect();
+    return {
+      tag: el.tagName.toLowerCase(),
+      text: el.innerText?.trim().slice(0, 80) || null,
+      box: {
+        x: Math.round(r.x),
+        y: Math.round(r.y),
+        width: Math.round(r.width),
+        height: Math.round(r.height),
+      },
+      styles: {
+        fontSize: s.fontSize,
+        fontWeight: s.fontWeight,
+        fontFamily: s.fontFamily.split(',')[0].trim().replace(/"/g, ''),
+        color: s.color,
+        backgroundColor: s.backgroundColor,
+        borderRadius: s.borderRadius,
+        border: s.border !== 'none' && s.borderWidth !== '0px' ? s.border : null,
+        boxShadow: s.boxShadow !== 'none' ? s.boxShadow : null,
+        padding: s.padding,
+      },
+    };
+  })`;
+    // Check if it's a ref - single element
+    if (browser.isRef(command.selector)) {
+        const locator = browser.getLocator(command.selector);
+        const element = (await locator.evaluate((el, script) => {
+            const fn = eval(script);
+            return fn(el);
+        }, extractStylesScript));
+        return successResponse(command.id, { elements: [element] });
+    }
+    // CSS selector - can match multiple elements
+    const elements = (await frame.locator(command.selector).evaluateAll((els, script) => {
+        const fn = eval(script);
+        return els.map((el) => fn(el));
+    }, extractStylesScript));
+    return successResponse(command.id, { elements });
+}
+// Advanced handlers
+async function handleVideoStart(command, browser) {
+    // Video recording requires context-level setup at launch
+    // For now, return a note about this limitation
+    return successResponse(command.id, {
+        note: 'Video recording must be enabled at browser launch. Use --video flag when starting.',
+        path: command.path,
+    });
+}
+async function handleVideoStop(command, browser) {
+    const page = browser.getPage();
+    const video = page.video();
+    if (video) {
+        const path = await video.path();
+        return successResponse(command.id, { path });
+    }
+    return successResponse(command.id, { note: 'No video recording active' });
+}
+async function handleTraceStart(command, browser) {
+    await browser.startTracing({
+        screenshots: command.screenshots,
+        snapshots: command.snapshots,
+    });
+    return successResponse(command.id, { started: true });
+}
+async function handleTraceStop(command, browser) {
+    await browser.stopTracing(command.path);
+    return successResponse(command.id, { path: command.path });
+}
+async function handleHarStart(command, browser) {
+    await browser.startHarRecording();
+    browser.startRequestTracking();
+    return successResponse(command.id, { started: true });
+}
+async function handleHarStop(command, browser) {
+    // HAR recording is handled at context level
+    // For now, we save tracked requests as a simplified HAR-like format
+    const requests = browser.getRequests();
+    return successResponse(command.id, {
+        path: command.path,
+        requestCount: requests.length,
+    });
+}
+async function handleStateSave(command, browser) {
+    await browser.saveStorageState(command.path);
+    return successResponse(command.id, { path: command.path });
+}
+async function handleStateLoad(command, browser) {
+    // Storage state is loaded at context creation
+    return successResponse(command.id, {
+        note: 'Storage state must be loaded at browser launch. Use --state flag.',
+        path: command.path,
+    });
+}
+async function handleConsole(command, browser) {
+    if (command.clear) {
+        browser.clearConsoleMessages();
+        return successResponse(command.id, { cleared: true });
+    }
+    const messages = browser.getConsoleMessages();
+    return successResponse(command.id, { messages });
+}
+async function handleErrors(command, browser) {
+    if (command.clear) {
+        browser.clearPageErrors();
+        return successResponse(command.id, { cleared: true });
+    }
+    const errors = browser.getPageErrors();
+    return successResponse(command.id, { errors });
+}
+async function handleKeyboard(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.press(command.keys);
+    return successResponse(command.id, { pressed: command.keys });
+}
+async function handleWheel(command, browser) {
+    const page = browser.getPage();
+    if (command.selector) {
+        const element = page.locator(command.selector);
+        await element.hover();
+    }
+    await page.mouse.wheel(command.deltaX ?? 0, command.deltaY ?? 0);
+    return successResponse(command.id, { scrolled: true });
+}
+async function handleTap(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    await locator.tap();
+    return successResponse(command.id, { tapped: true });
+}
+async function handleClipboard(command, browser) {
+    const page = browser.getPage();
+    switch (command.operation) {
+        case 'copy':
+            await page.keyboard.press('Control+c');
+            return successResponse(command.id, { copied: true });
+        case 'paste':
+            await page.keyboard.press('Control+v');
+            return successResponse(command.id, { pasted: true });
+        case 'read':
+            const text = await page.evaluate('navigator.clipboard.readText()');
+            return successResponse(command.id, { text });
+        default:
+            return errorResponse(command.id, 'Unknown clipboard operation');
+    }
+}
+async function handleHighlight(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    await locator.highlight();
+    return successResponse(command.id, { highlighted: true });
+}
+async function handleClear(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    await locator.clear();
+    return successResponse(command.id, { cleared: true });
+}
+async function handleSelectAll(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    await locator.selectText();
+    return successResponse(command.id, { selected: true });
+}
+async function handleInnerText(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const text = await locator.innerText();
+    return successResponse(command.id, { text });
+}
+async function handleInnerHtml(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const html = await locator.innerHTML();
+    return successResponse(command.id, { html });
+}
+async function handleInputValue(command, browser) {
+    const locator = browser.getLocator(command.selector, command.inFrame);
+    const value = await locator.inputValue();
+    return successResponse(command.id, { value });
+}
+async function handleSetValue(command, browser) {
+    const page = browser.getPage();
+    await page.locator(command.selector).fill(command.value);
+    return successResponse(command.id, { set: true });
+}
+async function handleDispatch(command, browser) {
+    const page = browser.getPage();
+    await page.locator(command.selector).dispatchEvent(command.event, command.eventInit);
+    return successResponse(command.id, { dispatched: command.event });
+}
+async function handleEvalHandle(command, browser) {
+    const page = browser.getPage();
+    const handle = await page.evaluateHandle(command.script);
+    const result = await handle.jsonValue().catch(() => 'Handle (non-serializable)');
+    return successResponse(command.id, { result });
+}
+async function handleExpose(command, browser) {
+    const page = browser.getPage();
+    await page.exposeFunction(command.name, () => {
+        // Exposed function - can be extended
+        return `Function ${command.name} called`;
+    });
+    return successResponse(command.id, { exposed: command.name });
+}
+async function handleAddScript(command, browser) {
+    const page = browser.getPage();
+    if (command.content) {
+        await page.addScriptTag({ content: command.content });
+    }
+    else if (command.url) {
+        await page.addScriptTag({ url: command.url });
+    }
+    return successResponse(command.id, { added: true });
+}
+async function handleAddStyle(command, browser) {
+    const page = browser.getPage();
+    if (command.content) {
+        await page.addStyleTag({ content: command.content });
+    }
+    else if (command.url) {
+        await page.addStyleTag({ url: command.url });
+    }
+    return successResponse(command.id, { added: true });
+}
+async function handleEmulateMedia(command, browser) {
+    const page = browser.getPage();
+    await page.emulateMedia({
+        media: command.media,
+        colorScheme: command.colorScheme,
+        reducedMotion: command.reducedMotion,
+        forcedColors: command.forcedColors,
+    });
+    return successResponse(command.id, { emulated: true });
+}
+async function handleOffline(command, browser) {
+    await browser.setOffline(command.offline);
+    return successResponse(command.id, { offline: command.offline });
+}
+async function handleHeaders(command, browser) {
+    await browser.setExtraHeaders(command.headers);
+    return successResponse(command.id, { set: true });
+}
+async function handlePause(command, browser) {
+    const page = browser.getPage();
+    await page.pause();
+    return successResponse(command.id, { paused: true });
+}
+async function handleGetByAltText(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByAltText(command.text, { exact: command.exact });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleGetByTitle(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByTitle(command.text, { exact: command.exact });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleGetByTestId(command, browser) {
+    const frame = browser.getFrame(command.inFrame);
+    const locator = frame.getByTestId(command.testId);
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'fill':
+            await locator.fill(command.value ?? '');
+            return successResponse(command.id, { filled: true });
+        case 'check':
+            await locator.check();
+            return successResponse(command.id, { checked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleNth(command, browser) {
+    const refLocator = browser.getLocatorFromRef(command.selector, command.inFrame);
+    let locator;
+    if (refLocator) {
+        locator = refLocator;
+    }
+    else {
+        const frame = browser.getFrame(command.inFrame);
+        const base = frame.locator(command.selector);
+        locator = command.index === -1 ? base.last() : base.nth(command.index);
+    }
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'fill':
+            await locator.fill(command.value ?? '');
+            return successResponse(command.id, { filled: true });
+        case 'check':
+            await locator.check();
+            return successResponse(command.id, { checked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+        case 'text':
+            const text = await locator.textContent();
+            return successResponse(command.id, { text });
+    }
+}
+async function handleWaitForUrl(command, browser) {
+    const page = browser.getPage();
+    await page.waitForURL(command.url, { timeout: command.timeout });
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleWaitForLoadState(command, browser) {
+    const page = browser.getPage();
+    await page.waitForLoadState(command.state, { timeout: command.timeout });
+    return successResponse(command.id, { state: command.state });
+}
+async function handleSetContent(command, browser) {
+    const page = browser.getPage();
+    await page.setContent(command.html);
+    return successResponse(command.id, { set: true });
+}
+async function handleTimezone(command, browser) {
+    // Timezone must be set at context level before navigation
+    // This is a limitation - it sets for the current context
+    const page = browser.getPage();
+    await page.context().setGeolocation({ latitude: 0, longitude: 0 }); // Trigger context awareness
+    return successResponse(command.id, {
+        note: 'Timezone must be set at browser launch. Use --timezone flag.',
+        timezone: command.timezone,
+    });
+}
+async function handleLocale(command, browser) {
+    // Locale must be set at context creation
+    return successResponse(command.id, {
+        note: 'Locale must be set at browser launch. Use --locale flag.',
+        locale: command.locale,
+    });
+}
+async function handleCredentials(command, browser) {
+    const context = browser.getPage().context();
+    await context.setHTTPCredentials({
+        username: command.username,
+        password: command.password,
+    });
+    return successResponse(command.id, { set: true });
+}
+async function handleMouseMove(command, browser) {
+    const page = browser.getPage();
+    await page.mouse.move(command.x, command.y);
+    return successResponse(command.id, { moved: true, x: command.x, y: command.y });
+}
+async function handleMouseDown(command, browser) {
+    const page = browser.getPage();
+    await page.mouse.down({ button: command.button ?? 'left' });
+    return successResponse(command.id, { down: true });
+}
+async function handleMouseUp(command, browser) {
+    const page = browser.getPage();
+    await page.mouse.up({ button: command.button ?? 'left' });
+    return successResponse(command.id, { up: true });
+}
+async function handleWander(command, browser) {
+    const page = browser.getPage();
+    const viewport = page.viewportSize() ?? { width: 1280, height: 800 };
+    const config = command.human ?? { enabled: true, pathType: 'bezier' };
+    await humanWander(page, config, {
+        duration: command.duration ?? 2000,
+        area: viewport,
+    });
+    return successResponse(command.id, { wandered: true, duration: command.duration ?? 2000 });
+}
+/**
+ * Parse trajectory data string into array of points
+ * Format: "x:y:delay;x:y:delay;..."
+ */
+function parseTrajectoryData(data) {
+    return data.split(';').map((segment) => {
+        const parts = segment.split(':').map(Number);
+        return { x: parts[0] || 0, y: parts[1] || 0, delay: parts[2] || 0 };
+    });
+}
+async function handleMouseTrajectory(command, browser) {
+    const page = browser.getPage();
+    const points = parseTrajectoryData(command.data);
+    const config = command.human ?? { enabled: true, pathType: 'bezier' };
+    for (let i = 0; i < points.length; i++) {
+        const { x, y, delay } = points[i];
+        // Wait for the specified delay (except first point)
+        if (delay > 0) {
+            await page.waitForTimeout(delay);
+        }
+        // Move with human-like animation if enabled
+        if (config.enabled) {
+            await humanMoveTo(page, { x, y }, config);
+        }
+        else {
+            await page.mouse.move(x, y);
+        }
+    }
+    return successResponse(command.id, { moved: true, points: points.length });
+}
+async function handleBringToFront(command, browser) {
+    const page = browser.getPage();
+    await page.bringToFront();
+    return successResponse(command.id, { focused: true });
+}
+async function handleWaitForFunction(command, browser) {
+    const page = browser.getPage();
+    await page.waitForFunction(command.expression, { timeout: command.timeout });
+    return successResponse(command.id, { waited: true });
+}
+async function handleScrollIntoView(command, browser) {
+    const page = browser.getPage();
+    await page.locator(command.selector).scrollIntoViewIfNeeded();
+    return successResponse(command.id, { scrolled: true });
+}
+async function handleAddInitScript(command, browser) {
+    const context = browser.getPage().context();
+    await context.addInitScript(command.script);
+    return successResponse(command.id, { added: true });
+}
+async function handleKeyDown(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.down(command.key);
+    return successResponse(command.id, { down: true, key: command.key });
+}
+async function handleKeyUp(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.up(command.key);
+    return successResponse(command.id, { up: true, key: command.key });
+}
+async function handleInsertText(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.insertText(command.text);
+    return successResponse(command.id, { inserted: true });
+}
+async function handleMultiSelect(command, browser) {
+    const page = browser.getPage();
+    const selected = await page.locator(command.selector).selectOption(command.values);
+    return successResponse(command.id, { selected });
+}
+async function handleWaitForDownload(command, browser) {
+    const page = browser.getPage();
+    const download = await page.waitForEvent('download', { timeout: command.timeout });
+    let filePath;
+    if (command.path) {
+        filePath = command.path;
+        await download.saveAs(filePath);
+    }
+    else {
+        filePath = (await download.path()) || download.suggestedFilename();
+    }
+    return successResponse(command.id, {
+        path: filePath,
+        filename: download.suggestedFilename(),
+        url: download.url(),
+    });
+}
+async function handleResponseBody(command, browser) {
+    const page = browser.getPage();
+    const response = await page.waitForResponse((resp) => resp.url().includes(command.url), {
+        timeout: command.timeout,
+    });
+    const body = await response.text();
+    let parsed = body;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        // Keep as string if not JSON
+    }
+    return successResponse(command.id, {
+        url: response.url(),
+        status: response.status(),
+        body: parsed,
+    });
+}
+// Screencast and input injection handlers
+async function handleScreencastStart(command, browser) {
+    if (!screencastFrameCallback) {
+        throw new Error('Screencast frame callback not set. Start the streaming server first.');
+    }
+    await browser.startScreencast(screencastFrameCallback, {
+        format: command.format,
+        quality: command.quality,
+        maxWidth: command.maxWidth,
+        maxHeight: command.maxHeight,
+        everyNthFrame: command.everyNthFrame,
+    });
+    return successResponse(command.id, {
+        started: true,
+        format: command.format ?? 'jpeg',
+        quality: command.quality ?? 80,
+    });
+}
+async function handleScreencastStop(command, browser) {
+    await browser.stopScreencast();
+    return successResponse(command.id, { stopped: true });
+}
+async function handleInputMouse(command, browser) {
+    await browser.injectMouseEvent({
+        type: command.type,
+        x: command.x,
+        y: command.y,
+        button: command.button,
+        clickCount: command.clickCount,
+        deltaX: command.deltaX,
+        deltaY: command.deltaY,
+        modifiers: command.modifiers,
+    });
+    return successResponse(command.id, { injected: true });
+}
+async function handleInputKeyboard(command, browser) {
+    await browser.injectKeyboardEvent({
+        type: command.type,
+        key: command.key,
+        code: command.code,
+        text: command.text,
+        modifiers: command.modifiers,
+    });
+    return successResponse(command.id, { injected: true });
+}
+async function handleInputTouch(command, browser) {
+    await browser.injectTouchEvent({
+        type: command.type,
+        touchPoints: command.touchPoints,
+        modifiers: command.modifiers,
+    });
+    return successResponse(command.id, { injected: true });
+}
+// Recording handlers (Playwright native video recording)
+async function handleRecordingStart(command, browser) {
+    await browser.startRecording(command.path, command.url);
+    return successResponse(command.id, {
+        started: true,
+        path: command.path,
+    });
+}
+async function handleRecordingStop(command, browser) {
+    const result = await browser.stopRecording();
+    return successResponse(command.id, result);
+}
+async function handleRecordingRestart(command, browser) {
+    const result = await browser.restartRecording(command.path, command.url);
+    return successResponse(command.id, {
+        started: true,
+        path: command.path,
+        previousPath: result.previousPath,
+        stopped: result.stopped,
+    });
+}
+async function handleRecorderStart(command, browser) {
+    const result = await browser.startRecorder(command.url, command.hide);
+    return successResponse(command.id, result);
+}
+async function handleRecorderStop(command, browser) {
+    const result = await browser.stopRecorder();
+    // 如果没有在录制中，返回提示但仍尝试获取最近的录制文件
+    if (result.wasRecording === false) {
+        // 尝试获取最近的录制文件
+        const recorderDir = path.join(getAppDir(), 'tmp', 'recordings');
+        if (existsSync(recorderDir)) {
+            const files = readdirSync(recorderDir)
+                .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+                .map((f) => ({
+                name: f,
+                time: statSync(path.join(recorderDir, f)).mtime.getTime(),
+            }))
+                .sort((a, b) => b.time - a.time);
+            if (files.length > 0) {
+                const recentPath = path.join(recorderDir, files[0].name);
+                return successResponse(command.id, {
+                    yaml: '',
+                    steps: 0,
+                    path: recentPath,
+                    note: 'No active recording session. Returning most recent recording file.',
+                });
+            }
+        }
+        return successResponse(command.id, {
+            yaml: '',
+            steps: 0,
+            note: 'No active recording session. Use "recorder start" to begin recording.',
+        });
+    }
+    // 确定输出路径
+    let outputPath;
+    let isDefaultPath = false;
+    if (command.output) {
+        outputPath = path.resolve(command.output);
+    }
+    else {
+        // 默认保存到临时目录
+        const recorderDir = path.join(getAppDir(), 'tmp', 'recordings');
+        if (!existsSync(recorderDir)) {
+            mkdirSync(recorderDir, { recursive: true });
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        outputPath = path.join(recorderDir, `session-${timestamp}.yaml`);
+        isDefaultPath = true;
+    }
+    // 保存文件
+    writeFileSync(outputPath, result.yaml, 'utf-8');
+    // 返回 YAML 内容和路径
+    return successResponse(command.id, {
+        yaml: result.yaml,
+        steps: result.steps,
+        path: outputPath,
+        tip: isDefaultPath ? `Full YAML saved to: ${outputPath}` : undefined,
+    });
+}
+async function handleRecorderStatus(command, browser) {
+    const result = browser.getRecorderStatus();
+    return successResponse(command.id, result);
+}
+/**
+ * Parse and execute CLI commands from YAML file
+ */
+async function handleRecorderReplay(command, browser) {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    // Determine YAML file path
+    let yamlPath = command.path;
+    if (!yamlPath) {
+        // Use the most recent recording from temp directory
+        const recorderDir = path.join(getAppDir(), 'tmp', 'recordings');
+        console.log('[Replay] Looking for recordings in:', recorderDir);
+        if (!fs.existsSync(recorderDir)) {
+            console.log('[Replay] Directory does not exist');
+            return errorResponse(command.id, 'No recordings found. Please record first.');
+        }
+        const files = fs
+            .readdirSync(recorderDir)
+            .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+            .map((f) => ({
+            name: f,
+            time: fs.statSync(path.join(recorderDir, f)).mtime.getTime(),
+        }))
+            .sort((a, b) => b.time - a.time);
+        console.log('[Replay] Found files:', files.length);
+        if (files.length === 0) {
+            return errorResponse(command.id, 'No recordings found. Please record first.');
+        }
+        yamlPath = path.join(recorderDir, files[0].name);
+        console.log('[Replay] Using file:', yamlPath);
+    }
+    // Read YAML file
+    if (!fs.existsSync(yamlPath)) {
+        return errorResponse(command.id, `Recording file not found: ${yamlPath}`);
+    }
+    const yamlContent = fs.readFileSync(yamlPath, 'utf-8');
+    // Parse CLI commands from YAML
+    const lines = yamlContent.split('\n');
+    const cliCommands = [];
+    let inCliSection = false;
+    for (const line of lines) {
+        if (line.includes('# CLI Commands')) {
+            inCliSection = true;
+            continue;
+        }
+        if (inCliSection &&
+            (line.startsWith('agent-browser ') || line.startsWith('AGENT_BROWSER_HUMAN='))) {
+            cliCommands.push(line.trim());
+        }
+    }
+    if (cliCommands.length === 0) {
+        return errorResponse(command.id, 'No CLI commands found in recording. Please re-record with the new version.');
+    }
+    // Helper function to parse command line with proper quote handling
+    function parseCommandLine(line) {
+        const parts = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = '';
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            }
+            else if (char === ' ' && !inQuotes) {
+                if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            parts.push(current);
+        }
+        return parts;
+    }
+    // Execute each command
+    const results = [];
+    for (const cmdLine of cliCommands) {
+        try {
+            // Parse command line with proper quote handling
+            let parts = parseCommandLine(cmdLine);
+            const envVars = {};
+            // Extract environment variables (format: KEY=value)
+            while (parts.length > 0 && parts[0].includes('=')) {
+                const [key, ...valueParts] = parts.shift().split('=');
+                envVars[key] = valueParts.join('=');
+            }
+            // Remove 'agent-browser' prefix if present
+            if (parts.length > 0 && parts[0] === 'agent-browser') {
+                parts = parts.slice(1);
+            }
+            // Skip empty commands
+            if (parts.length === 0) {
+                results.push({ command: cmdLine, success: true });
+                continue;
+            }
+            // Set environment variables temporarily
+            const originalEnv = {};
+            for (const [key, value] of Object.entries(envVars)) {
+                originalEnv[key] = process.env[key];
+                process.env[key] = value;
+            }
+            // Execute command using the existing executeCommand flow
+            const { parseCommand } = await import('./cli/commands.js');
+            const { parseFlags } = await import('./cli/flags.js');
+            const flags = parseFlags([]);
+            const parsedCmd = parseCommand(parts, flags);
+            // Check if recording is active, and temporarily disable
+            const wasRecording = browser.isRecordingSession();
+            if (wasRecording) {
+                browser.pauseRecording();
+            }
+            // Execute the command with a timeout to prevent hanging on invalid selectors
+            const COMMAND_TIMEOUT_MS = 5000;
+            const result = (await Promise.race([
+                executeCommand(parsedCmd, browser),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Command timed out after ${COMMAND_TIMEOUT_MS}ms`)), COMMAND_TIMEOUT_MS)),
+            ]));
+            // Restore recording state
+            if (wasRecording) {
+                browser.resumeRecording();
+            }
+            // Restore environment variables
+            for (const [key, value] of Object.entries(originalEnv)) {
+                if (value === undefined) {
+                    delete process.env[key];
+                }
+                else {
+                    process.env[key] = value;
+                }
+            }
+            results.push({ command: cmdLine, success: result.success });
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            results.push({ command: cmdLine, success: false, error: errorMessage });
+        }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.filter((r) => !r.success).length;
+    return successResponse(command.id, {
+        replayed: true,
+        file: yamlPath,
+        totalCommands: cliCommands.length,
+        successCount,
+        failCount,
+        results: results.slice(0, 20), // Only return first 20 results
+    });
+}
+async function handleViewer(command, _browser) {
+    const instanceId = getInstanceId();
+    const port = parseInt(process.env.AGENT_BROWSER_STREAM_PORT || '5005', 10);
+    return successResponse(command.id, {
+        url: `http://localhost:${port}/view?instanceId=${instanceId}`,
+        wsUrl: `ws://localhost:${port}?instanceId=${instanceId}`,
+        streamPort: port,
+    });
+}
+async function handleAsk(command, _browser) {
+    const session = getSession();
+    const bridge = new MessageBridge();
+    try {
+        const answer = await bridge.ask(command.question, session);
+        return successResponse(command.id, { answer });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResponse(command.id, `Failed to ask question: ${message}`);
+    }
+}
+function handleConfig(command) {
+    const humanConfig = getHumanConfigFromEnv();
+    const config = {
+        session: process.env.AGENT_BROWSER_SESSION || 'default',
+        executablePath: process.env.AGENT_BROWSER_EXECUTABLE_PATH || null,
+        extensions: process.env.AGENT_BROWSER_EXTENSIONS || null,
+        profile: process.env.AGENT_BROWSER_PROFILE || null,
+        state: process.env.AGENT_BROWSER_STATE || null,
+        proxy: process.env.AGENT_BROWSER_PROXY || null,
+        proxyBypass: process.env.AGENT_BROWSER_PROXY_BYPASS || null,
+        args: process.env.AGENT_BROWSER_ARGS || null,
+        userAgent: process.env.AGENT_BROWSER_USER_AGENT || null,
+        provider: process.env.AGENT_BROWSER_PROVIDER || null,
+        allowFileAccess: process.env.AGENT_BROWSER_ALLOW_FILE_ACCESS === '1',
+        iosDevice: process.env.AGENT_BROWSER_IOS_DEVICE || null,
+        streamPort: process.env.AGENT_BROWSER_STREAM_PORT || null,
+        headed: process.env.AGENT_BROWSER_HEADED === '1',
+        human: humanConfig,
+    };
+    if (command.json) {
+        return successResponse(command.id, { config });
+    }
+    // Format human-readable output
+    const lines = [
+        'Agent Browser Configuration',
+        '===========================',
+        '',
+        'Session & Browser:',
+        `  AGENT_BROWSER_SESSION          ${config.session}`,
+        `  AGENT_BROWSER_EXECUTABLE_PATH  ${config.executablePath || '(not set)'}`,
+        `  AGENT_BROWSER_PROVIDER         ${config.provider || '(not set)'}`,
+        `  AGENT_BROWSER_HEADED           ${config.headed ? 'true' : 'false (default)'}`,
+        '',
+        'Browser Options:',
+        `  AGENT_BROWSER_PROFILE          ${config.profile || '(not set)'}`,
+        `  AGENT_BROWSER_EXTENSIONS       ${config.extensions || '(not set)'}`,
+        `  AGENT_BROWSER_ARGS             ${config.args || '(not set)'}`,
+        `  AGENT_BROWSER_USER_AGENT       ${config.userAgent || '(not set)'}`,
+        `  AGENT_BROWSER_PROXY            ${config.proxy || '(not set)'}`,
+        `  AGENT_BROWSER_ALLOW_FILE_ACCESS ${config.allowFileAccess ? 'true' : 'false (default)'}`,
+        '',
+        'Human Mode (runtime):',
+        `  AGENT_BROWSER_HUMAN            ${humanConfig.enabled ? humanConfig.pathType + ' ✓' : '(disabled)'}`,
+        '',
+        'Note: Most settings only take effect at browser startup.',
+        'Use "export AGENT_BROWSER_XXX=value" before starting.',
+    ];
+    return successResponse(command.id, { config, output: lines.join('\n') });
+}
+//# sourceMappingURL=actions.js.map