@mehmoodqureshi/chrome-mcp 0.6.7 → 0.7.0

package/dist/shared/page-fns.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * shared/page-fns.ts — the ONE function that runs inside a page for every
+ * DOM-touching command.
+ *
+ * MUST be self-contained: `chrome.scripting.executeScript` serializes it to
+ * source, so it may not close over anything from this module. That constraint is
+ * exactly why every op lives in one function instead of ten — the shared
+ * helpers below (`deepQuery` above all) can then be written once and are
+ * automatically used by every op.
+ *
+ * `deepQuery` is the reason this file exists. `snapshot` deliberately walks open
+ * shadow roots and stamps `data-mcp-ref` on what it finds there, but every
+ * action used to resolve that ref with a plain `document.querySelector`, which
+ * cannot cross a shadow boundary. So the snapshot advertised elements that no
+ * click could ever reach — a structural dead end on every web-component site.
+ * One resolver, used by every op, is what closes it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pageOp = pageOp;
+/**
+ * Runs IN THE PAGE (or in one frame of it). Returns a plain JSON-able object;
+ * `found: false` means the selector matched nothing, which the caller renders as
+ * SELECTOR_NOT_FOUND. Never throws across the boundary — a page that blows up
+ * inside an op is reported as `{ ok: false, error }`.
+ */
+function pageOp(a) {
+    // -- shared helpers (must stay INSIDE: this function is serialized alone) --
+    /** querySelector that descends into open shadow roots, breadth-ish first. */
+    const deepQuery = (sel) => {
+        const roots = [document];
+        const seen = new Set();
+        while (roots.length > 0) {
+            const root = roots.shift();
+            if (seen.has(root))
+                continue;
+            seen.add(root);
+            let hit = null;
+            try {
+                hit = root.querySelector(sel);
+            }
+            catch {
+                return null; // malformed selector — same answer for every root
+            }
+            if (hit)
+                return hit;
+            let hosts = [];
+            try {
+                hosts = Array.from(root.querySelectorAll('*'));
+            }
+            catch {
+                hosts = [];
+            }
+            for (const host of hosts) {
+                const sr = host.shadowRoot;
+                if (sr && !seen.has(sr))
+                    roots.push(sr);
+            }
+        }
+        return null;
+    };
+    /**
+     * Where this frame sits inside the TOP document, so a CDP mouse event (which
+     * is dispatched in top-viewport coordinates) lands on an element that lives in
+     * an iframe. `window.frameElement` is readable only when the parent is
+     * same-origin, so a cross-origin ancestor yields `exact: false` and the caller
+     * falls back to a synthetic click rather than clicking the wrong pixel.
+     */
+    const frameOffset = () => {
+        let dx = 0;
+        let dy = 0;
+        let win = window;
+        try {
+            while (win.parent && win.parent !== win) {
+                const fe = win.frameElement;
+                if (!fe)
+                    return { dx, dy, exact: false, scrollX: window.scrollX, scrollY: window.scrollY };
+                const r = fe.getBoundingClientRect();
+                dx += r.left;
+                dy += r.top;
+                win = win.parent;
+            }
+        }
+        catch {
+            return { dx, dy, exact: false, scrollX: window.scrollX, scrollY: window.scrollY };
+        }
+        return { dx, dy, exact: true, scrollX: win.scrollX, scrollY: win.scrollY };
+    };
+    const sel = typeof a.selector === 'string' && a.selector.length > 0 ? a.selector : null;
+    const el = sel ? deepQuery(sel) : null;
+    const missing = sel !== null && el === null;
+    /** Set a value the way React/Vue see it (they patch the instance setter). */
+    const setValue = (node, next) => {
+        const setter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(node), 'value')?.set;
+        if (setter)
+            setter.call(node, next);
+        else
+            node.value = next;
+        node.dispatchEvent(new Event('input', { bubbles: true }));
+    };
+    switch (a.op) {
+        case 'probe':
+            return { found: true, url: location.href, title: document.title };
+        case 'text': {
+            if (missing)
+                return { found: false };
+            const root = el ?? document.body;
+            return { found: true, text: root ? root.innerText ?? '' : '' };
+        }
+        case 'html': {
+            if (missing)
+                return { found: false };
+            const root = el ?? document.documentElement;
+            if (!root)
+                return { found: true, html: '' };
+            const outer = a.outer === true || !sel;
+            return { found: true, html: outer ? root.outerHTML : root.innerHTML };
+        }
+        case 'click': {
+            if (!el)
+                return { found: false };
+            el.scrollIntoView({ block: 'center' });
+            el.click();
+            return { found: true };
+        }
+        case 'type': {
+            const node = el;
+            if (!node)
+                return { found: false };
+            node.focus();
+            const next = (a.clear ? '' : node.value ?? '') + (a.text ?? '');
+            setValue(node, next);
+            node.dispatchEvent(new Event('change', { bubbles: true }));
+            return { found: true };
+        }
+        case 'focus': {
+            const node = el;
+            if (!node)
+                return { found: false };
+            node.focus();
+            if (a.clear)
+                setValue(node, '');
+            return { found: true };
+        }
+        case 'point': {
+            if (!el)
+                return { found: false };
+            el.scrollIntoView({ block: 'center', inline: 'center' });
+            const r = el.getBoundingClientRect();
+            const off = frameOffset();
+            return {
+                found: true,
+                x: r.left + r.width / 2 + off.dx,
+                y: r.top + r.height / 2 + off.dy,
+                // false => this frame's coordinates cannot be mapped to the top viewport.
+                exact: off.exact,
+            };
+        }
+        case 'hover': {
+            if (!el)
+                return { found: false };
+            el.dispatchEvent(new MouseEvent('mouseover', { bubbles: true }));
+            el.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true }));
+            return { found: true };
+        }
+        case 'select': {
+            const node = el;
+            if (!node || !node.options)
+                return { found: false };
+            const want = new Set(a.values ?? []);
+            let matched = false;
+            for (const opt of Array.from(node.options)) {
+                const on = want.has(opt.value) || want.has(opt.label) || want.has(opt.text);
+                opt.selected = on;
+                if (on)
+                    matched = true;
+            }
+            node.dispatchEvent(new Event('input', { bubbles: true }));
+            node.dispatchEvent(new Event('change', { bubbles: true }));
+            return { found: true, matched };
+        }
+        case 'measure': {
+            const d = document.documentElement;
+            const dims = {
+                w: window.innerWidth,
+                h: window.innerHeight,
+                fullW: Math.max(d.scrollWidth, d.clientWidth),
+                fullH: Math.max(d.scrollHeight, d.clientHeight),
+            };
+            if (!sel)
+                return { found: true, dims, element: null, missing: false };
+            if (!el)
+                return { found: true, dims, element: null, missing: true };
+            el.scrollIntoView({ block: 'center', inline: 'center' });
+            const r = el.getBoundingClientRect();
+            const off = frameOffset();
+            // viewport rect + this frame's offset + the TOP document's scroll ->
+            // document coordinates of the page the screenshot actually captures.
+            return {
+                found: true,
+                dims,
+                element: {
+                    x: r.left + off.dx + off.scrollX,
+                    y: r.top + off.dy + off.scrollY,
+                    w: r.width,
+                    h: r.height,
+                },
+                missing: false,
+                exact: off.exact,
+            };
+        }
+        case 'scroll': {
+            if (el)
+                el.scrollIntoView({ block: 'center' });
+            else if (a.x != null || a.y != null)
+                window.scrollTo(a.x ?? 0, a.y ?? 0);
+            else
+                window.scrollBy(a.deltaX ?? 0, a.deltaY ?? 0);
+            return { found: !missing };
+        }
+        case 'storage': {
+            const store = a.session ? window.sessionStorage : window.localStorage;
+            const op = a.storageOp;
+            if (op === 'set') {
+                store.setItem(String(a.key), String(a.value ?? ''));
+                return { found: true, ok: true };
+            }
+            if (op === 'remove') {
+                store.removeItem(String(a.key));
+                return { found: true, ok: true };
+            }
+            if (op === 'clear') {
+                store.clear();
+                return { found: true, ok: true };
+            }
+            if (a.key)
+                return { found: true, ok: true, value: store.getItem(a.key) };
+            const entries = {};
+            for (let i = 0; i < store.length; i++) {
+                const k = store.key(i);
+                if (k)
+                    entries[k] = store.getItem(k) ?? '';
+            }
+            return { found: true, ok: true, entries };
+        }
+        // -- the two polling ops: one injection that resolves in-page, rather than
+        //    one executeScript round-trip per tick --
+        case 'waitSelector': {
+            const deadline = Date.now() + (a.timeoutMs ?? 5_000);
+            const every = a.interval ?? 120;
+            return new Promise((resolve) => {
+                const tick = () => {
+                    if (sel && deepQuery(sel))
+                        return resolve({ found: true });
+                    if (Date.now() > deadline)
+                        return resolve({ found: false });
+                    setTimeout(tick, every);
+                };
+                tick();
+            });
+        }
+        case 'waitFor': {
+            const deadline = Date.now() + (a.timeoutMs ?? 30_000);
+            const every = a.interval ?? 150;
+            const want = typeof a.textContains === 'string' && a.textContains.length > 0 ? a.textContains : null;
+            const gone = a.gone === true;
+            return new Promise((resolve) => {
+                const hit = () => {
+                    let present;
+                    if (sel)
+                        present = !!deepQuery(sel);
+                    else if (want)
+                        present = (document.body?.innerText ?? '').includes(want);
+                    else
+                        present = true;
+                    return gone ? !present : present;
+                };
+                const tick = () => {
+                    if (hit())
+                        return resolve({ found: true, matched: true });
+                    if (Date.now() > deadline)
+                        return resolve({ found: true, matched: false });
+                    setTimeout(tick, every);
+                };
+                tick();
+            });
+        }
+        default:
+            return { found: false, error: `unknown page op: ${String(a.op)}` };
+    }
+}
+//# sourceMappingURL=page-fns.js.map

package/dist/shared/policy.d.ts

@@ -17,6 +17,15 @@ export declare function isMutatingMethod(method: WireMethod): boolean;
 export declare function isUrlGated(method: WireMethod): boolean;
 /** Parse a host out of a URL string; '' if it has none (about:blank, data:, …). */
 export declare function hostOf(url: string): string;
+/**
+ * Reduce an allowlist entry to the bare host it constrains. Users routinely paste
+ * a full URL ("https://example.com/app") or a "host:port/path" instead of a bare
+ * host; those forms would never equal a hostname and so silently match nothing.
+ * We strip the scheme, userinfo, port, and path/query/fragment, preserving a
+ * leading "*." wildcard and the two catch-all forms. Returns '' for a pattern
+ * that carries no host (which then matches nothing).
+ */
+export declare function normalizeDomainPattern(pattern: string): string;
 export declare function isDomainAllowed(url: string, policy: WirePolicy): boolean;
 export type PolicyVerdict = {
     ok: true;

package/dist/shared/policy.js

@@ -15,6 +15,7 @@ exports.isReadMethod = isReadMethod;
 exports.isMutatingMethod = isMutatingMethod;
 exports.isUrlGated = isUrlGated;
 exports.hostOf = hostOf;
+exports.normalizeDomainPattern = normalizeDomainPattern;
 exports.isDomainAllowed = isDomainAllowed;
 exports.evaluatePolicy = evaluatePolicy;
 exports.blockedDomainMessage = blockedDomainMessage;
@@ -27,6 +28,12 @@ const READ_CONTENT = new Set([
     'get_html',
     'screenshot',
     'wait_for',
+    // A frame list leaks the URLs a page embeds; console/network buffers are the
+    // page's own traffic and error text; a PDF is a screenshot by another name.
+    // All three are page CONTENT and gate exactly like the reads above.
+    'frames_list',
+    'observers',
+    'print_pdf',
 ]);
 /** Content-mutating actions — URL-gated AND mutation-gated. */
 const MUTATE_CONTENT = new Set([
@@ -132,6 +139,14 @@ function evaluatePolicy(url, method, policy) {
     if (method === 'download_file' && !policy.allowDownloads) {
         return { ok: false, reason: 'downloads are disabled. Pass --enable-downloads or set allowDownloads.' };
     }
+    if (method === 'observers' && !policy.allowObservers) {
+        return {
+            ok: false,
+            reason: 'the in-page observers (console_logs / network_log / dialogs) are disabled. They patch console, ' +
+                'fetch, XMLHttpRequest and the dialog functions on every allowlisted page in your real browser, ' +
+                'so they are opt-in: pass --enable-observers or set allowObservers.',
+        };
+    }
     if (method === 'upload_file' && !policy.allowUploads) {
         return {
             ok: false,
@@ -182,5 +197,6 @@ exports.DENY_ALL_WIRE_POLICY = {
     allowUploads: false,
     allowAllTabs: false,
     enableMutations: false,
+    allowObservers: false,
 };
 //# sourceMappingURL=policy.js.map

package/dist/shared/protocol.d.ts

@@ -44,10 +44,10 @@ export declare const WIRE_CAP_TAB_URL: "tab-url";
  * `download_file` (privileged, executor-owned) and `ping_probe` (a short-deadline
  * responsiveness check used to detect a dead-but-not-yet-reconnected worker).
  */
-export type WireMethod = 'tabs_list' | 'tab_select' | 'tab_new' | 'tab_close' | 'navigate' | 'back' | 'forward' | 'reload' | 'click' | 'type' | 'press' | 'hover' | 'scroll' | 'screenshot' | 'get_text' | 'get_html' | 'snapshot' | 'select_option' | 'get_cookies' | 'storage' | 'eval' | 'wait_for' | 'download_file' | 'upload_file' | 'ping_probe';
+export type WireMethod = 'tabs_list' | 'tab_select' | 'tab_new' | 'tab_close' | 'navigate' | 'back' | 'forward' | 'reload' | 'click' | 'type' | 'press' | 'hover' | 'scroll' | 'screenshot' | 'get_text' | 'get_html' | 'snapshot' | 'select_option' | 'get_cookies' | 'storage' | 'eval' | 'wait_for' | 'download_file' | 'upload_file' | 'frames_list' | 'observers' | 'print_pdf' | 'ping_probe';
 /** Runtime list of every WireMethod, for boot-time drift assertions on both ends. */
 export declare const WIRE_METHODS: readonly WireMethod[];
-export type ExecutorErrorCode = 'NO_TARGET' | 'TARGET_GONE' | 'DETACHED' | 'DEVTOOLS_OPEN' | 'SELECTOR_NOT_FOUND' | 'REF_EXPIRED' | 'EVAL_THREW' | 'TIMEOUT' | 'BAD_ARGS' | 'CDP_ERROR' | 'POLICY_DENIED' | 'DOWNLOAD_FAILED' | 'UPLOAD_FAILED' | 'UNKNOWN_METHOD';
+export type ExecutorErrorCode = 'NO_TARGET' | 'TARGET_GONE' | 'DETACHED' | 'DEVTOOLS_OPEN' | 'SELECTOR_NOT_FOUND' | 'REF_EXPIRED' | 'EVAL_THREW' | 'TIMEOUT' | 'BAD_ARGS' | 'CDP_ERROR' | 'POLICY_DENIED' | 'DOWNLOAD_FAILED' | 'UPLOAD_FAILED' | 'FRAME_NOT_FOUND' | 'OBSERVERS_DISABLED' | 'UNKNOWN_METHOD';
 export interface BaseFrame {
     type: string;
     v: ProtocolVersion;
@@ -80,6 +80,15 @@ export interface WirePolicy {
     allowUploads: boolean;
     allowAllTabs: boolean;
     enableMutations: boolean;
+    /**
+     * Whether the in-page observer hook (console / network / dialog capture) may
+     * be installed. Off by default: it patches `console`, `fetch`,
+     * `XMLHttpRequest` and the dialog functions on every allowlisted page in the
+     * user's real browser, which is too invasive to turn on for someone silently.
+     * Optional so an older extension deserializing a newer welcome frame reads it
+     * as undefined -> falsy -> the safe answer.
+     */
+    allowObservers?: boolean;
 }
 export interface WelcomeFrame extends BaseFrame {
     type: 'welcome';

package/dist/shared/protocol.js

@@ -67,6 +67,9 @@ exports.WIRE_METHODS = [
     'wait_for',
     'download_file',
     'upload_file',
+    'frames_list',
+    'observers',
+    'print_pdf',
     'ping_probe',
 ];
 //# sourceMappingURL=protocol.js.map

package/dist/shared/snapshot.d.ts

@@ -15,6 +15,8 @@ export interface RawSnapshotNode {
     value?: string;
     disabled?: boolean;
     checked?: boolean;
+    /** A password field. `value` is never populated for one. */
+    secret?: boolean;
 }
 export interface RawSnapshot {
     url: string;

package/dist/shared/snapshot.js

@@ -140,8 +140,15 @@ function collectSnapshot(interactiveOnly = true, max = 200) {
         const ref = `e${++n}`;
         el.setAttribute('data-mcp-ref', ref);
         const node = { ref, role: roleOf(el), name: accName(el), tag: el.tagName.toLowerCase() };
+        // A password field's characters never leave the page. The node still
+        // appears (so the model can target it) and is flagged `secret`, but the
+        // value is not something a caller has a use for and every caller would
+        // otherwise get it by default.
+        const isSecret = el.tagName === 'INPUT' && el.type === 'password';
+        if (isSecret)
+            node.secret = true;
         const v = el.value;
-        if (typeof v === 'string' && v)
+        if (!isSecret && typeof v === 'string' && v)
             node.value = v.slice(0, 200);
         if (el.disabled)
             node.disabled = true;

package/dist/src/bridge/workspace.d.ts

@@ -37,6 +37,12 @@ export declare function switchWorkspace(opts: {
  * Returns the path written, or null if persisted nowhere (no workspace / error).
  */
 export declare function saveResult(tool: string, ext: string, body: string): string | null;
+/**
+ * Save a binary artifact (a PDF, today) into the active task's results dir.
+ * Same contract as `saveResult`: best-effort, returns the path or null, and a
+ * failure here never fails the tool call that produced the bytes.
+ */
+export declare function saveBinary(tool: string, ext: string, bytes: Buffer): string | null;
 /** Save a screenshot PNG (base64) into the active task's `screenshots/`. */
 export declare function saveScreenshot(dataBase64: string): string | null;
 /**

package/dist/src/bridge/workspace.js

@@ -19,6 +19,7 @@ exports.peekActiveWorkspace = peekActiveWorkspace;
 exports.resetActiveWorkspaceForTesting = resetActiveWorkspaceForTesting;
 exports.switchWorkspace = switchWorkspace;
 exports.saveResult = saveResult;
+exports.saveBinary = saveBinary;
 exports.saveScreenshot = saveScreenshot;
 exports.captureDownload = captureDownload;
 exports.appendHistory = appendHistory;
@@ -103,6 +104,25 @@ function saveResult(tool, ext, body) {
         return null;
     }
 }
+/**
+ * Save a binary artifact (a PDF, today) into the active task's results dir.
+ * Same contract as `saveResult`: best-effort, returns the path or null, and a
+ * failure here never fails the tool call that produced the bytes.
+ */
+function saveBinary(tool, ext, bytes) {
+    const w = peekActiveWorkspace();
+    if (!w)
+        return null;
+    try {
+        const path = (0, node_path_1.join)(w.resultsDir, `${stem(tool)}.${ext}`);
+        (0, node_fs_1.writeFileSync)(path, bytes, { mode: 0o600 });
+        return path;
+    }
+    catch (err) {
+        logErr(`results save failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
 /** Save a screenshot PNG (base64) into the active task's `screenshots/`. */
 function saveScreenshot(dataBase64) {
     const w = peekActiveWorkspace();

package/dist/src/config.js

@@ -134,6 +134,18 @@ function parseArgs(argv) {
             case '--allow-all-tabs':
                 policyFlags.allowAllTabs = true;
                 break;
+            case '--enable-observers':
+                policyFlags.allowObservers = true;
+                break;
+            case '--redact':
+                policyFlags.redact = true;
+                break;
+            case '--redact-pattern':
+                // A custom pattern only means anything with redaction on, so asking for
+                // one turns it on rather than being silently ignored.
+                policyFlags.redact = true;
+                (policyFlags.redactPatterns ??= []).push(requireValue(argv[++i], '--redact-pattern'));
+                break;
             case '--cdp-fallback':
                 cdpFallback = true;
                 break;
@@ -177,6 +189,17 @@ function parseArgs(argv) {
     if (policy.allowUploads && !policy.uploadsDir) {
         throw new Error('--enable-uploads requires --uploads-dir <path> (uploads must be confined to a directory)');
     }
+    // Fail at startup, not on the first read, if a redaction pattern is malformed:
+    // a pattern the user believes is scrubbing secrets but that never compiled is
+    // the worst of both worlds.
+    for (const source of policy.redactPatterns ?? []) {
+        try {
+            new RegExp(source);
+        }
+        catch (err) {
+            throw new Error(`--redact-pattern ${JSON.stringify(source)} is not a valid regular expression: ${String(err)}`);
+        }
+    }
     return {
         wsPort,
         dataDir: resolveDataDir(),
@@ -269,6 +292,14 @@ Security (default: deny-all safe mode):
   --enable-uploads       Enable upload_file — sends local files to a page (off by default)
   --uploads-dir <path>   Restrict upload_file to files inside <path> (recommended with --enable-uploads)
   --allow-all-tabs       Relax tab list/select to all tabs
+  --enable-observers     Enable console_logs / network_log / dialogs. Installs an
+                         in-page hook on allowlisted sites that records console
+                         output, fetch/XHR traffic, and intercepts alert/confirm/
+                         prompt (off by default: it patches page globals).
+  --redact               Scrub secret-shaped strings (JWTs, cloud keys, bearer
+                         tokens, private keys) out of page reads. Password field
+                         values are always suppressed, with or without this.
+  --redact-pattern <re>  Add a redaction regex (repeatable; implies --redact)
 
 Misc:
   --log-level <lvl>      silent | info | debug (default info)

package/dist/src/executor/extension-executor.d.ts

@@ -7,7 +7,7 @@
  * method-specific arguments travel in `params`. Results are trusted shapes
  * produced by the extension router (validated there).
  */
-import { type ActionOk, type BackendKind, type CookieItem, type DownloadResult, type EvalResult, type Executor, type ExecutorStatus, type KeyModifier, type MouseButton, type NavResult, type ScreenshotResult, type SnapshotResult, type StorageOp, type StorageResult, type TabId, type TabInfo, type Target, type WaitResult, type WaitUntil } from './types';
+import { type ActionOk, type BackendKind, type CookieItem, type DownloadResult, type EvalResult, type Executor, type ExecutorStatus, type FrameInfo, type FrameOpts, type ObserverArgs, type ObserverReadResult, type PdfResult, type KeyModifier, type MouseButton, type NavResult, type ScreenshotResult, type SnapshotResult, type StorageOp, type StorageResult, type TabId, type TabInfo, type Target, type WaitResult, type WaitUntil } from './types';
 import type { BridgeServer } from '../bridge/server';
 export declare class ExtensionExecutor implements Executor {
     private readonly bridge;
@@ -49,27 +49,27 @@ export declare class ExtensionExecutor implements Executor {
         button?: MouseButton;
         clickCount?: number;
         trusted?: boolean;
-    }): Promise<ActionOk>;
+    } & FrameOpts): Promise<ActionOk>;
     type(t: Target, text: string, opts?: {
         tabId?: TabId;
         clear?: boolean;
         pressEnter?: boolean;
         keyEvents?: boolean;
         trusted?: boolean;
-    }): Promise<ActionOk>;
+    } & FrameOpts): Promise<ActionOk>;
     selectOption(t: Target, values: string[], opts?: {
         tabId?: TabId;
-    }): Promise<ActionOk>;
+    } & FrameOpts): Promise<ActionOk>;
     fill(t: Target, value: string, opts?: {
         tabId?: TabId;
-    }): Promise<ActionOk>;
+    } & FrameOpts): Promise<ActionOk>;
     press(key: string, opts?: {
         tabId?: TabId;
         modifiers?: KeyModifier[];
     }): Promise<ActionOk>;
     hover(t: Target, opts?: {
         tabId?: TabId;
-    }): Promise<ActionOk>;
+    } & FrameOpts): Promise<ActionOk>;
     scroll(opts: {
         tabId?: TabId;
         x?: number;
@@ -77,24 +77,24 @@ export declare class ExtensionExecutor implements Executor {
         deltaX?: number;
         deltaY?: number;
         target?: Target;
-    }): Promise<ActionOk>;
+    } & FrameOpts): Promise<ActionOk>;
     getText(t?: Target, opts?: {
         tabId?: TabId;
-    }): Promise<{
+    } & FrameOpts): Promise<{
         text: string;
         ref?: string;
     }>;
     getHtml(t?: Target, opts?: {
         tabId?: TabId;
         outer?: boolean;
-    }): Promise<{
+    } & FrameOpts): Promise<{
         html: string;
     }>;
     snapshot(opts?: {
         tabId?: TabId;
         interactiveOnly?: boolean;
         max?: number;
-    }): Promise<SnapshotResult>;
+    } & FrameOpts): Promise<SnapshotResult>;
     getCookies(opts?: {
         tabId?: TabId;
         url?: string;
@@ -112,18 +112,18 @@ export declare class ExtensionExecutor implements Executor {
         tabId?: TabId;
         fullPage?: boolean;
         target?: Target;
-    }): Promise<ScreenshotResult>;
+    } & FrameOpts): Promise<ScreenshotResult>;
     eval(expression: string, opts?: {
         tabId?: TabId;
         awaitPromise?: boolean;
-    }): Promise<EvalResult>;
+    } & FrameOpts): Promise<EvalResult>;
     waitFor(opts: {
         tabId?: TabId;
         selector?: string;
         textContains?: string;
         gone?: boolean;
         timeoutMs?: number;
-    }): Promise<WaitResult>;
+    } & FrameOpts): Promise<WaitResult>;
     download(args: {
         url?: string;
         target?: Target;
@@ -133,4 +133,18 @@ export declare class ExtensionExecutor implements Executor {
     uploadFile(t: Target, files: string[], opts?: {
         tabId?: TabId;
     }): Promise<ActionOk>;
+    framesList(opts?: {
+        tabId?: TabId;
+    }): Promise<FrameInfo[]>;
+    observers(args: ObserverArgs): Promise<ObserverReadResult>;
+    printPdf(opts?: {
+        tabId?: TabId;
+        landscape?: boolean;
+        printBackground?: boolean;
+        scale?: number;
+        paperWidth?: number;
+        paperHeight?: number;
+        pageRanges?: string;
+        preferCSSPageSize?: boolean;
+    }): Promise<PdfResult>;
 }