@dyyz1993/agent-browser 0.25.0 → 0.26.1

package/dist/actions.js

@@ -1,2662 +0,0 @@
-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 { getViewerUrl, getViewerWsUrl, getViewerPort, getMessageBridgeUrl, getExecutablePath, getEffectiveValue, loadConfig, } from './rc-config.js';
-import { detectMainContent, generateContentTips } from './content-detection.js';
-import { humanClick, humanType, humanMoveTo, humanWander, getHumanConfigFromEnv, } from './human-mouse.js';
-import { successResponse, errorResponse } from './protocol.js';
-import { parseYamlSiteFile, loadSitesFromDirectory, loadAllSites, findFlow, validateYamlFile, } from './flow/yaml-parser.js';
-import { recorderToFlowFromFile, siteToYamlString } from './flow/recorder-to-flow.js';
-import { FlowExecutor } from './flow/flow-executor.js';
-import { PlaywrightExporter, PythonExporter, CypressExporter, SeleniumExporter, } from './flow/exporters/index.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;
-}
-/**
- * Quick check if element exists before performing action.
- * This avoids waiting for timeout when element is clearly not present.
- */
-async function assertElementExists(locator, selector, isRef) {
-    const count = await locator.count();
-    if (count === 0) {
-        if (isRef) {
-            throw new Error(`Element ref "${selector}" not found. ` + `Run 'snapshot' to get updated element refs.`);
-        }
-        else {
-            throw new Error(`No element matches selector "${selector}". ` + `Run 'snapshot' to see available elements.`);
-        }
-    }
-}
-/**
- * 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);
-    if (message.includes('strict mode violation')) {
-        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. ` +
-            `Tip: Use 'find nth <index> ${selector} --click' to target a specific match.`);
-    }
-    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. ` +
-            `Tip: Run 'snapshot -i' to see all visible elements and identify what's blocking.`);
-    }
-    if (message.includes('not visible') && !message.includes('Timeout')) {
-        return new Error(`Element "${selector}" is not visible. ` +
-            `Try 'scrollintoview ${selector}' or check if it's hidden. ` +
-            `Tip: Run 'is visible ${selector}' to confirm visibility state.`);
-    }
-    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. ` +
-            `Tip: If the page is still loading, try 'wait --load networkidle' first.`);
-    }
-    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 -i' to see current page elements and their refs. ` +
-            `Tip: If using @ref, the page may have changed. Re-run 'snapshot -i' to get fresh refs.`);
-    }
-    if (message.includes('Execution context was destroyed') || message.includes('Target closed')) {
-        return new Error(`Browser context was lost (page navigated or closed). ` +
-            `Re-open the page with 'open <url>' and start fresh. ` +
-            `Tip: This usually happens after a form submission triggers navigation.`);
-    }
-    if (message.includes('querySelector') || message.includes('is not a valid selector')) {
-        return new Error(`Invalid selector "${selector}". ` +
-            `CSS selectors like '#id', '.class', or 'tag' are supported. ` +
-            `Tip: Use 'snapshot -i' to get @ref selectors (e.g., @e1) that are always valid.`);
-    }
-    return error instanceof Error ? error : new Error(message);
-}
-/**
- * Execute a command and return a response
- */
-export async function executeCommand(command, browser) {
-    try {
-        if (command.action === 'flow') {
-            return await handleFlowAction(command, browser);
-        }
-        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 'frames':
-                return await handleFrames(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 'websockets':
-                return await handleWebSockets(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);
-            case 'history':
-                return await handleHistory(cmd, browser);
-            case 'selector-for':
-                return await handleSelectorFor(cmd, browser);
-            case 'selectors-of':
-                return await handleSelectorsOf(cmd, browser);
-            case 'validate':
-                return await handleValidate(cmd, browser);
-            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: getViewerUrl(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 ?? 'domcontentloaded',
-        timeout: command.timeout ?? 30000,
-    });
-    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);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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;
-        }
-        browser.recordCommand('click', command.selector, undefined, true);
-        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;
-    }
-    browser.recordCommand('click', command.selector, undefined, true);
-    return successResponse(command.id, result);
-}
-async function handleType(command, browser) {
-    const locator = browser.getLocator(command.selector, command.inFrame);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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;
-        }
-        browser.recordCommand('type', command.selector, command.text, true);
-        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;
-    }
-    browser.recordCommand('type', command.selector, command.text, true);
-    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;
-    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,
-        selectors: command.selectors,
-        all: command.all,
-    });
-    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) {
-            const resolvedPath = path.resolve(command.file);
-            const cwd = process.cwd();
-            if (!resolvedPath.startsWith(cwd)) {
-                throw new Error(`Security: file path must be within project directory. Got: ${resolvedPath}`);
-            }
-            if (!existsSync(resolvedPath)) {
-                throw new Error(`Script file not found: ${resolvedPath}`);
-            }
-            script = readFileSync(resolvedPath, '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);
-        }
-        browser.recordCommand('eval', 'javascript', script.length > 200 ? script.substring(0, 200) + '...' : script, true);
-        return successResponse(command.id, { result });
-    }
-    catch (error) {
-        const script = command.script || command.file || '';
-        browser.recordCommand('eval', 'javascript', script.length > 200 ? script.substring(0, 200) + '...' : script, false);
-        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;
-            }
-        }
-        const safeDeltaX = Number(deltaX) || 0;
-        const safeDeltaY = Number(deltaY) || 0;
-        await page.evaluate(({ dx, dy }) => window.scrollBy(dx, dy), {
-            dx: safeDeltaX,
-            dy: safeDeltaY,
-        });
-    }
-    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 isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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;
-    }
-    browser.recordCommand('select', command.selector, values.join(','), true);
-    return successResponse(command.id, result);
-}
-async function handleHover(command, browser) {
-    const locator = browser.getLocator(command.selector, command.inFrame);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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 handleFrames(command, browser) {
-    const frames = browser.listFrames();
-    if (frames.length === 0) {
-        return successResponse(command.id, {
-            frames: [],
-            tip: 'No iframes found on this page.',
-        });
-    }
-    return successResponse(command.id, { frames });
-}
-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);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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;
-        }
-        browser.recordCommand('fill', command.selector, command.value, true);
-        return successResponse(command.id, result);
-    }
-    const diffResult = await performDiff(locator, command.diffScope, async () => {
-        try {
-            await locator.fill(command.value);
-            if (!isRef) {
-                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;
-    }
-    browser.recordCommand('fill', command.selector, command.value, true);
-    return successResponse(command.id, result);
-}
-async function handleCheck(command, browser) {
-    const locator = browser.getLocator(command.selector, command.inFrame);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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;
-    }
-    browser.recordCommand('check', command.selector, undefined, true);
-    return successResponse(command.id, result);
-}
-async function handleUncheck(command, browser) {
-    const locator = browser.getLocator(command.selector, command.inFrame);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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;
-    }
-    browser.recordCommand('uncheck', command.selector, undefined, true);
-    return successResponse(command.id, result);
-}
-async function handleUpload(command, browser) {
-    const locator = browser.getLocator(command.selector, command.inFrame);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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);
-    const isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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 isRef = browser.isRef(command.selector);
-    // Quick check: fail fast if element doesn't exist
-    await assertElementExists(locator, command.selector, isRef);
-    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);
-    // Quick check: fail fast if elements don't exist
-    const isSourceRef = browser.isRef(command.source);
-    const isTargetRef = browser.isRef(command.target);
-    await assertElementExists(sourceLocator, command.source, isSourceRef);
-    await assertElementExists(targetLocator, command.target, isTargetRef);
-    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,
-    });
-    try {
-        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 });
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes('strict mode violation')) {
-            const countMatch = msg.match(/resolved to (\d+) elements/);
-            const count = countMatch ? countMatch[1] : 'multiple';
-            const first = locator.first();
-            const warning = `Matched ${count} elements, used first match. Use 'find nth <index> role "${command.role}" --click' for a specific match.`;
-            switch (command.subaction) {
-                case 'click':
-                    await first.click();
-                    return successResponse(command.id, { clicked: true, warning });
-                case 'fill':
-                    await first.fill(command.value ?? '');
-                    return successResponse(command.id, { filled: true, warning });
-                case 'check':
-                    await first.check();
-                    return successResponse(command.id, { checked: true, warning });
-                case 'hover':
-                    await first.hover();
-                    return successResponse(command.id, { hovered: true, warning });
-            }
-        }
-        throw error;
-    }
-    return successResponse(command.id, {});
-}
-async function handleGetByText(command, browser) {
-    const frame = browser.getFrame(command.inFrame);
-    const locator = frame.getByText(command.text, { exact: command.exact });
-    try {
-        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 });
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes('strict mode violation')) {
-            const countMatch = msg.match(/resolved to (\d+) elements/);
-            const count = countMatch ? countMatch[1] : 'multiple';
-            const first = locator.first();
-            switch (command.subaction) {
-                case 'click':
-                    await first.click();
-                    return successResponse(command.id, {
-                        clicked: true,
-                        warning: `Matched ${count} elements, used first match. Use 'find nth <index> text "${command.text}" --click' for a specific match.`,
-                    });
-                case 'hover':
-                    await first.hover();
-                    return successResponse(command.id, {
-                        hovered: true,
-                        warning: `Matched ${count} elements, used first match. Use 'find nth <index> text "${command.text}" --hover' for a specific match.`,
-                    });
-            }
-        }
-        throw error;
-    }
-    return successResponse(command.id, {});
-}
-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 (with response capture if requested)
-    const wasTracking = browser.trackingEnabled;
-    browser.startRequestTracking(command.captureResponse);
-    // If output directory is specified, save to directory
-    if (command.output) {
-        const result = browser.saveRequestsToDir(command.output, command.filter, command.type);
-        return successResponse(command.id, {
-            saved: true,
-            savedCount: result.savedCount,
-            outputPath: result.outputPath,
-            indexPath: result.indexPath,
-        });
-    }
-    const requests = browser.getRequests(command.filter, command.type);
-    const result = { requests };
-    if (requests.length === 0 && !wasTracking) {
-        result.hint = 'Request tracking just activated. Reload or navigate to capture requests.';
-    }
-    return successResponse(command.id, result);
-}
-async function handleWebSockets(command, browser) {
-    if (command.clear) {
-        browser.clearWebSockets();
-        return successResponse(command.id, { cleared: true });
-    }
-    const wasTracking = browser.wsTrackingEnabled;
-    browser.startWebSocketTracking();
-    const sockets = browser.getWebSockets(command.filter);
-    const result = { websockets: sockets };
-    if (sockets.length === 0 && !wasTracking) {
-        result.hint = 'WebSocket tracking just activated. Reload or navigate to capture connections.';
-    }
-    return successResponse(command.id, result);
-}
-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 = new Function('return ' + 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 = new Function('return ' + 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 = command.index === -1 ? refLocator.last() : refLocator.nth(command.index);
-    }
-    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 });
-}
-export async function handleAddInitScript(command, browser) {
-    const page = browser.getPage();
-    const context = page.context();
-    await context.addInitScript(command.script);
-    const tips = [];
-    try {
-        await page.evaluate(command.script);
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        tips.push(`Init script error on current page: ${msg}. Script will work on next navigation.`);
-    }
-    return successResponse(command.id, { added: true }, tips.length ? tips : undefined);
-}
-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');
-    let yamlPath = command.path;
-    if (!yamlPath) {
-        const recorderDir = path.join(getAppDir(), 'tmp', 'recordings');
-        if (!fs.existsSync(recorderDir)) {
-            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);
-        if (files.length === 0) {
-            return errorResponse(command.id, 'No recordings found. Please record first.');
-        }
-        yamlPath = path.join(recorderDir, files[0].name);
-    }
-    if (!fs.existsSync(yamlPath)) {
-        return errorResponse(command.id, `Recording file not found: ${yamlPath}`);
-    }
-    const yamlContent = fs.readFileSync(yamlPath, 'utf-8');
-    const cliCommands = [];
-    // Strategy 1: Parse structured steps and generate CLI commands
-    const stepRegex = /^\s+-\s+(?:id:\s*.+)/;
-    const lines = yamlContent.split('\n');
-    let inSteps = false;
-    const parsedSteps = {};
-    for (const line of lines) {
-        if (/^steps:/.test(line.trim())) {
-            inSteps = true;
-            continue;
-        }
-        if (inSteps && /^-\s+id:/.test(line.trim())) {
-            const idMatch = line.match(/id:\s*(.+)/);
-            if (idMatch)
-                parsedSteps.currentId = idMatch[1].trim();
-        }
-        if (inSteps && /^\s+action:\s*(.+)/.test(line)) {
-            // End of steps section when we hit a non-step line
-        }
-        if (inSteps && !/^\s/.test(line) && !/^$/.test(line) && !/^steps:/.test(line.trim())) {
-            inSteps = false;
-        }
-    }
-    // Strategy 2: Fall back to CLI Commands comment section
-    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());
-        }
-    }
-    // Strategy 3: If no CLI section, generate from structured steps using browser's method
-    if (cliCommands.length === 0) {
-        return errorResponse(command.id, 'No CLI commands found in recording. Please re-record with the new version.');
-    }
-    // Filter out env-only lines (keep them for env setup but not as commands)
-    const envLines = cliCommands.filter((l) => l.startsWith('AGENT_BROWSER_'));
-    const cmdLines = cliCommands.filter((l) => l.startsWith('agent-browser '));
-    // Set env vars from recording (skip AGENT_BROWSER_HUMAN to avoid
-    // human-mode coordinate issues during replay where elements may be
-    // scrolled off-screen)
-    const originalEnv = {};
-    for (const envLine of envLines) {
-        const eqIdx = envLine.indexOf('=');
-        if (eqIdx > 0) {
-            const key = envLine.substring(0, eqIdx);
-            if (key === 'AGENT_BROWSER_HUMAN')
-                continue;
-            let value = envLine.substring(eqIdx + 1);
-            const spaceIdx = value.indexOf(' ');
-            if (spaceIdx > 0) {
-                value = value.substring(0, spaceIdx);
-            }
-            originalEnv[key] = process.env[key];
-            process.env[key] = value;
-        }
-    }
-    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;
-    }
-    // Get current session for passthrough
-    const currentSession = process.env.AGENT_BROWSER_SESSION || 'default';
-    const results = [];
-    for (const cmdLine of cmdLines) {
-        try {
-            let parts = parseCommandLine(cmdLine);
-            if (parts.length > 0 && parts[0] === 'agent-browser') {
-                parts = parts.slice(1);
-            }
-            if (parts.length === 0) {
-                results.push({ command: cmdLine, success: true });
-                continue;
-            }
-            const { parseCommand } = await import('./cli/commands.js');
-            const { parseFlags } = await import('./cli/flags.js');
-            const flags = parseFlags([]);
-            if (currentSession !== 'default') {
-                flags.session = currentSession;
-            }
-            const parsedCmd = parseCommand(parts, flags);
-            const wasRecording = browser.isRecordingSession();
-            if (wasRecording) {
-                browser.pauseRecording();
-            }
-            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)),
-            ]));
-            if (wasRecording) {
-                browser.resumeRecording();
-            }
-            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 });
-        }
-    }
-    // Restore env vars
-    for (const [key, value] of Object.entries(originalEnv)) {
-        if (value === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = value;
-        }
-    }
-    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: cmdLines.length,
-        successCount,
-        failCount,
-        results: results.slice(0, 20),
-    });
-}
-async function handleViewer(command, _browser) {
-    const instanceId = getInstanceId();
-    return successResponse(command.id, {
-        url: getViewerUrl(instanceId),
-        wsUrl: getViewerWsUrl(instanceId),
-        streamPort: getViewerPort(),
-    });
-}
-async function handleAsk(command, _browser) {
-    const session = getSession();
-    const bridge = new MessageBridge(getMessageBridgeUrl());
-    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 rcConfig = loadConfig();
-    const config = {
-        session: process.env.AGENT_BROWSER_SESSION || 'default',
-        executablePath: getExecutablePath() || 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',
-        streamPort: getViewerPort(),
-        headed: process.env.AGENT_BROWSER_HEADED === '1',
-        human: humanConfig,
-    };
-    if (command.json) {
-        return successResponse(command.id, { config, rc: rcConfig });
-    }
-    const viewerHost = getEffectiveValue('viewer.host');
-    const bridgeUrl = getEffectiveValue('messageBridge.url');
-    const msgProxy = getEffectiveValue('messageProxy.url');
-    // Format human-readable output
-    const lines = [
-        'Agent Browser Configuration',
-        '===========================',
-        '',
-        'Session & Browser:',
-        `  executablePath                 ${config.executablePath || '(not set)'}`,
-        `  AGENT_BROWSER_PROVIDER         ${config.provider || '(not set)'}`,
-        `  AGENT_BROWSER_HEADED           ${config.headed ? 'true' : 'false (default)'}`,
-        '',
-        'Viewer & Stream:',
-        `  viewer.host                    ${viewerHost || '(not set, using http://localhost)'}`,
-        `  viewer.port                    ${config.streamPort}`,
-        '',
-        'Message Bridge (ask command):',
-        `  messageBridge.url              ${bridgeUrl || '(not set, using default)'}`,
-        `  messageProxy.url               ${msgProxy || '(not set)'}`,
-        '',
-        '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)'}`,
-        '',
-        `Persistent config: ~/.agent-browser/config.json`,
-        'Run "agent-browser config set <key> <value>" to persist settings.',
-        'Run "agent-browser config list" to see configurable keys.',
-    ];
-    return successResponse(command.id, { config, output: lines.join('\n') });
-}
-async function handleHistory(command, browser) {
-    if (command.clear) {
-        browser.clearHistory();
-        return successResponse(command.id, { cleared: true });
-    }
-    const history = browser.getHistory(command.filter);
-    return successResponse(command.id, { history });
-}
-async function handleSelectorFor(command, browser) {
-    const store = browser.getSnapshotStore();
-    const colonIndex = command.target.indexOf(':');
-    if (colonIndex === -1) {
-        return errorResponse(command.id, `Invalid target format: "${command.target}". Expected "snapshotId:refOrIndex" (e.g., "snap_3:@e1" or "snap_3:1").`);
-    }
-    const snapshotId = command.target.substring(0, colonIndex);
-    const refOrIndex = command.target.substring(colonIndex + 1);
-    await browser.ensureSelectorsGenerated(snapshotId);
-    const element = store.getElement(snapshotId, refOrIndex);
-    if (!element) {
-        return errorResponse(command.id, `Element not found: "${refOrIndex}" in snapshot "${snapshotId}". Run 'snapshot' to get fresh snapshot data.`);
-    }
-    return successResponse(command.id, {
-        snapshotId,
-        ref: element.ref,
-        index: element.index,
-        role: element.role,
-        name: element.name,
-        cssSelector: element.cssSelector,
-        xpath: element.xpath,
-    });
-}
-async function handleSelectorsOf(command, browser) {
-    const store = browser.getSnapshotStore();
-    await browser.ensureSelectorsGenerated(command.target);
-    const elements = store.getElements(command.target);
-    if (!elements) {
-        return errorResponse(command.id, `Snapshot "${command.target}" not found. Run 'snapshot' to create a new snapshot.`);
-    }
-    return successResponse(command.id, {
-        snapshotId: command.target,
-        elements: elements.map((el) => ({
-            ref: el.ref,
-            index: el.index,
-            role: el.role,
-            name: el.name,
-            cssSelector: el.cssSelector,
-            xpath: el.xpath,
-        })),
-    });
-}
-async function handleValidate(command, browser) {
-    const store = browser.getSnapshotStore();
-    await browser.ensureSelectorsGenerated(command.target);
-    const elements = store.getElements(command.target);
-    if (!elements) {
-        return errorResponse(command.id, `Snapshot "${command.target}" not found. Run 'snapshot' to create a new snapshot.`);
-    }
-    const page = browser.getPage();
-    const selectors = elements.map((el) => el.cssSelector);
-    const matchCounts = await page.evaluate((sels) => {
-        return sels.map((sel) => {
-            try {
-                return document.querySelectorAll(sel).length;
-            }
-            catch {
-                return -1;
-            }
-        });
-    }, selectors);
-    const results = elements.map((el, i) => {
-        const matchCount = matchCounts[i];
-        let status;
-        if (matchCount === -1) {
-            status = 'invalid_selector';
-        }
-        else if (matchCount === 0) {
-            status = 'not_found';
-        }
-        else if (matchCount === 1) {
-            status = 'valid';
-        }
-        else {
-            status = 'ambiguous';
-        }
-        return {
-            ref: el.ref,
-            index: el.index,
-            cssSelector: el.cssSelector,
-            status,
-            matchCount,
-        };
-    });
-    const failedCount = results.filter((r) => r.status === 'not_found' || r.status === 'invalid_selector').length;
-    let newSnapshotId;
-    if (failedCount > 0) {
-        const newSnapshot = await browser.getSnapshot({ interactive: true });
-        newSnapshotId = newSnapshot.snapshotId;
-    }
-    return successResponse(command.id, {
-        snapshotId: command.target,
-        results,
-        newSnapshotId,
-    });
-}
-async function handleFlowAction(command, browser) {
-    const cmd = command;
-    const subcommand = cmd.subcommand;
-    switch (subcommand) {
-        case 'run':
-            return await handleFlowRun(cmd, browser);
-        case 'list':
-            return handleFlowList(cmd);
-        case 'show':
-            return handleFlowShow(cmd);
-        case 'validate':
-            return handleFlowValidate(cmd);
-        case 'from-recorder':
-            return handleFlowFromRecorder(cmd);
-        case 'export':
-            return handleFlowExport(cmd);
-        default:
-            return errorResponse(command.id, `Unknown flow subcommand: ${subcommand}`);
-    }
-}
-function handleFlowList(command) {
-    const sites = command.sitesDir ? loadSitesFromDirectory(command.sitesDir) : loadAllSites();
-    const siteList = [];
-    for (const [name, site] of sites) {
-        siteList.push({
-            name,
-            description: site.description,
-            flows: Object.keys(site.flows),
-        });
-    }
-    return successResponse(command.id, { sites: siteList });
-}
-function handleFlowShow(command) {
-    const sites = command.sitesDir ? loadSitesFromDirectory(command.sitesDir) : loadAllSites();
-    const ref = command.siteFlow || '';
-    const result = findFlow(sites, ref);
-    if (!result) {
-        return errorResponse(command.id, `Flow "${ref}" not found`);
-    }
-    return successResponse(command.id, {
-        site: {
-            name: result.site.name,
-            description: result.site.description,
-            baseUrl: result.site.baseUrl,
-        },
-        flow: result.flow,
-    });
-}
-function handleFlowValidate(command) {
-    const filePath = command.filePath || '';
-    if (!filePath) {
-        return errorResponse(command.id, 'Missing file path for validate');
-    }
-    const result = validateYamlFile(filePath);
-    return successResponse(command.id, result);
-}
-function handleFlowFromRecorder(command) {
-    const recorderFile = command.recorderFile;
-    if (!recorderFile) {
-        return errorResponse(command.id, 'Missing recorder YAML file path');
-    }
-    try {
-        const result = recorderToFlowFromFile(recorderFile, {
-            flowId: command.flowId,
-            description: command.description,
-            baseUrl: command.baseUrl,
-            siteName: command.siteName,
-            maxPaginateIterations: command.maxPaginateIterations,
-        });
-        const yamlString = siteToYamlString(result.site);
-        if (command.outputFile) {
-            writeFileSync(path.resolve(command.outputFile), yamlString, 'utf-8');
-            return successResponse(command.id, {
-                siteName: result.site.name,
-                flowId: Object.keys(result.site.flows)[0],
-                outputFile: command.outputFile,
-                warnings: result.warnings,
-            });
-        }
-        return successResponse(command.id, {
-            siteName: result.site.name,
-            flowId: Object.keys(result.site.flows)[0],
-            yaml: yamlString,
-            warnings: result.warnings,
-        });
-    }
-    catch (e) {
-        return errorResponse(command.id, `Failed to convert recorder YAML: ${e instanceof Error ? e.message : String(e)}`);
-    }
-}
-async function handleFlowRun(command, browser) {
-    const ref = command.siteFlow || '';
-    const sites = command.sitesDir ? loadSitesFromDirectory(command.sitesDir) : loadAllSites();
-    const result = findFlow(sites, ref);
-    if (!result) {
-        return errorResponse(command.id, `Flow "${ref}" not found. Available sites: ${[...sites.keys()].join(', ')}`);
-    }
-    const typedParams = {};
-    if (result.flow.params) {
-        for (const param of result.flow.params) {
-            const raw = command.params?.[param.name];
-            if (raw !== undefined) {
-                switch (param.type) {
-                    case 'number':
-                        typedParams[param.name] = Number(raw);
-                        break;
-                    case 'boolean':
-                        typedParams[param.name] = raw === 'true' || raw === '1';
-                        break;
-                    default:
-                        typedParams[param.name] = raw;
-                }
-            }
-        }
-    }
-    const executor = new FlowExecutor(browser);
-    const flowResult = await executor.execute(result.site, result.flowName, typedParams);
-    return successResponse(command.id, flowResult);
-}
-function handleFlowExport(command) {
-    const filePath = command.filePath;
-    if (!filePath) {
-        return errorResponse(command.id, 'Missing file path for export');
-    }
-    let site;
-    try {
-        site = parseYamlSiteFile(filePath);
-    }
-    catch (e) {
-        return errorResponse(command.id, `Failed to parse YAML file: ${e instanceof Error ? e.message : String(e)}`);
-    }
-    const flowEntries = Object.entries(site.flows);
-    if (flowEntries.length === 0) {
-        return errorResponse(command.id, 'No flows found in YAML file');
-    }
-    const flow = flowEntries[0][1];
-    const format = command.format || 'playwright';
-    const exporterMap = {
-        playwright: new PlaywrightExporter(),
-        python: new PythonExporter(),
-        cypress: new CypressExporter(),
-        selenium: new SeleniumExporter(),
-    };
-    const exporter = exporterMap[format];
-    if (!exporter) {
-        return errorResponse(command.id, `Unknown export format: "${format}". Available: ${Object.keys(exporterMap).join(', ')}`);
-    }
-    try {
-        const script = exporter.export(flow.steps, {
-            baseUrl: command.baseUrl || site.baseUrl,
-            headless: command.headless,
-        });
-        return successResponse(command.id, {
-            format: exporter.format,
-            extension: exporter.extension,
-            script,
-        });
-    }
-    catch (e) {
-        return errorResponse(command.id, `Export failed: ${e instanceof Error ? e.message : String(e)}`);
-    }
-}
-//# sourceMappingURL=actions.js.map