@weavetab/mcp 2.5.0-beta.0

package/dist/tools/click_and_wait.js

@@ -0,0 +1,149 @@
+// src/tools/click_and_wait.ts
+// Consolidated tool: find element + click + wait for response in one CDP round-trip
+// Eliminates the common pattern: browser_map → browser_click → browser_wait
+import { buildActionMap, findBestMatch, safeSelector, toMarkdownTable } from "../cdp/walker.js";
+import { recordAction, trackToolCall, detectStuckLoop } from "../intelligence/trail.js";
+import { waitForDOMStable } from "../sensors/guard.js";
+import { waitForNetworkIdle } from "../sensors/wait.js";
+import { ghostMove, ghostClick } from "../overlay/ghost.js";
+import { cacheActionMap, getCachedActionMap } from "../state/cache.js";
+import { storeSnapshot, computeDelta } from "../state/delta.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+import { operationMonitor } from "../sensors/operation_monitor.js";
+/**
+ * Consolidated tool that combines element resolution, clicking, and waiting.
+ * Eliminates 2-3 tool calls in the common pattern: find → click → wait
+ */
+export async function weaveClickAndWait(session, args, config) {
+    const { id, label, intent, x, y, waitAfter = 500, waitForNetwork = true, includeMap = false, fast = false, tab_id } = args;
+    const { Page, DOM, Input } = session;
+    const startMs = Date.now();
+    const targetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId ?? "default";
+    const operationId = `clickAndWait-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    operationMonitor.startOperation(operationId, 'browser_click_and_wait');
+    // Handle tab switching if tab_id is provided
+    let targetSession = session;
+    if (tab_id) {
+        const { connectToTab } = await import("../cdp/connector.js");
+        const client = await connectToTab(tab_id);
+        targetSession = client.session;
+    }
+    // Check for stuck loop before processing
+    const stuckCheck = detectStuckLoop();
+    if (stuckCheck.stuck) {
+        return {
+            success: false,
+            error_code: "STUCK_LOOP",
+            message: stuckCheck.diagnosis || "Agent is stuck in a loop",
+            suggestion: "Try a different approach or reset the loop counter",
+        };
+    }
+    // Get initial URL
+    const initialUrl = (await targetSession.Page.getFrameTree()).frameTree.frame.url;
+    // Build or get cached action map
+    let map = getCachedActionMap(targetId, initialUrl);
+    if (!map) {
+        map = await buildActionMap(targetSession, { lite: true }, targetId);
+        cacheActionMap(targetId, map);
+    }
+    await storeSnapshot(targetId, initialUrl, map.elements);
+    // Resolve element
+    let element;
+    if (id) {
+        element = map.elements.find((el) => el.id === id || el.id.endsWith(id));
+    }
+    if (!element && label) {
+        element = findBestMatch(map.elements, label);
+    }
+    if (!element && intent) {
+        element = findBestMatch(map.elements, intent);
+    }
+    if (!element && !x && !y) {
+        return {
+            success: false,
+            error_code: "ELEMENT_NOT_FOUND",
+            message: `Element not found with id="${id}", label="${label}", or intent="${intent}"`,
+            suggestion: "Try browser_map to see available elements, or use x/y coordinates",
+        };
+    }
+    const clickX = x ?? element?.x;
+    const clickY = y ?? element?.y;
+    const selector = element ? safeSelector(element) : undefined;
+    if (!clickX || !clickY) {
+        return {
+            success: false,
+            error_code: "NO_COORDINATES",
+            message: "Could not determine click coordinates",
+            suggestion: "Provide explicit x/y coordinates or ensure element has position data",
+        };
+    }
+    // Perform click with ghost move
+    await ghostMove(targetSession, clickX, clickY, config, element?.label || "target");
+    await ghostClick(targetSession, clickX, clickY, { pointerType: 'mouse' });
+    await new Promise(r => setTimeout(r, 30 + Math.random() * 40));
+    await targetSession.Input.dispatchMouseEvent({
+        type: 'mouseReleased',
+        x: clickX,
+        y: clickY,
+        button: 'left',
+        clickCount: 1,
+        pointerType: 'mouse'
+    });
+    // Wait for response
+    const waitStart = Date.now();
+    if (waitForNetwork) {
+        await Promise.all([
+            waitForDOMStable(targetSession, 50, 300),
+            waitForNetworkIdle(targetSession, waitAfter, waitAfter * 2).catch(() => { })
+        ]);
+    }
+    else {
+        await new Promise(r => setTimeout(r, waitAfter));
+    }
+    const waitedMs = Date.now() - waitStart;
+    // Check result
+    const finalUrl = (await targetSession.Page.getFrameTree()).frameTree.frame.url;
+    const urlChanged = finalUrl !== initialUrl;
+    let newMap = map;
+    let domChanged = false;
+    if (urlChanged || includeMap) {
+        newMap = await buildActionMap(targetSession, { lite: true }, targetId);
+        cacheActionMap(targetId, newMap);
+        const delta = computeDelta(targetId, initialUrl, newMap.elements);
+        domChanged = delta ? delta.added.length + delta.removed.length + delta.changed.length > 0 : urlChanged;
+    }
+    else {
+        const delta = computeDelta(targetId, initialUrl, map.elements);
+        domChanged = delta ? delta.added.length + delta.removed.length + delta.changed.length > 0 : false;
+    }
+    const executionMs = Date.now() - startMs;
+    // Track tool call
+    trackToolCall("browser_click_and_wait", element?.id || id || label || "coordinates", {
+        success: true,
+        urlChanged
+    });
+    recordAction({
+        timestamp: new Date().toISOString(),
+        tool: "browser_click_and_wait",
+        input: { ref: element?.id || id || label, waitAfter, waitForNetwork },
+        result: { success: true, urlChanged, domChanged, waitedMs },
+    });
+    operationMonitor.endOperation(operationId);
+    const result = {
+        success: true,
+        clicked: element?.label || "coordinates",
+        ref: element?.id || id || "coordinates",
+        execution_ms: executionMs,
+        tab_id: targetId,
+        url: finalUrl,
+        title: newMap?.title || "",
+        url_changed: urlChanged,
+        ...(includeMap ? { page_map: newMap ? toMarkdownTable(newMap.elements, finalUrl, newMap.title) : "" } : {}),
+        dom_changed: domChanged,
+        stuck_warning: false,
+        waited_ms: waitedMs,
+        network_idle: waitForNetwork,
+    };
+    return result;
+}

package/dist/tools/clipboard.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Weavetab — tools/clipboard.ts
+ * browser_clipboard: Read and write text + images to the system/browser clipboard.
+ * Uses synthetic mouse click to grant user activation before clipboard API calls.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface ClipboardOptions {
+    action: "read" | "write";
+    /** Text content to write (required for text write, optional if dataUrl is provided) */
+    text?: string;
+    /** Base64 data URL for image write (e.g. "data:image/png;base64,iVBOR...") */
+    dataUrl?: string;
+    /** MIME type override (auto-detected from dataUrl by default) */
+    mimeType?: string;
+    /**
+     * When true, skips the (5,5) user-activation click before clipboard write.
+     * Set this when the calling context already has input focus (e.g. browser_type)
+     * to prevent blurring the focused field before Ctrl+V.
+     */
+    skipActivation?: boolean;
+}
+export declare function browserClipboard(session: CDP.Client, options: ClipboardOptions, _config: Config): Promise<{
+    success: boolean;
+    text?: string;
+    dataUrl?: string;
+    message: string;
+}>;

package/dist/tools/clipboard.js

@@ -0,0 +1,279 @@
+import { ghostClick } from "../overlay/ghost.js";
+export async function browserClipboard(session, options, _config) {
+    const { action, text, dataUrl, mimeType } = options;
+    // ── Dispatch a synthetic click to grant transient user activation ──
+    async function grantActivation() {
+        try {
+            await ghostClick(session, 5, 5);
+            await session.Input.dispatchMouseEvent({ type: "mouseReleased", x: 5, y: 5, button: "left", clickCount: 1 });
+        }
+        catch {
+            // Non-critical — proceed anyway
+        }
+    }
+    // Detect non-secure context (file://, http://) up front. The Clipboard API is
+    // undefined there, and raw CDP ops can hang or throw -32001. Surface a typed
+    // error instead.
+    async function isSecureContext() {
+        try {
+            const { result } = await session.Runtime.evaluate({
+                expression: "window.isSecureContext === true",
+                returnByValue: true,
+                timeout: 1500,
+            });
+            return result?.value === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (action === "write") {
+        const hasText = text !== undefined;
+        const hasImage = dataUrl !== undefined;
+        if (!hasText && !hasImage) {
+            throw new Error("Provide 'text' and/or 'dataUrl' for write action");
+        }
+        // ── Grant user activation only for standalone clipboard writes ───────────
+        // When called from browser_type, the input field is already focused.
+        // Clicking (5,5) here would blur the field before Ctrl+V, causing the
+        // phantom-click + wipe + write-to-BODY issue.
+        if (!options.skipActivation) {
+            await grantActivation();
+        }
+        const secureCtx = await isSecureContext();
+        if (hasImage) {
+            if (!secureCtx) {
+                throw new Error("browser_clipboard: image write requires a secure context (https or chrome://). Current page is non-secure (file:// or http://).");
+            }
+            const mime = mimeType || (dataUrl.includes(';') ? dataUrl.split(';')[0].split(':')[1] : "image/png");
+            const res = await session.Runtime.evaluate({
+                expression: `(async function() {
+          try {
+            const resp = await fetch(${JSON.stringify(dataUrl)});
+            const blob = await resp.blob();
+            await navigator.clipboard.write([
+              new ClipboardItem({ ${JSON.stringify(mime)}: blob })
+            ]);
+            return "ok";
+          } catch(e) {
+            return "ERR:" + e.message;
+          }
+        })()`,
+                awaitPromise: true,
+                returnByValue: true
+            });
+            const val = res.result?.value;
+            if (val === "ok") {
+                return { success: true, message: hasText ? "Text and image copied to clipboard" : "Image copied to clipboard" };
+            }
+            throw new Error("Failed to write image to clipboard: " + (val || "unknown"));
+        }
+        // Text-only write
+        const res = await session.Runtime.evaluate({
+            expression: `(async function() {
+        try {
+          ${secureCtx ? `await navigator.clipboard.writeText(${JSON.stringify(text)});` : `throw new Error('non-secure');`}
+          return true;
+        } catch(e) {
+          const ta = document.createElement('textarea');
+          ta.value = ${JSON.stringify(text)};
+          ta.style.position = 'fixed'; ta.style.opacity = '0';
+          document.body.appendChild(ta);
+          ta.focus(); ta.select();
+          const ok = document.execCommand('copy');
+          document.body.removeChild(ta);
+          return ok;
+        }
+      })()`,
+            awaitPromise: true,
+            returnByValue: true
+        });
+        if (res.result?.value === true) {
+            return { success: true, message: "Copied to clipboard" };
+        }
+        if (!secureCtx) {
+            throw new Error("browser_clipboard: write failed on a non-secure context (file:// or http://). The Clipboard API is unavailable here; navigate to an https page and retry.");
+        }
+        throw new Error("Failed to write to clipboard (page may not be focused)");
+    }
+    // ── Read action ──────────────────────────────────────────────────
+    // 4-layer clipboard read strategy:
+    // Layer 1: CDP mouse click on body + page script click() for user activation
+    // Layer 2: navigator.clipboard.read() API
+    // Layer 3: Ctrl+V via trusted CDP key event → hidden textarea
+    // Layer 4: document.execCommand('paste') fallback
+    async function grantUserActivation() {
+        try {
+            const { result: vp } = await session.Runtime.evaluate({
+                expression: '({w: window.innerWidth, h: window.innerHeight})',
+                returnByValue: true
+            });
+            const cx = Math.floor((vp?.value?.w || 800) / 2);
+            const cy = Math.floor((vp?.value?.h || 600) / 2);
+            await ghostClick(session, cx, cy);
+            await session.Input.dispatchMouseEvent({ type: "mouseReleased", x: cx, y: cy, button: "left", clickCount: 1 });
+            await session.Runtime.evaluate({ expression: 'document.body.click()' }).catch(() => { });
+        }
+        catch { /* non-critical */ }
+    }
+    async function readViaCdpPaste() {
+        const { result } = await session.Runtime.evaluate({
+            expression: `(function() {
+        try {
+          var ta = document.createElement('textarea');
+          ta.style.cssText = 'position:fixed;top:-999px;left:-999px;opacity:0;width:1px;height:1px';
+          document.body.appendChild(ta);
+          ta.focus();
+          ta.select();
+          return true;
+        } catch(e) { return false; }
+      })()`,
+            returnByValue: true
+        });
+        if (result?.value !== true)
+            return null;
+        await session.Input.dispatchKeyEvent({ type: "rawKeyDown", key: "v", windowsVirtualKeyCode: 86, nativeVirtualKeyCode: 86, modifiers: 2 });
+        await session.Input.dispatchKeyEvent({ type: "keyUp", key: "v", windowsVirtualKeyCode: 86, nativeVirtualKeyCode: 86, modifiers: 2 });
+        await new Promise(r => setTimeout(r, 100));
+        const { result: valRes } = await session.Runtime.evaluate({
+            expression: `(function() {
+        var ta = document.querySelector('textarea[style*="top:-999px"]');
+        if (!ta) return null;
+        var v = ta.value;
+        ta.remove();
+        return v || null;
+      })()`,
+            returnByValue: true
+        });
+        return valRes?.value || null;
+    }
+    await grantUserActivation();
+    const secureCtx = await isSecureContext();
+    const originRes = await session.Runtime.evaluate({ expression: "window.location.origin" }).catch(() => null);
+    if (originRes && originRes.result.value && secureCtx) {
+        await session.Browser.grantPermissions({
+            origin: originRes.result.value,
+            permissions: ["clipboardReadWrite", "clipboardSanitizedWrite"]
+        }).catch(() => { });
+    }
+    const READ_TIMEOUT_MS = 2000;
+    let readResult = null;
+    // Layer 1+2: Try clipboard API with user activation (secure contexts only)
+    const apiRead = async () => {
+        if (!secureCtx)
+            return null;
+        const res = await session.Runtime.evaluate({
+            expression: `(async function() {
+        try {
+          if (typeof ClipboardItem !== 'undefined') {
+            var items = await navigator.clipboard.read();
+            var textVal = null, dataUrlVal = null;
+            for (var i = 0; i < items.length; i++) {
+              var item = items[i];
+              var types = item.types;
+              for (var j = 0; j < types.length; j++) {
+                var type = types[j];
+                var blob = await item.getType(type);
+                if (type.indexOf('text/') === 0) {
+                  textVal = await blob.text();
+                } else if (type.indexOf('image/') === 0) {
+                  dataUrlVal = await new Promise(function(rsv) {
+                    var r = new FileReader();
+                    r.onload = function() { rsv(r.result); };
+                    r.readAsDataURL(blob);
+                  });
+                }
+              }
+            }
+            if (textVal || dataUrlVal) return JSON.stringify({ text: textVal, dataUrl: dataUrlVal });
+          }
+          var t = await navigator.clipboard.readText();
+          if (t) return JSON.stringify({ text: t });
+          return null;
+        } catch(e) {
+          return 'ERR:' + e.message;
+        }
+      })()`,
+            awaitPromise: true,
+            returnByValue: true,
+            timeout: READ_TIMEOUT_MS
+        });
+        if (res.exceptionDetails)
+            return null;
+        const raw = res.result?.value;
+        if (!raw || raw.startsWith('ERR:'))
+            return null;
+        return raw;
+    };
+    try {
+        readResult = await Promise.race([
+            apiRead(),
+            new Promise(r => setTimeout(() => r(null), READ_TIMEOUT_MS))
+        ]);
+    }
+    catch (e) {
+        // If API read fails, fall through to CDP paste method
+        readResult = null;
+    }
+    // Layer 3: Ctrl+V via CDP key dispatch (trusted event — no user activation needed)
+    if (!readResult) {
+        try {
+            const pasteVal = await Promise.race([
+                readViaCdpPaste(),
+                new Promise(r => setTimeout(() => r(null), 1000))
+            ]);
+            if (pasteVal) {
+                readResult = JSON.stringify({ text: pasteVal });
+            }
+        }
+        catch {
+            readResult = null;
+        }
+    }
+    // Layer 4: execCommand fallback
+    if (!readResult) {
+        try {
+            const evalResult = await Promise.race([
+                session.Runtime.evaluate({
+                    expression: `(function() {
+            try {
+              var ta = document.createElement('textarea');
+              ta.style.cssText = 'position:fixed;top:-999px;left:-999px;opacity:0';
+              document.body.appendChild(ta);
+              ta.focus();
+              var ok = document.execCommand('paste');
+              var v = ta.value;
+              ta.remove();
+              return ok && v ? JSON.stringify({ text: v }) : null;
+            } catch(e) { return null; }
+          })()`,
+                    returnByValue: true
+                }),
+                new Promise(r => setTimeout(() => r({ result: { value: null } }), 500))
+            ]);
+            const result = evalResult;
+            readResult = result?.result?.value || null;
+        }
+        catch {
+            readResult = null;
+        }
+    }
+    if (!readResult) {
+        if (!secureCtx) {
+            return { success: false, message: "Clipboard is empty or inaccessible. Current page is a non-secure context (file:// or http://) where the Clipboard API is unavailable; trusted CDP paste also returned nothing. Navigate to an https page and retry." };
+        }
+        return { success: true, message: "Clipboard is empty or inaccessible (browser may require user permission)" };
+    }
+    try {
+        const obj = JSON.parse(readResult);
+        return {
+            success: true,
+            text: obj.text || undefined,
+            dataUrl: obj.dataUrl || undefined,
+            message: obj.text && obj.dataUrl ? "Read text and image from clipboard" : obj.dataUrl ? "Read image from clipboard" : "Read from clipboard"
+        };
+    }
+    catch {
+        return { success: true, text: readResult, message: "Read from clipboard" };
+    }
+}

package/dist/tools/console.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Weavetab — tools/console.ts
+ * browser_console: Buffer last 50 console entries and exception events.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface ConsoleEntry {
+    type: string;
+    text: string;
+    timestamp: number;
+    url?: string;
+}
+export declare function initConsoleBuffering(session: CDP.Client, targetId: string): void;
+export interface ConsoleOptions {
+    action: "read" | "clear";
+}
+export declare function browserConsole(session: CDP.Client, options: ConsoleOptions, _config: Config, targetId: string): Promise<{
+    success: boolean;
+    logs: ConsoleEntry[];
+}>;

package/dist/tools/console.js

@@ -0,0 +1,107 @@
+import { SessionSecretTracker } from "../security/secrets.js";
+/**
+ * Server-side noise filter (Q4 decision).
+ * Suppresses Weavetab-internal log spam before it enters the agent-visible buffer.
+ * Extension-side gating is the long-term fix (when ext-dist/ is rebuilt), but
+ * this filter acts as a reliable safety net for any messages that escape.
+ *
+ * Pattern matching is case-insensitive substring. Keep the list minimal.
+ */
+const NOISE_PATTERNS = [
+    /Weavetab_GROUP_STATE/i, // Extension broadcast: idle/busy state changes
+    /cursor host missing/i, // Extension watchdog: fires every 5s on some pages
+    /feedback panel missing/i, // Extension watchdog: harmless recovery notice
+    /\[Weavetab\] Cursor host/i, // Same watchdog, alternate prefix
+    /wt-cursor-trail/i, // Extension CSS transition noise
+    /__wt_push_analytics/i, // Analytics ping echo (already fire-and-forget)
+];
+/** Dedup: suppress the same message within this window (ms) */
+const DEDUP_WINDOW_MS = 10_000;
+function isNoise(text) {
+    for (const pattern of NOISE_PATTERNS) {
+        if (pattern.test(text))
+            return true;
+    }
+    return false;
+}
+const consoleBuffers = new Map();
+/** Per-tab last-seen text for deduplication */
+const lastSeenText = new Map();
+export function initConsoleBuffering(session, targetId) {
+    if (consoleBuffers.has(targetId))
+        return;
+    const buffer = [];
+    consoleBuffers.set(targetId, buffer);
+    const push = (entry) => {
+        // Server-side noise suppression
+        if (isNoise(entry.text))
+            return;
+        // Deduplication: same text within 10s window
+        const last = lastSeenText.get(targetId);
+        if (last && last.text === entry.text && Date.now() - last.at < DEDUP_WINDOW_MS)
+            return;
+        lastSeenText.set(targetId, { text: entry.text, at: Date.now() });
+        buffer.push(entry);
+        if (buffer.length > 50)
+            buffer.shift();
+    };
+    session.Runtime.on("consoleAPICalled", (event) => {
+        const text = event.args.map((a) => a.value || a.description || "").join(" ");
+        push({ type: event.type, text, timestamp: event.timestamp });
+    });
+    session.Runtime.on("exceptionThrown", (event) => {
+        push({
+            type: "exception",
+            text: event.exceptionDetails.text + (event.exceptionDetails.exception?.description || ""),
+            timestamp: event.timestamp,
+            url: event.exceptionDetails.url
+        });
+    });
+    // Clear the per-tab buffer when the MAIN frame navigates to a new document,
+    // so site A's logs don't leak into site B's console reads.
+    session.Page.on("frameNavigated", (event) => {
+        const frame = event.frame;
+        if (frame && !frame.parentId) {
+            const buf = consoleBuffers.get(targetId);
+            if (buf)
+                buf.length = 0;
+            lastSeenText.delete(targetId);
+        }
+    });
+}
+export async function browserConsole(session, options, _config, targetId) {
+    if (options.action === "clear") {
+        await session.Runtime.evaluate({
+            expression: `if (window.__consoleBuffer) { window.__consoleBuffer.length = 0; window.__consoleCursor = 0; }`
+        }).catch(() => { });
+        const buf = consoleBuffers.get(targetId);
+        if (buf)
+            buf.length = 0;
+        return { success: true, logs: [] };
+    }
+    const res = await session.Runtime.evaluate({
+        expression: `window.__Weavetab_readConsole({ since: 'last' })`,
+        returnByValue: true
+    }).catch(() => null);
+    let logs = [];
+    if (res?.result?.value) {
+        logs = res.result.value.map((l) => ({
+            type: l.level,
+            text: l.text,
+            timestamp: l.time
+        }));
+    }
+    else {
+        // Fallback to CDP buffer
+        const buf = consoleBuffers.get(targetId);
+        if (buf) {
+            logs = [...buf];
+            buf.length = 0; // Simulate 'since: last'
+        }
+    }
+    const redactedLogs = logs.map(l => ({
+        ...l,
+        text: typeof l.text === 'string' ? SessionSecretTracker.redact(targetId, l.text) : l.text
+    }));
+    return { success: true, logs: redactedLogs };
+}

package/dist/tools/cookies.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Weavetab — tools/cookies.ts
+ * browser_cookies: Read and inject browser cookies via the CDP Network domain.
+ *
+ * Use this tool to:
+ * - GET: Read all cookies for the current page's URL (for inspection or debugging)
+ * - SET: Inject a cookie to pre-authenticate a session without logging in manually
+ * - DELETE: Remove a specific cookie by name and domain
+ *
+ * This is the correct tool for session pre-authentication. Do NOT use browser_eval
+ * for cookie manipulation — this tool uses the proper CDP Network domain which
+ * works correctly with HttpOnly and Secure cookies.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface CookieEntry {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires: number;
+    httpOnly: boolean;
+    secure: boolean;
+    sameSite?: string;
+}
+export interface CookiesGetResult {
+    success: true;
+    action: "get";
+    cookies: CookieEntry[];
+    count: number;
+    found?: boolean;
+    message?: string;
+}
+export interface CookiesSetResult {
+    success: true;
+    action: "set";
+    name: string;
+}
+export interface CookiesDeleteResult {
+    success: true;
+    action: "delete";
+    name: string;
+}
+export type CookiesResult = CookiesGetResult | CookiesSetResult | CookiesDeleteResult;
+export interface CookieSetOptions {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+export declare function browserCookies(session: CDP.Client, args: {
+    action: "get" | "set" | "delete";
+    name?: string;
+    value?: string;
+    domain?: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+    url?: string;
+}, _config: Config): Promise<CookiesResult>;