tuna-agent 0.1.0 → 0.1.2

package/dist/browser/capture/activity.d.ts

@@ -0,0 +1,22 @@
+import type { ConsoleMessage, PageError, NetworkRequest } from '../types.js';
+export declare function getConsoleMessagesViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    level?: string;
+    clear?: boolean;
+}): Promise<ConsoleMessage[]>;
+export declare function getPageErrorsViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    clear?: boolean;
+}): Promise<{
+    errors: PageError[];
+}>;
+export declare function getNetworkRequestsViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    filter?: string;
+    clear?: boolean;
+}): Promise<{
+    requests: NetworkRequest[];
+}>;

package/dist/browser/capture/activity.js

@@ -0,0 +1,39 @@
+import { getPageForTargetId, ensurePageState } from '../connection.js';
+function consolePriority(level) {
+    switch (level) {
+        case 'error': return 3;
+        case 'warning':
+        case 'warn': return 2;
+        case 'info':
+        case 'log': return 1;
+        case 'debug': return 0;
+        default: return 1;
+    }
+}
+export async function getConsoleMessagesViaPlaywright(opts) {
+    const state = ensurePageState(await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId }));
+    const messages = opts.level
+        ? state.console.filter(msg => consolePriority(msg.type) >= consolePriority(opts.level))
+        : [...state.console];
+    if (opts.clear)
+        state.console = [];
+    return messages;
+}
+export async function getPageErrorsViaPlaywright(opts) {
+    const state = ensurePageState(await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId }));
+    const errors = [...state.errors];
+    if (opts.clear)
+        state.errors = [];
+    return { errors };
+}
+export async function getNetworkRequestsViaPlaywright(opts) {
+    const state = ensurePageState(await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId }));
+    const raw = [...state.requests];
+    const filter = typeof opts.filter === 'string' ? opts.filter.trim() : '';
+    const requests = filter ? raw.filter(r => r.url.includes(filter)) : raw;
+    if (opts.clear) {
+        state.requests = [];
+        state.requestIds = new WeakMap();
+    }
+    return { requests };
+}

package/dist/browser/capture/pdf.d.ts

@@ -0,0 +1,6 @@
+export declare function pdfViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+}): Promise<{
+    buffer: Buffer;
+}>;

package/dist/browser/capture/pdf.js

@@ -0,0 +1,6 @@
+import { getPageForTargetId, ensurePageState } from '../connection.js';
+export async function pdfViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    return { buffer: await page.pdf({ printBackground: true }) };
+}

package/dist/browser/capture/response.d.ts

@@ -0,0 +1,8 @@
+import type { ResponseBodyResult } from '../types.js';
+export declare function responseBodyViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    url: string;
+    timeoutMs?: number;
+    maxChars?: number;
+}): Promise<ResponseBodyResult>;

package/dist/browser/capture/response.js

@@ -0,0 +1,28 @@
+import { getPageForTargetId, ensurePageState, normalizeTimeoutMs, } from '../connection.js';
+export async function responseBodyViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const timeout = normalizeTimeoutMs(opts.timeoutMs, 30000, 120000);
+    const response = await page.waitForResponse(opts.url, { timeout });
+    let body = await response.text();
+    let truncated = false;
+    const maxChars = typeof opts.maxChars === 'number' && Number.isFinite(opts.maxChars)
+        ? Math.max(1, Math.min(5_000_000, Math.floor(opts.maxChars)))
+        : undefined;
+    if (maxChars !== undefined && body.length > maxChars) {
+        body = body.slice(0, maxChars);
+        truncated = true;
+    }
+    const headers = {};
+    const allHeaders = response.headers();
+    for (const [key, value] of Object.entries(allHeaders)) {
+        headers[key] = value;
+    }
+    return {
+        url: response.url(),
+        status: response.status(),
+        headers,
+        body,
+        truncated,
+    };
+}

package/dist/browser/capture/screenshot.d.ts

@@ -0,0 +1,30 @@
+export declare function takeScreenshotViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    fullPage?: boolean;
+    ref?: string;
+    element?: string;
+    type?: 'png' | 'jpeg';
+}): Promise<{
+    buffer: Buffer;
+}>;
+export declare function screenshotWithLabelsViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    refs: string[];
+    maxLabels?: number;
+    type?: 'png' | 'jpeg';
+}): Promise<{
+    buffer: Buffer;
+    labels: Array<{
+        ref: string;
+        index: number;
+        box: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    skipped: string[];
+}>;

package/dist/browser/capture/screenshot.js

@@ -0,0 +1,72 @@
+import { getPageForTargetId, ensurePageState, restoreRoleRefsForTarget, refLocator, } from '../connection.js';
+export async function takeScreenshotViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const type = opts.type ?? 'png';
+    if (opts.ref) {
+        if (opts.fullPage)
+            throw new Error('fullPage is not supported for element screenshots');
+        return { buffer: await refLocator(page, opts.ref).screenshot({ type }) };
+    }
+    if (opts.element) {
+        if (opts.fullPage)
+            throw new Error('fullPage is not supported for element screenshots');
+        return { buffer: await page.locator(opts.element).first().screenshot({ type }) };
+    }
+    return { buffer: await page.screenshot({ type, fullPage: Boolean(opts.fullPage) }) };
+}
+export async function screenshotWithLabelsViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
+    const maxLabels = opts.maxLabels ?? 50;
+    const type = opts.type ?? 'png';
+    const refs = opts.refs.slice(0, maxLabels);
+    const skipped = opts.refs.slice(maxLabels);
+    // Collect bounding boxes for each ref
+    const labels = [];
+    for (let i = 0; i < refs.length; i++) {
+        const ref = refs[i];
+        try {
+            const locator = refLocator(page, ref);
+            const box = await locator.boundingBox({ timeout: 2000 });
+            if (box) {
+                labels.push({ ref, index: i + 1, box });
+            }
+            else {
+                skipped.push(ref);
+            }
+        }
+        catch {
+            skipped.push(ref);
+        }
+    }
+    // Inject visible label overlays into the page
+    await page.evaluate((labelData) => {
+        const container = document.createElement('div');
+        container.id = '__browserclaw_labels__';
+        container.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:2147483647;';
+        for (const { index, box } of labelData) {
+            // Border around element
+            const border = document.createElement('div');
+            border.style.cssText = `position:absolute;left:${box.x}px;top:${box.y}px;width:${box.width}px;height:${box.height}px;border:2px solid #FF4500;box-sizing:border-box;`;
+            container.appendChild(border);
+            // Label badge
+            const badge = document.createElement('div');
+            badge.textContent = String(index);
+            badge.style.cssText = `position:absolute;left:${box.x}px;top:${Math.max(0, box.y - 18)}px;background:#FF4500;color:#fff;font:bold 12px/16px monospace;padding:0 4px;border-radius:2px;`;
+            container.appendChild(badge);
+        }
+        document.body.appendChild(container);
+    }, labels.map(l => ({ index: l.index, box: l.box })));
+    // Take the screenshot with labels visible
+    const buffer = await page.screenshot({ type });
+    // Remove the label overlays (best-effort — page may have navigated)
+    await page.evaluate(() => {
+        const el = document.getElementById('__browserclaw_labels__');
+        if (el)
+            el.remove();
+    }).catch(() => { });
+    return { buffer, labels, skipped };
+}

package/dist/browser/capture/trace.d.ts

@@ -0,0 +1,13 @@
+export declare function traceStartViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    screenshots?: boolean;
+    snapshots?: boolean;
+    sources?: boolean;
+}): Promise<void>;
+export declare function traceStopViaPlaywright(opts: {
+    cdpUrl: string;
+    targetId?: string;
+    path: string;
+    allowedOutputRoots?: string[];
+}): Promise<void>;

package/dist/browser/capture/trace.js

@@ -0,0 +1,19 @@
+import { getPageForTargetId, ensurePageState, } from '../connection.js';
+import { assertSafeOutputPath } from '../security.js';
+export async function traceStartViaPlaywright(opts) {
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const context = page.context();
+    await context.tracing.start({
+        screenshots: opts.screenshots ?? true,
+        snapshots: opts.snapshots ?? true,
+        sources: opts.sources,
+    });
+}
+export async function traceStopViaPlaywright(opts) {
+    await assertSafeOutputPath(opts.path, opts.allowedOutputRoots);
+    const page = await getPageForTargetId({ cdpUrl: opts.cdpUrl, targetId: opts.targetId });
+    ensurePageState(page);
+    const context = page.context();
+    await context.tracing.stop({ path: opts.path });
+}

package/dist/browser/chrome-launcher.d.ts

@@ -0,0 +1,8 @@
+import type { ChromeExecutable, LaunchOptions, RunningChrome } from './types.js';
+export declare function resolveBrowserExecutable(opts?: {
+    executablePath?: string;
+}): ChromeExecutable | null;
+export declare function isChromeReachable(cdpUrl: string, timeoutMs?: number, authToken?: string): Promise<boolean>;
+export declare function getChromeWebSocketUrl(cdpUrl: string, timeoutMs?: number, authToken?: string): Promise<string | null>;
+export declare function launchChrome(opts?: LaunchOptions): Promise<RunningChrome>;
+export declare function stopChrome(running: RunningChrome, timeoutMs?: number): Promise<void>;