tuna-agent 0.1.1 → 0.1.3

package/dist/browser/actions/download.d.ts

@@ -0,0 +1,16 @@
+import type { DownloadResult } from '../types.js';
+export declare function downloadViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+    path: string;
+    timeoutMs?: number;
+    allowedOutputRoots?: string[];
+}): Promise<DownloadResult>;
+export declare function waitForDownloadViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    path?: string;
+    timeoutMs?: number;
+    allowedOutputRoots?: string[];
+}): Promise<DownloadResult>;

package/dist/browser/actions/download.js

@@ -0,0 +1,39 @@
+import { getPageForTargetId, ensurePageState, restoreRoleRefsForTarget, refLocator, toAIFriendlyError, normalizeTimeoutMs, } from '../connection.js';
+import { assertSafeOutputPath } from '../security.js';
+export async function downloadViaPlaywright(opts) {
+    await assertSafeOutputPath(opts.path, opts.allowedOutputRoots);
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 30000, 120000);
+    const locator = refLocator(page, opts.ref);
+    try {
+        const [download] = await Promise.all([
+            page.waitForEvent('download', { timeout }),
+            locator.click({ timeout }),
+        ]);
+        await download.saveAs(opts.path);
+        return {
+            url: download.url(),
+            suggestedFilename: download.suggestedFilename(),
+            path: opts.path,
+        };
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function waitForDownloadViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 30000, 120000);
+    const download = await page.waitForEvent('download', { timeout });
+    const savePath = opts.path ?? download.suggestedFilename();
+    await assertSafeOutputPath(savePath, opts.allowedOutputRoots);
+    await download.saveAs(savePath);
+    return {
+        url: download.url(),
+        suggestedFilename: download.suggestedFilename(),
+        path: savePath,
+    };
+}

package/dist/browser/actions/emulation.d.ts

@@ -0,0 +1,53 @@
+import type { ColorScheme } from '../types.js';
+export declare function emulateMediaViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    colorScheme: ColorScheme;
+}): Promise<void>;
+export declare function setDeviceViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    name: string;
+}): Promise<void>;
+export declare function setExtraHTTPHeadersViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    headers: Record<string, string>;
+}): Promise<void>;
+export declare function setGeolocationViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    latitude?: number;
+    longitude?: number;
+    accuracy?: number;
+    origin?: string;
+    clear?: boolean;
+}): Promise<void>;
+/**
+ * Set or clear HTTP credentials for the browser context.
+ * Note: Playwright's `setHTTPCredentials()` is deprecated — prefer providing credentials
+ * at context creation time. This function is retained for CDP-connected contexts where
+ * context creation is not controlled by the library.
+ */
+export declare function setHttpCredentialsViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    username?: string;
+    password?: string;
+    clear?: boolean;
+}): Promise<void>;
+export declare function setLocaleViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    locale: string;
+}): Promise<void>;
+export declare function setOfflineViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    offline: boolean;
+}): Promise<void>;
+export declare function setTimezoneViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    timezoneId: string;
+}): Promise<void>;

package/dist/browser/actions/emulation.js

@@ -0,0 +1,103 @@
+import { devices } from 'playwright-core';
+import { getPageForTargetId, ensurePageState, } from '../connection.js';
+export async function emulateMediaViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    await page.emulateMedia({ colorScheme: opts.colorScheme });
+}
+export async function setDeviceViaPlaywright(opts) {
+    const device = devices[opts.name];
+    if (!device) {
+        const available = Object.keys(devices).slice(0, 10).join(', ');
+        throw new Error(`Unknown device "${opts.name}". Some available devices: ${available}...`);
+    }
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    if (device.viewport) {
+        await page.setViewportSize(device.viewport);
+    }
+    if (device.userAgent) {
+        const context = page.context();
+        // Playwright doesn't expose setUserAgent on context directly via CDP,
+        // so we use CDP Emulation.setUserAgentOverride
+        const session = await context.newCDPSession(page);
+        try {
+            await session.send('Emulation.setUserAgentOverride', {
+                userAgent: device.userAgent,
+            });
+        }
+        finally {
+            await session.detach().catch(() => { });
+        }
+    }
+}
+export async function setExtraHTTPHeadersViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    await page.setExtraHTTPHeaders(opts.headers);
+}
+export async function setGeolocationViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const context = page.context();
+    if (opts.clear) {
+        await context.setGeolocation(null);
+        await context.clearPermissions();
+        return;
+    }
+    if (opts.latitude === undefined || opts.longitude === undefined) {
+        throw new Error('latitude and longitude are required (or set clear=true)');
+    }
+    await context.grantPermissions(['geolocation'], opts.origin ? { origin: opts.origin } : undefined);
+    await context.setGeolocation({
+        latitude: opts.latitude,
+        longitude: opts.longitude,
+        accuracy: opts.accuracy,
+    });
+}
+/**
+ * Set or clear HTTP credentials for the browser context.
+ * Note: Playwright's `setHTTPCredentials()` is deprecated — prefer providing credentials
+ * at context creation time. This function is retained for CDP-connected contexts where
+ * context creation is not controlled by the library.
+ */
+export async function setHttpCredentialsViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const context = page.context();
+    if (opts.clear) {
+        await context.setHTTPCredentials({ username: '', password: '' });
+        return;
+    }
+    await context.setHTTPCredentials({
+        username: opts.username ?? '',
+        password: opts.password ?? '',
+    });
+}
+export async function setLocaleViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const session = await page.context().newCDPSession(page);
+    try {
+        await session.send('Emulation.setLocaleOverride', { locale: opts.locale });
+    }
+    finally {
+        await session.detach().catch(() => { });
+    }
+}
+export async function setOfflineViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    await page.context().setOffline(opts.offline);
+}
+export async function setTimezoneViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const session = await page.context().newCDPSession(page);
+    try {
+        await session.send('Emulation.setTimezoneOverride', { timezoneId: opts.timezoneId });
+    }
+    finally {
+        await session.detach().catch(() => { });
+    }
+}

package/dist/browser/actions/evaluate.d.ts

@@ -0,0 +1,29 @@
+export interface FrameEvalResult {
+    frameUrl: string;
+    frameName: string;
+    result: unknown;
+}
+/**
+ * Evaluate JavaScript in ALL frames (including cross-origin iframes).
+ * Playwright can access cross-origin frames via CDP, bypassing same-origin policy.
+ * Returns results from each frame where evaluation succeeded.
+ */
+export declare function evaluateInAllFramesViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    fn: string;
+}): Promise<FrameEvalResult[]>;
+/**
+ * Evaluate JavaScript in the browser page context.
+ * This is intentionally using eval() to execute user-provided browser-side code,
+ * which is the core purpose of this function — running arbitrary JS in the page.
+ * The code runs in the browser sandbox, not in Node.js.
+ */
+export declare function evaluateViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    fn: string;
+    ref?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<unknown>;

package/dist/browser/actions/evaluate.js

@@ -0,0 +1,92 @@
+import { getPageForTargetId, ensurePageState, restoreRoleRefsForTarget, refLocator, } from '../connection.js';
+/**
+ * Evaluate JavaScript in ALL frames (including cross-origin iframes).
+ * Playwright can access cross-origin frames via CDP, bypassing same-origin policy.
+ * Returns results from each frame where evaluation succeeded.
+ */
+export async function evaluateInAllFramesViaPlaywright(opts) {
+    const fnText = String(opts.fn ?? '').trim();
+    if (!fnText)
+        throw new Error('function is required');
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    const frames = page.frames();
+    const results = [];
+    for (const frame of frames) {
+        try {
+            // Runs in the frame's browser context (sandboxed), not in Node.js
+            const result = await frame.evaluate(
+            // eslint-disable-next-line no-eval
+            (fnBody) => {
+                'use strict';
+                try {
+                    const candidate = (0, eval)('(' + fnBody + ')');
+                    return typeof candidate === 'function' ? candidate() : candidate;
+                }
+                catch (err) {
+                    throw new Error('Invalid evaluate function: ' + (err instanceof Error ? err.message : String(err)));
+                }
+            }, fnText);
+            results.push({
+                frameUrl: frame.url(),
+                frameName: frame.name(),
+                result,
+            });
+        }
+        catch {
+            // Frame may have been detached or navigation in progress — skip
+        }
+    }
+    return results;
+}
+/**
+ * Evaluate JavaScript in the browser page context.
+ * This is intentionally using eval() to execute user-provided browser-side code,
+ * which is the core purpose of this function — running arbitrary JS in the page.
+ * The code runs in the browser sandbox, not in Node.js.
+ */
+export async function evaluateViaPlaywright(opts) {
+    const fnText = String(opts.fn ?? '').trim();
+    if (!fnText)
+        throw new Error('function is required');
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const timeout = opts.timeoutMs != null ? opts.timeoutMs : undefined;
+    if (opts.ref) {
+        const locator = refLocator(page, opts.ref);
+        // Runs in the browser page context (sandboxed), not in Node.js
+        return await locator.evaluate(
+        // eslint-disable-next-line no-eval
+        (el, fnBody) => {
+            'use strict';
+            try {
+                const candidate = (0, eval)('(' + fnBody + ')');
+                return typeof candidate === 'function' ? candidate(el) : candidate;
+            }
+            catch (err) {
+                throw new Error('Invalid evaluate function: ' + (err instanceof Error ? err.message : String(err)));
+            }
+        }, fnText, { timeout });
+    }
+    // Runs in the browser page context (sandboxed), not in Node.js
+    const evalPromise = page.evaluate(
+    // eslint-disable-next-line no-eval
+    (fnBody) => {
+        'use strict';
+        try {
+            const candidate = (0, eval)('(' + fnBody + ')');
+            return typeof candidate === 'function' ? candidate() : candidate;
+        }
+        catch (err) {
+            throw new Error('Invalid evaluate function: ' + (err instanceof Error ? err.message : String(err)));
+        }
+    }, fnText);
+    if (!opts.signal)
+        return evalPromise;
+    return Promise.race([
+        evalPromise,
+        new Promise((_, reject) => {
+            opts.signal.addEventListener('abort', () => reject(new Error('Evaluate aborted')), { once: true });
+        }),
+    ]);
+}

package/dist/browser/actions/interaction.d.ts

@@ -0,0 +1,79 @@
+import type { FormField } from '../types.js';
+type MouseButton = 'left' | 'right' | 'middle';
+type KeyModifier = 'Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift';
+export declare function clickViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+    doubleClick?: boolean;
+    button?: MouseButton;
+    modifiers?: KeyModifier[];
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function hoverViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function typeViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+    text: string;
+    submit?: boolean;
+    slowly?: boolean;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function selectOptionViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+    values: string[];
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function dragViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    startRef: string;
+    endRef: string;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function fillFormViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    fields: FormField[];
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function scrollIntoViewViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function highlightViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref: string;
+}): Promise<void>;
+export declare function setInputFilesViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    ref?: string;
+    element?: string;
+    paths: string[];
+}): Promise<void>;
+export declare function armDialogViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    accept: boolean;
+    promptText?: string;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function armFileUploadViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    paths?: string[];
+    timeoutMs?: number;
+}): Promise<void>;
+export {};

package/dist/browser/actions/interaction.js

@@ -0,0 +1,210 @@
+import { getPageForTargetId, ensurePageState, restoreRoleRefsForTarget, refLocator, toAIFriendlyError, normalizeTimeoutMs, } from '../connection.js';
+import { assertSafeUploadPaths } from '../security.js';
+export async function clickViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const locator = refLocator(page, opts.ref);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 8000, 60000);
+    try {
+        if (opts.doubleClick) {
+            await locator.dblclick({ timeout, button: opts.button, modifiers: opts.modifiers });
+        }
+        else {
+            await locator.click({ timeout, button: opts.button, modifiers: opts.modifiers });
+        }
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function hoverViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    try {
+        await refLocator(page, opts.ref).hover({
+            timeout: normalizeTimeoutMs(opts.timeoutMs, 8000, 60000),
+        });
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function typeViaPlaywright(opts) {
+    const text = String(opts.text ?? '');
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const locator = refLocator(page, opts.ref);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 8000, 60000);
+    try {
+        if (opts.slowly) {
+            await locator.click({ timeout });
+            await locator.pressSequentially(text, { timeout, delay: 75 });
+        }
+        else {
+            await locator.fill(text, { timeout });
+        }
+        if (opts.submit)
+            await locator.press('Enter', { timeout });
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function selectOptionViaPlaywright(opts) {
+    if (!opts.values?.length)
+        throw new Error('values are required');
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    try {
+        await refLocator(page, opts.ref).selectOption(opts.values, {
+            timeout: normalizeTimeoutMs(opts.timeoutMs, 8000, 60000),
+        });
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function dragViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    try {
+        await refLocator(page, opts.startRef).dragTo(refLocator(page, opts.endRef), {
+            timeout: normalizeTimeoutMs(opts.timeoutMs, 8000, 60000),
+        });
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, `${opts.startRef} -> ${opts.endRef}`);
+    }
+}
+export async function fillFormViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 8000, 60000);
+    for (let i = 0; i < opts.fields.length; i++) {
+        const field = opts.fields[i];
+        const ref = field.ref.trim();
+        const type = (typeof field.type === 'string' ? field.type.trim() : '') || 'text';
+        const rawValue = field.value;
+        const value = rawValue == null ? '' : String(rawValue);
+        if (!ref)
+            throw new Error(`fill(): field at index ${i} has empty ref`);
+        const locator = refLocator(page, ref);
+        if (type === 'checkbox' || type === 'radio') {
+            const checked = rawValue === true || rawValue === 1 || rawValue === '1' || rawValue === 'true';
+            try {
+                await locator.setChecked(checked, { timeout });
+            }
+            catch (err) {
+                throw toAIFriendlyError(err, ref);
+            }
+            continue;
+        }
+        try {
+            await locator.fill(value, { timeout });
+        }
+        catch (err) {
+            throw toAIFriendlyError(err, ref);
+        }
+    }
+}
+export async function scrollIntoViewViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    try {
+        await refLocator(page, opts.ref).scrollIntoViewIfNeeded({
+            timeout: normalizeTimeoutMs(opts.timeoutMs, 20000),
+        });
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function highlightViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    try {
+        await refLocator(page, opts.ref).highlight();
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref);
+    }
+}
+export async function setInputFilesViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const locator = opts.ref
+        ? refLocator(page, opts.ref)
+        : opts.element
+            ? page.locator(opts.element).first()
+            : null;
+    if (!locator)
+        throw new Error('Either ref or element is required for setInputFiles');
+    await assertSafeUploadPaths(opts.paths);
+    try {
+        await locator.setInputFiles(opts.paths);
+    }
+    catch (err) {
+        throw toAIFriendlyError(err, opts.ref ?? opts.element ?? 'unknown');
+    }
+}
+export async function armDialogViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 30000, 120000);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            page.removeListener('dialog', handler);
+            reject(new Error(`No dialog appeared within ${timeout}ms`));
+        }, timeout);
+        const handler = async (dialog) => {
+            clearTimeout(timer);
+            try {
+                if (opts.accept) {
+                    await dialog.accept(opts.promptText);
+                }
+                else {
+                    await dialog.dismiss();
+                }
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        page.once('dialog', handler);
+    });
+}
+export async function armFileUploadViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 30000, 120000);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            page.removeListener('filechooser', handler);
+            reject(new Error(`No file chooser appeared within ${timeout}ms`));
+        }, timeout);
+        const handler = async (fc) => {
+            clearTimeout(timer);
+            try {
+                const paths = opts.paths ?? [];
+                if (paths.length > 0)
+                    await assertSafeUploadPaths(paths);
+                await fc.setFiles(paths);
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        page.once('filechooser', handler);
+    });
+}

package/dist/browser/actions/keyboard.d.ts

@@ -0,0 +1,6 @@
+export declare function pressKeyViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    key: string;
+    delayMs?: number;
+}): Promise<void>;

package/dist/browser/actions/keyboard.js

@@ -0,0 +1,9 @@
+import { getPageForTargetId, ensurePageState } from '../connection.js';
+export async function pressKeyViaPlaywright(opts) {
+    const key = String(opts.key ?? '').trim();
+    if (!key)
+        throw new Error('key is required');
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    await page.keyboard.press(key, { delay: Math.max(0, Math.floor(opts.delayMs ?? 0)) });
+}

package/dist/browser/actions/navigation.d.ts

@@ -0,0 +1,40 @@
+import type { BrowserTab, SsrfPolicy } from '../types.js';
+export declare function navigateViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    url: string;
+    timeoutMs?: number;
+    ssrfPolicy?: SsrfPolicy;
+    /** @deprecated Use ssrfPolicy: { dangerouslyAllowPrivateNetwork: true } instead */
+    allowInternal?: boolean;
+}): Promise<{
+    url: string;
+}>;
+export declare function listPagesViaPlaywright(opts: {
+    cdpUrl: string;
+}): Promise<BrowserTab[]>;
+export declare function createPageViaPlaywright(opts: {
+    cdpUrl: string;
+    url?: string;
+    ssrfPolicy?: SsrfPolicy;
+    /** @deprecated Use ssrfPolicy: { dangerouslyAllowPrivateNetwork: true } instead */
+    allowInternal?: boolean;
+}): Promise<BrowserTab>;
+export declare function closePageViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+}): Promise<void>;
+export declare function closePageByTargetIdViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId: string;
+}): Promise<void>;
+export declare function focusPageByTargetIdViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId: string;
+}): Promise<void>;
+export declare function resizeViewportViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    width: number;
+    height: number;
+}): Promise<void>;