tuna-agent 0.1.0 → 0.1.2

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>;

package/dist/browser/actions/navigation.js

@@ -0,0 +1,92 @@
+import { connectBrowser, getPageForTargetId, ensurePageState, pageTargetId, findPageByTargetId, getAllPages, normalizeTimeoutMs } from '../connection.js';
+import { assertBrowserNavigationAllowed } from '../security.js';
+export async function navigateViaPlaywright(opts) {
+    const url = String(opts.url ?? '').trim();
+    if (!url)
+        throw new Error('url is required');
+    const policy = opts.allowInternal ? { ...opts.ssrfPolicy, dangerouslyAllowPrivateNetwork: true } : opts.ssrfPolicy;
+    await assertBrowserNavigationAllowed({ url, ssrfPolicy: policy });
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    await page.goto(url, { timeout: normalizeTimeoutMs(opts.timeoutMs, 30000), waitUntil: 'domcontentloaded' });
+    return { url: page.url() };
+}
+export async function listPagesViaPlaywright(opts) {
+    const { browser } = await connectBrowser(opts.cdpUrl);
+    const pages = await getAllPages(browser);
+    const results = [];
+    for (const page of pages) {
+        const tid = await pageTargetId(page).catch(() => null);
+        if (tid)
+            results.push({
+                targetId: tid,
+                title: await page.title().catch(() => ''),
+                url: page.url(),
+                type: 'page',
+            });
+    }
+    return results;
+}
+export async function createPageViaPlaywright(opts) {
+    const targetUrl = (opts.url ?? '').trim() || 'about:blank';
+    if (targetUrl !== 'about:blank') {
+        const policy = opts.allowInternal ? { ...opts.ssrfPolicy, dangerouslyAllowPrivateNetwork: true } : opts.ssrfPolicy;
+        await assertBrowserNavigationAllowed({ url: targetUrl, ssrfPolicy: policy });
+    }
+    const { browser } = await connectBrowser(opts.cdpUrl);
+    const context = browser.contexts()[0] ?? await browser.newContext();
+    const page = await context.newPage();
+    ensurePageState(page);
+    if (targetUrl !== 'about:blank') {
+        await page.goto(targetUrl, { timeout: normalizeTimeoutMs(undefined, 30000), waitUntil: 'domcontentloaded' });
+    }
+    const tid = await pageTargetId(page).catch(() => null);
+    if (!tid)
+        throw new Error('Failed to get targetId for new page');
+    return {
+        targetId: tid,
+        title: await page.title().catch(() => ''),
+        url: page.url(),
+        type: 'page',
+    };
+}
+export async function closePageViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    await page.close();
+}
+export async function closePageByTargetIdViaPlaywright(opts) {
+    const { browser } = await connectBrowser(opts.cdpUrl);
+    const page = await findPageByTargetId(browser, opts.targetId, opts.cdpUrl);
+    if (!page)
+        throw new Error(`Tab not found (targetId: ${opts.targetId}). Use browser.tabs() to list open tabs.`);
+    await page.close();
+}
+export async function focusPageByTargetIdViaPlaywright(opts) {
+    const { browser } = await connectBrowser(opts.cdpUrl);
+    const page = await findPageByTargetId(browser, opts.targetId, opts.cdpUrl);
+    if (!page)
+        throw new Error(`Tab not found (targetId: ${opts.targetId}). Use browser.tabs() to list open tabs.`);
+    try {
+        await page.bringToFront();
+    }
+    catch (err) {
+        const session = await page.context().newCDPSession(page);
+        try {
+            await session.send('Page.bringToFront');
+        }
+        catch {
+            throw err;
+        }
+        finally {
+            await session.detach().catch(() => { });
+        }
+    }
+}
+export async function resizeViewportViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    await page.setViewportSize({
+        width: Math.max(1, Math.floor(opts.width)),
+        height: Math.max(1, Math.floor(opts.height)),
+    });
+}

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

@@ -0,0 +1,12 @@
+export declare function waitForViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    timeMs?: number;
+    text?: string;
+    textGone?: string;
+    selector?: string;
+    url?: string;
+    loadState?: 'load' | 'domcontentloaded' | 'networkidle';
+    fn?: string;
+    timeoutMs?: number;
+}): Promise<void>;

package/dist/browser/actions/wait.js

@@ -0,0 +1,33 @@
+import { getPageForTargetId, ensurePageState, normalizeTimeoutMs } from '../connection.js';
+export async function waitForViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 20000);
+    if (typeof opts.timeMs === 'number' && Number.isFinite(opts.timeMs)) {
+        await page.waitForTimeout(Math.max(0, opts.timeMs));
+    }
+    if (opts.text) {
+        await page.getByText(opts.text).first().waitFor({ state: 'visible', timeout });
+    }
+    if (opts.textGone) {
+        await page.getByText(opts.textGone).first().waitFor({ state: 'hidden', timeout });
+    }
+    if (opts.selector) {
+        const selector = String(opts.selector).trim();
+        if (selector)
+            await page.locator(selector).first().waitFor({ state: 'visible', timeout });
+    }
+    if (opts.url) {
+        const url = String(opts.url).trim();
+        if (url)
+            await page.waitForURL(url, { timeout });
+    }
+    if (opts.loadState) {
+        await page.waitForLoadState(opts.loadState, { timeout });
+    }
+    if (opts.fn) {
+        const fn = String(opts.fn).trim();
+        if (fn)
+            await page.waitForFunction(fn, undefined, { timeout });
+    }
+}