agent-browser 0.0.0 → 0.1.0

package/dist/actions.js

@@ -0,0 +1,1138 @@
+import { successResponse, errorResponse } from './protocol.js';
+/**
+ * Execute a command and return a response
+ */
+export async function executeCommand(command, browser) {
+    try {
+        switch (command.action) {
+            case 'launch':
+                return await handleLaunch(command, browser);
+            case 'navigate':
+                return await handleNavigate(command, browser);
+            case 'click':
+                return await handleClick(command, browser);
+            case 'type':
+                return await handleType(command, browser);
+            case 'fill':
+                return await handleFill(command, browser);
+            case 'check':
+                return await handleCheck(command, browser);
+            case 'uncheck':
+                return await handleUncheck(command, browser);
+            case 'upload':
+                return await handleUpload(command, browser);
+            case 'dblclick':
+                return await handleDoubleClick(command, browser);
+            case 'focus':
+                return await handleFocus(command, browser);
+            case 'drag':
+                return await handleDrag(command, browser);
+            case 'frame':
+                return await handleFrame(command, browser);
+            case 'mainframe':
+                return await handleMainFrame(command, browser);
+            case 'getbyrole':
+                return await handleGetByRole(command, browser);
+            case 'getbytext':
+                return await handleGetByText(command, browser);
+            case 'getbylabel':
+                return await handleGetByLabel(command, browser);
+            case 'getbyplaceholder':
+                return await handleGetByPlaceholder(command, browser);
+            case 'press':
+                return await handlePress(command, browser);
+            case 'screenshot':
+                return await handleScreenshot(command, browser);
+            case 'snapshot':
+                return await handleSnapshot(command, browser);
+            case 'evaluate':
+                return await handleEvaluate(command, browser);
+            case 'wait':
+                return await handleWait(command, browser);
+            case 'scroll':
+                return await handleScroll(command, browser);
+            case 'select':
+                return await handleSelect(command, browser);
+            case 'hover':
+                return await handleHover(command, browser);
+            case 'content':
+                return await handleContent(command, browser);
+            case 'close':
+                return await handleClose(command, browser);
+            case 'tab_new':
+                return await handleTabNew(command, browser);
+            case 'tab_list':
+                return await handleTabList(command, browser);
+            case 'tab_switch':
+                return await handleTabSwitch(command, browser);
+            case 'tab_close':
+                return await handleTabClose(command, browser);
+            case 'window_new':
+                return await handleWindowNew(command, browser);
+            case 'cookies_get':
+                return await handleCookiesGet(command, browser);
+            case 'cookies_set':
+                return await handleCookiesSet(command, browser);
+            case 'cookies_clear':
+                return await handleCookiesClear(command, browser);
+            case 'storage_get':
+                return await handleStorageGet(command, browser);
+            case 'storage_set':
+                return await handleStorageSet(command, browser);
+            case 'storage_clear':
+                return await handleStorageClear(command, browser);
+            case 'dialog':
+                return await handleDialog(command, browser);
+            case 'pdf':
+                return await handlePdf(command, browser);
+            case 'route':
+                return await handleRoute(command, browser);
+            case 'unroute':
+                return await handleUnroute(command, browser);
+            case 'requests':
+                return await handleRequests(command, browser);
+            case 'download':
+                return await handleDownload(command, browser);
+            case 'geolocation':
+                return await handleGeolocation(command, browser);
+            case 'permissions':
+                return await handlePermissions(command, browser);
+            case 'viewport':
+                return await handleViewport(command, browser);
+            case 'useragent':
+                return await handleUserAgent(command, browser);
+            case 'device':
+                return await handleDevice(command, browser);
+            case 'back':
+                return await handleBack(command, browser);
+            case 'forward':
+                return await handleForward(command, browser);
+            case 'reload':
+                return await handleReload(command, browser);
+            case 'url':
+                return await handleUrl(command, browser);
+            case 'title':
+                return await handleTitle(command, browser);
+            case 'getattribute':
+                return await handleGetAttribute(command, browser);
+            case 'gettext':
+                return await handleGetText(command, browser);
+            case 'isvisible':
+                return await handleIsVisible(command, browser);
+            case 'isenabled':
+                return await handleIsEnabled(command, browser);
+            case 'ischecked':
+                return await handleIsChecked(command, browser);
+            case 'count':
+                return await handleCount(command, browser);
+            case 'boundingbox':
+                return await handleBoundingBox(command, browser);
+            case 'video_start':
+                return await handleVideoStart(command, browser);
+            case 'video_stop':
+                return await handleVideoStop(command, browser);
+            case 'trace_start':
+                return await handleTraceStart(command, browser);
+            case 'trace_stop':
+                return await handleTraceStop(command, browser);
+            case 'har_start':
+                return await handleHarStart(command, browser);
+            case 'har_stop':
+                return await handleHarStop(command, browser);
+            case 'state_save':
+                return await handleStateSave(command, browser);
+            case 'state_load':
+                return await handleStateLoad(command, browser);
+            case 'console':
+                return await handleConsole(command, browser);
+            case 'errors':
+                return await handleErrors(command, browser);
+            case 'keyboard':
+                return await handleKeyboard(command, browser);
+            case 'wheel':
+                return await handleWheel(command, browser);
+            case 'tap':
+                return await handleTap(command, browser);
+            case 'clipboard':
+                return await handleClipboard(command, browser);
+            case 'highlight':
+                return await handleHighlight(command, browser);
+            case 'clear':
+                return await handleClear(command, browser);
+            case 'selectall':
+                return await handleSelectAll(command, browser);
+            case 'innertext':
+                return await handleInnerText(command, browser);
+            case 'innerhtml':
+                return await handleInnerHtml(command, browser);
+            case 'inputvalue':
+                return await handleInputValue(command, browser);
+            case 'setvalue':
+                return await handleSetValue(command, browser);
+            case 'dispatch':
+                return await handleDispatch(command, browser);
+            case 'evalhandle':
+                return await handleEvalHandle(command, browser);
+            case 'expose':
+                return await handleExpose(command, browser);
+            case 'addscript':
+                return await handleAddScript(command, browser);
+            case 'addstyle':
+                return await handleAddStyle(command, browser);
+            case 'emulatemedia':
+                return await handleEmulateMedia(command, browser);
+            case 'offline':
+                return await handleOffline(command, browser);
+            case 'headers':
+                return await handleHeaders(command, browser);
+            case 'pause':
+                return await handlePause(command, browser);
+            case 'getbyalttext':
+                return await handleGetByAltText(command, browser);
+            case 'getbytitle':
+                return await handleGetByTitle(command, browser);
+            case 'getbytestid':
+                return await handleGetByTestId(command, browser);
+            case 'nth':
+                return await handleNth(command, browser);
+            case 'waitforurl':
+                return await handleWaitForUrl(command, browser);
+            case 'waitforloadstate':
+                return await handleWaitForLoadState(command, browser);
+            case 'setcontent':
+                return await handleSetContent(command, browser);
+            case 'timezone':
+                return await handleTimezone(command, browser);
+            case 'locale':
+                return await handleLocale(command, browser);
+            case 'credentials':
+                return await handleCredentials(command, browser);
+            case 'mousemove':
+                return await handleMouseMove(command, browser);
+            case 'mousedown':
+                return await handleMouseDown(command, browser);
+            case 'mouseup':
+                return await handleMouseUp(command, browser);
+            case 'bringtofront':
+                return await handleBringToFront(command, browser);
+            case 'waitforfunction':
+                return await handleWaitForFunction(command, browser);
+            case 'scrollintoview':
+                return await handleScrollIntoView(command, browser);
+            case 'addinitscript':
+                return await handleAddInitScript(command, browser);
+            case 'keydown':
+                return await handleKeyDown(command, browser);
+            case 'keyup':
+                return await handleKeyUp(command, browser);
+            case 'inserttext':
+                return await handleInsertText(command, browser);
+            case 'multiselect':
+                return await handleMultiSelect(command, browser);
+            case 'waitfordownload':
+                return await handleWaitForDownload(command, browser);
+            case 'responsebody':
+                return await handleResponseBody(command, browser);
+            default: {
+                // TypeScript narrows to never here, but we handle it for safety
+                const unknownCommand = command;
+                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);
+    return successResponse(command.id, { launched: true });
+}
+async function handleNavigate(command, browser) {
+    const page = browser.getPage();
+    await page.goto(command.url, {
+        waitUntil: command.waitUntil ?? 'load',
+    });
+    return successResponse(command.id, {
+        url: page.url(),
+        title: await page.title(),
+    });
+}
+async function handleClick(command, browser) {
+    const page = browser.getPage();
+    await page.click(command.selector, {
+        button: command.button,
+        clickCount: command.clickCount,
+        delay: command.delay,
+    });
+    return successResponse(command.id, { clicked: true });
+}
+async function handleType(command, browser) {
+    const page = browser.getPage();
+    if (command.clear) {
+        await page.fill(command.selector, '');
+    }
+    await page.type(command.selector, command.text, {
+        delay: command.delay,
+    });
+    return successResponse(command.id, { typed: true });
+}
+async function handlePress(command, browser) {
+    const page = browser.getPage();
+    if (command.selector) {
+        await page.press(command.selector, command.key);
+    }
+    else {
+        await page.keyboard.press(command.key);
+    }
+    return successResponse(command.id, { pressed: true });
+}
+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.selector) {
+        target = page.locator(command.selector);
+    }
+    if (command.path) {
+        await target.screenshot({ ...options, path: command.path });
+        return successResponse(command.id, { path: command.path });
+    }
+    else {
+        const buffer = await target.screenshot(options);
+        return successResponse(command.id, { base64: buffer.toString('base64') });
+    }
+}
+async function handleSnapshot(command, browser) {
+    const page = browser.getPage();
+    // Use ariaSnapshot which returns a string representation of the accessibility tree
+    const snapshot = await page.locator(':root').ariaSnapshot();
+    return successResponse(command.id, {
+        snapshot: snapshot ?? 'Empty page',
+    });
+}
+async function handleEvaluate(command, browser) {
+    const page = browser.getPage();
+    // Evaluate the script directly as a string expression
+    const result = await page.evaluate(command.script);
+    return successResponse(command.id, { result });
+}
+async function handleWait(command, browser) {
+    const page = browser.getPage();
+    if (command.selector) {
+        await page.waitForSelector(command.selector, {
+            state: command.state ?? 'visible',
+            timeout: command.timeout,
+        });
+    }
+    else if (command.timeout) {
+        await page.waitForTimeout(command.timeout);
+    }
+    else {
+        // Default: wait for load state
+        await page.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 }) => {
+                el.scrollBy(x ?? 0, y ?? 0);
+            }, { x: command.x, y: command.y });
+        }
+    }
+    else {
+        // Scroll the page
+        let deltaX = command.x ?? 0;
+        let deltaY = command.y ?? 0;
+        if (command.direction) {
+            const amount = command.amount ?? 100;
+            switch (command.direction) {
+                case 'up':
+                    deltaY = -amount;
+                    break;
+                case 'down':
+                    deltaY = amount;
+                    break;
+                case 'left':
+                    deltaX = -amount;
+                    break;
+                case 'right':
+                    deltaX = amount;
+                    break;
+            }
+        }
+        await page.evaluate(`window.scrollBy(${deltaX}, ${deltaY})`);
+    }
+    return successResponse(command.id, { scrolled: true });
+}
+async function handleSelect(command, browser) {
+    const page = browser.getPage();
+    const values = Array.isArray(command.values) ? command.values : [command.values];
+    await page.selectOption(command.selector, values);
+    return successResponse(command.id, { selected: values });
+}
+async function handleHover(command, browser) {
+    const page = browser.getPage();
+    await page.hover(command.selector);
+    return successResponse(command.id, { hovered: true });
+}
+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();
+    return successResponse(command.id, result);
+}
+async function handleTabList(command, browser) {
+    const tabs = await browser.listTabs();
+    return successResponse(command.id, {
+        tabs,
+        active: browser.getActiveIndex(),
+    });
+}
+async function handleTabSwitch(command, browser) {
+    const result = 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 frame = browser.getFrame();
+    await frame.fill(command.selector, command.value);
+    return successResponse(command.id, { filled: true });
+}
+async function handleCheck(command, browser) {
+    const frame = browser.getFrame();
+    await frame.check(command.selector);
+    return successResponse(command.id, { checked: true });
+}
+async function handleUncheck(command, browser) {
+    const frame = browser.getFrame();
+    await frame.uncheck(command.selector);
+    return successResponse(command.id, { unchecked: true });
+}
+async function handleUpload(command, browser) {
+    const frame = browser.getFrame();
+    const files = Array.isArray(command.files) ? command.files : [command.files];
+    await frame.setInputFiles(command.selector, files);
+    return successResponse(command.id, { uploaded: files });
+}
+async function handleDoubleClick(command, browser) {
+    const frame = browser.getFrame();
+    await frame.dblclick(command.selector);
+    return successResponse(command.id, { clicked: true });
+}
+async function handleFocus(command, browser) {
+    const frame = browser.getFrame();
+    await frame.focus(command.selector);
+    return successResponse(command.id, { focused: true });
+}
+async function handleDrag(command, browser) {
+    const frame = browser.getFrame();
+    await frame.dragAndDrop(command.source, command.target);
+    return successResponse(command.id, { dragged: true });
+}
+async function handleFrame(command, browser) {
+    await browser.switchToFrame({
+        selector: command.selector,
+        name: command.name,
+        url: command.url,
+    });
+    return successResponse(command.id, { switched: true });
+}
+async function handleMainFrame(command, browser) {
+    browser.switchToMainFrame();
+    return successResponse(command.id, { switched: true });
+}
+async function handleGetByRole(command, browser) {
+    const page = browser.getPage();
+    const locator = page.getByRole(command.role, { name: command.name });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'fill':
+            await locator.fill(command.value ?? '');
+            return successResponse(command.id, { filled: true });
+        case 'check':
+            await locator.check();
+            return successResponse(command.id, { checked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleGetByText(command, browser) {
+    const page = browser.getPage();
+    const locator = page.getByText(command.text, { exact: command.exact });
+    switch (command.subaction) {
+        case 'click':
+            await locator.click();
+            return successResponse(command.id, { clicked: true });
+        case 'hover':
+            await locator.hover();
+            return successResponse(command.id, { hovered: true });
+    }
+}
+async function handleGetByLabel(command, browser) {
+    const page = browser.getPage();
+    const locator = page.getByLabel(command.label);
+    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 page = browser.getPage();
+    const locator = page.getByPlaceholder(command.placeholder);
+    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();
+    await context.addCookies(command.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 page = browser.getPage();
+    const storageType = command.type === 'local' ? 'localStorage' : 'sessionStorage';
+    if (command.key) {
+        const value = await page.evaluate(`${storageType}.getItem(${JSON.stringify(command.key)})`);
+        return successResponse(command.id, { key: command.key, value });
+    }
+    else {
+        const data = await page.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 page = browser.getPage();
+    const storageType = command.type === 'local' ? 'localStorage' : 'sessionStorage';
+    await page.evaluate(`${storageType}.setItem(${JSON.stringify(command.key)}, ${JSON.stringify(command.value)})`);
+    return successResponse(command.id, { set: true });
+}
+async function handleStorageClear(command, browser) {
+    const page = browser.getPage();
+    const storageType = command.type === 'local' ? 'localStorage' : 'sessionStorage';
+    await page.evaluate(`${storageType}.clear()`);
+    return successResponse(command.id, { cleared: true });
+}
+async function handleDialog(command, browser) {
+    browser.setDialogHandler(command.response, command.promptText);
+    return successResponse(command.id, { handler: 'set', response: command.response });
+}
+async function handlePdf(command, browser) {
+    const page = browser.getPage();
+    await page.pdf({
+        path: command.path,
+        format: command.format ?? 'Letter',
+    });
+    return successResponse(command.id, { path: command.path });
+}
+// Network & Request handlers
+async function handleRoute(command, browser) {
+    await browser.addRoute(command.url, {
+        response: command.response,
+        abort: command.abort,
+    });
+    return successResponse(command.id, { routed: command.url });
+}
+async function handleUnroute(command, browser) {
+    await browser.removeRoute(command.url);
+    return successResponse(command.id, { unrouted: command.url ?? 'all' });
+}
+async function handleRequests(command, browser) {
+    if (command.clear) {
+        browser.clearRequests();
+        return successResponse(command.id, { cleared: true });
+    }
+    // Start tracking if not already
+    browser.startRequestTracking();
+    const requests = browser.getRequests(command.filter);
+    return successResponse(command.id, { requests });
+}
+async function handleDownload(command, browser) {
+    const page = browser.getPage();
+    const [download] = await Promise.all([
+        page.waitForEvent('download'),
+        page.click(command.selector),
+    ]);
+    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);
+    return successResponse(command.id, {
+        device: command.device,
+        viewport: device.viewport,
+        userAgent: device.userAgent,
+    });
+}
+async function handleBack(command, browser) {
+    const page = browser.getPage();
+    await page.goBack();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleForward(command, browser) {
+    const page = browser.getPage();
+    await page.goForward();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleReload(command, browser) {
+    const page = browser.getPage();
+    await page.reload();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleUrl(command, browser) {
+    const page = browser.getPage();
+    return successResponse(command.id, { url: page.url() });
+}
+async function handleTitle(command, browser) {
+    const page = browser.getPage();
+    const title = await page.title();
+    return successResponse(command.id, { title });
+}
+async function handleGetAttribute(command, browser) {
+    const page = browser.getPage();
+    const value = await page.getAttribute(command.selector, command.attribute);
+    return successResponse(command.id, { attribute: command.attribute, value });
+}
+async function handleGetText(command, browser) {
+    const page = browser.getPage();
+    const text = await page.textContent(command.selector);
+    return successResponse(command.id, { text });
+}
+async function handleIsVisible(command, browser) {
+    const page = browser.getPage();
+    const visible = await page.isVisible(command.selector);
+    return successResponse(command.id, { visible });
+}
+async function handleIsEnabled(command, browser) {
+    const page = browser.getPage();
+    const enabled = await page.isEnabled(command.selector);
+    return successResponse(command.id, { enabled });
+}
+async function handleIsChecked(command, browser) {
+    const page = browser.getPage();
+    const checked = await page.isChecked(command.selector);
+    return successResponse(command.id, { checked });
+}
+async function handleCount(command, browser) {
+    const page = browser.getPage();
+    const count = await page.locator(command.selector).count();
+    return successResponse(command.id, { count });
+}
+async function handleBoundingBox(command, browser) {
+    const page = browser.getPage();
+    const box = await page.locator(command.selector).boundingBox();
+    return successResponse(command.id, { box });
+}
+// 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 });
+    }
+    browser.startConsoleTracking();
+    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 });
+    }
+    browser.startErrorTracking();
+    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 page = browser.getPage();
+    await page.tap(command.selector);
+    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 page = browser.getPage();
+    await page.locator(command.selector).highlight();
+    return successResponse(command.id, { highlighted: true });
+}
+async function handleClear(command, browser) {
+    const page = browser.getPage();
+    await page.locator(command.selector).clear();
+    return successResponse(command.id, { cleared: true });
+}
+async function handleSelectAll(command, browser) {
+    const page = browser.getPage();
+    await page.locator(command.selector).selectText();
+    return successResponse(command.id, { selected: true });
+}
+async function handleInnerText(command, browser) {
+    const page = browser.getPage();
+    const text = await page.locator(command.selector).innerText();
+    return successResponse(command.id, { text });
+}
+async function handleInnerHtml(command, browser) {
+    const page = browser.getPage();
+    const html = await page.locator(command.selector).innerHTML();
+    return successResponse(command.id, { html });
+}
+async function handleInputValue(command, browser) {
+    const page = browser.getPage();
+    const value = await page.locator(command.selector).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 page = browser.getPage();
+    const locator = page.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 page = browser.getPage();
+    const locator = page.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 page = browser.getPage();
+    const locator = page.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 page = browser.getPage();
+    const base = page.locator(command.selector);
+    const 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 handleBringToFront(command, browser) {
+    const page = browser.getPage();
+    await page.bringToFront();
+    return successResponse(command.id, { focused: true });
+}
+async function handleWaitForFunction(command, browser) {
+    const page = browser.getPage();
+    await page.waitForFunction(command.expression, { timeout: command.timeout });
+    return successResponse(command.id, { waited: true });
+}
+async function handleScrollIntoView(command, browser) {
+    const page = browser.getPage();
+    await page.locator(command.selector).scrollIntoViewIfNeeded();
+    return successResponse(command.id, { scrolled: true });
+}
+async function handleAddInitScript(command, browser) {
+    const context = browser.getPage().context();
+    await context.addInitScript(command.script);
+    return successResponse(command.id, { added: true });
+}
+async function handleKeyDown(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.down(command.key);
+    return successResponse(command.id, { down: true, key: command.key });
+}
+async function handleKeyUp(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.up(command.key);
+    return successResponse(command.id, { up: true, key: command.key });
+}
+async function handleInsertText(command, browser) {
+    const page = browser.getPage();
+    await page.keyboard.insertText(command.text);
+    return successResponse(command.id, { inserted: true });
+}
+async function handleMultiSelect(command, browser) {
+    const page = browser.getPage();
+    const selected = await page.locator(command.selector).selectOption(command.values);
+    return successResponse(command.id, { selected });
+}
+async function handleWaitForDownload(command, browser) {
+    const page = browser.getPage();
+    const download = await page.waitForEvent('download', { timeout: command.timeout });
+    let filePath;
+    if (command.path) {
+        filePath = command.path;
+        await download.saveAs(filePath);
+    }
+    else {
+        filePath = (await download.path()) || download.suggestedFilename();
+    }
+    return successResponse(command.id, {
+        path: filePath,
+        filename: download.suggestedFilename(),
+        url: download.url(),
+    });
+}
+async function handleResponseBody(command, browser) {
+    const page = browser.getPage();
+    const response = await page.waitForResponse((resp) => resp.url().includes(command.url), {
+        timeout: command.timeout,
+    });
+    const body = await response.text();
+    let parsed = body;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        // Keep as string if not JSON
+    }
+    return successResponse(command.id, {
+        url: response.url(),
+        status: response.status(),
+        body: parsed,
+    });
+}
+//# sourceMappingURL=actions.js.map