agentic-browser 2.6.2 → 2.7.0

package/README.md

@@ -113,10 +113,21 @@ agentic-browser agent start --user-agent "MyBot/1.0"
 agentic-browser agent status
 agentic-browser agent navigate https://example.com
 agentic-browser agent click "#login"
+agentic-browser agent click --text "Accept all" --frame "#sp_message_iframe_123"
+agentic-browser agent type --frame "iframe#checkout" "#card" "4242..."
+agentic-browser agent wait --url "*/dashboard*" --load --timeout 10000
+agentic-browser agent wait --text "Welcome back"
+agentic-browser agent eval "document.querySelectorAll('article').length"
+agentic-browser agent tabs
+agentic-browser agent tab-new https://example.org
+agentic-browser agent tab <id-or-prefix>
+agentic-browser agent tab-close <id-or-prefix>
 agentic-browser agent content --mode summary
 agentic-browser agent content --mode html --selector main
 agentic-browser agent elements
 agentic-browser agent elements --roles button,link --limit 20
+agentic-browser agent elements --href /news/ --text "gta"
+agentic-browser agent screenshot --out ./page.png --full-page
 agentic-browser agent memory-search "navigate:example.com" --domain example.com
 agentic-browser agent stop
 agentic-browser agent cleanup --dry-run --max-age-days 7
@@ -156,6 +167,10 @@ MCP responses are compact — `visible`, `actions`, and `tagName` are omitted to
 
 When an element lives inside an open shadow root or a same-origin iframe, discovery returns a composed locator using `>>>` to cross boundaries, for example `iframe[name="checkout"] >>> button[aria-label="Pay"]`. The same locator string works with `agent click`, `agent type`, MCP `browser_interact`, and fallback selectors.
 
+Cross-origin iframes (consent managers, payment forms) cannot be read from the page. `agent elements` lists them under `crossOriginFrames`; pass one of those selectors as `--frame` to `elements`, `click`, `type`, `hover`, `select`, `toggle`, `wait` and `eval` to run inside it, or compose it directly: `#sp_message_iframe_123 >>> text=Accept all`. A `text=Foo` segment matches by visible text, label or placeholder (`text="Foo"` for an exact match).
+
+`agent status`, `navigate` and interaction commands report the current `url`. `agent cookies` also handles cross-origin consent iframes and, when nothing was dismissed, explains why in `detail`.
+
 `agent content` and MCP `browser_get_content` now default to `summary`, which returns a low-token overview with `title`, `headings`, `landmarks`, `primaryActions`, `inputs`, `alerts`, and iframe metadata. Use `a11y` when you need the deeper accessibility structure, and `text` or `html` only when you need raw content.
 
 ````

package/dist/cli/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as isConnectionError, o as ensurePrivateDir, r as createCliRuntime, s as writePrivateFileSync } from "../runtime-Bo7FmRYk.mjs";
+import { a as isConnectionError, o as ensurePrivateDir, r as createCliRuntime, s as writePrivateFileSync } from "../runtime-CfQ0xGAm.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -45,12 +45,24 @@ async function agentStart(runtime) {
 		sessionId: session.sessionId
 	};
 }
+/** Best-effort page state; never fails the command it decorates. */
+async function tryPageState(runtime, sessionId) {
+	try {
+		return await runtime.api.getPageState(sessionId);
+	} catch {
+		return;
+	}
+}
 async function agentStatus(runtime) {
 	const sessionId = requireSessionId(runtime);
+	const session = runtime.api.getSession(sessionId);
+	const page = session.status === "ready" ? await tryPageState(runtime, sessionId) : void 0;
 	return {
 		ok: true,
 		action: "status",
-		...runtime.api.getSession(sessionId)
+		...session,
+		url: page?.url,
+		title: page?.title
 	};
 }
 async function agentStop(runtime) {
@@ -107,10 +119,12 @@ async function agentNavigate(runtime, input) {
 		const dismissed = await runtime.api.dismissCookieBanner(sessionId);
 		if (dismissed.dismissed) cookieBanner = dismissed;
 	} catch {}
+	const page = await tryPageState(runtime, result.sessionId);
 	return {
 		ok: true,
 		action: "navigate",
 		...result,
+		url: page?.url,
 		cookieBanner
 	};
 }
@@ -119,10 +133,155 @@ async function agentInteract(runtime, input) {
 		type: "interact",
 		payload: input
 	});
+	const page = await tryPageState(runtime, result.sessionId);
 	return {
 		ok: true,
 		action: input.action,
-		...result
+		...result,
+		url: page?.url
+	};
+}
+const INTERACTION_RESULT_PREFIX = "Interaction result: ";
+/** Evaluates a JavaScript expression in the page (or a frame) and returns its value. */
+async function agentEval(runtime, input) {
+	const result = await agentInteract(runtime, {
+		action: "evaluate",
+		text: input.expression,
+		frame: input.frame
+	});
+	const raw = result.resultMessage?.startsWith(INTERACTION_RESULT_PREFIX) ? result.resultMessage.slice(20) : result.resultMessage ?? "";
+	let value = raw;
+	try {
+		value = raw === "" || raw === "undefined" ? null : JSON.parse(raw);
+	} catch {}
+	return {
+		ok: true,
+		action: "eval",
+		sessionId: result.sessionId,
+		commandId: result.commandId,
+		result: value,
+		url: result.url
+	};
+}
+/** `/re/flags` = regex, `*` = glob, otherwise substring. */
+function matchesUrlPattern(url, pattern) {
+	const regex = /^\/(.+)\/([a-z]*)$/.exec(pattern);
+	if (regex) return new RegExp(regex[1], regex[2]).test(url);
+	if (pattern.includes("*")) {
+		const escaped = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+		return new RegExp(`^${escaped}$`).test(url);
+	}
+	return url.includes(pattern);
+}
+const WAIT_POLL_MS = 200;
+async function agentWait(runtime, input) {
+	if (!input.selector && !input.text && !input.url && !input.load) throw new Error("Nothing to wait for: pass a selector, --text, --url or --load");
+	if (input.selector && input.text) throw new Error("Pass either a selector or --text, not both");
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	const timeoutMs = input.timeoutMs ?? 1e4;
+	const started = Date.now();
+	const remaining = () => timeoutMs - (Date.now() - started);
+	const pollPage = async (done, describe) => {
+		let last;
+		for (;;) {
+			last = await tryPageState(runtime, sessionId) ?? last;
+			if (last && done(last)) return last;
+			if (remaining() <= 0) throw new Error(`wait timeout after ${timeoutMs}ms: ${describe} (current url: ${last?.url ?? "unknown"}, readyState: ${last?.readyState ?? "unknown"})`);
+			await new Promise((resolve) => setTimeout(resolve, Math.min(WAIT_POLL_MS, remaining())));
+		}
+	};
+	if (input.url) {
+		const pattern = input.url;
+		await pollPage((page) => matchesUrlPattern(page.url, pattern), `url did not match "${pattern}"`);
+	}
+	if (input.load) await pollPage((page) => page.readyState === "complete", "page did not finish loading");
+	if (input.selector || input.text) await agentInteract(runtime, {
+		action: "waitFor",
+		selector: input.selector ?? `text=${input.text}`,
+		frame: input.frame,
+		timeoutMs: Math.max(remaining(), 1)
+	});
+	const page = await tryPageState(runtime, sessionId);
+	return {
+		ok: true,
+		action: "wait",
+		sessionId,
+		elapsedMs: Date.now() - started,
+		url: page?.url,
+		title: page?.title,
+		readyState: page?.readyState
+	};
+}
+/** Accepts a full tab id or a unique prefix of one. */
+async function resolveTabId(runtime, sessionId, idOrPrefix) {
+	const tabs = await runtime.api.listTabs(sessionId);
+	const exact = tabs.find((tab) => tab.id === idOrPrefix);
+	if (exact) return exact.id;
+	const matches = tabs.filter((tab) => tab.id.startsWith(idOrPrefix));
+	if (matches.length === 1) return matches[0].id;
+	if (matches.length > 1) throw new Error(`Ambiguous tab id prefix: ${idOrPrefix}`);
+	throw new Error(`Tab not found: ${idOrPrefix}`);
+}
+async function agentTabs(runtime) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	return {
+		ok: true,
+		action: "tabs",
+		sessionId,
+		tabs: (await runtime.api.listTabs(sessionId)).map(({ id, url, title, active }) => ({
+			id,
+			url,
+			title,
+			active
+		}))
+	};
+}
+async function agentTabSwitch(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	const tab = await runtime.api.switchTab(sessionId, await resolveTabId(runtime, sessionId, input.id));
+	return {
+		ok: true,
+		action: "tab",
+		sessionId,
+		id: tab.id,
+		url: tab.url,
+		title: tab.title
+	};
+}
+async function agentTabNew(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	const tab = await runtime.api.newTab(sessionId);
+	if (!input.url) return {
+		ok: true,
+		action: "tab-new",
+		sessionId,
+		id: tab.id,
+		url: tab.url
+	};
+	return {
+		...await agentNavigate(runtime, { url: input.url }),
+		action: "tab-new",
+		id: tab.id
+	};
+}
+async function agentTabClose(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	const result = await runtime.api.closeTab(sessionId, await resolveTabId(runtime, sessionId, input.id));
+	return {
+		ok: true,
+		action: "tab-close",
+		sessionId,
+		closed: result.closed,
+		active: {
+			id: result.active.id,
+			url: result.active.url,
+			title: result.active.title
+		}
 	};
 }
 async function agentRestart(runtime) {
@@ -170,6 +329,36 @@ async function agentContent(runtime, input) {
 		})
 	};
 }
+async function agentScreenshot(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	const format = input.format ?? "png";
+	const result = await runtime.api.screenshot(sessionId, {
+		format,
+		quality: input.quality,
+		fullPage: input.fullPage
+	});
+	const ext = format === "png" ? "png" : "jpg";
+	let filePath;
+	if (input.out) {
+		filePath = path.resolve(input.out);
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	} else {
+		const dir = path.join(runtime.context.config.dataDir, "screenshots");
+		ensurePrivateDir(dir);
+		filePath = path.join(dir, `${sessionId}-${Date.now()}.${ext}`);
+	}
+	const bytes = Buffer.from(result.data, "base64");
+	fs.writeFileSync(filePath, bytes, { mode: 384 });
+	return {
+		ok: true,
+		action: "screenshot",
+		sessionId,
+		path: filePath,
+		mimeType: result.mimeType,
+		bytes: bytes.length
+	};
+}
 async function agentElements(runtime, input) {
 	const sessionId = requireSessionId(runtime);
 	await ensureReady(runtime, sessionId);
@@ -180,7 +369,10 @@ async function agentElements(runtime, input) {
 			roles: input.roles,
 			visibleOnly: input.visibleOnly,
 			limit: input.limit,
-			selector: input.selector
+			selector: input.selector,
+			href: input.href,
+			text: input.text,
+			frame: input.frame
 		})
 	};
 }
@@ -280,6 +472,14 @@ async function runMemoryStats(runtime) {
 }
 // src/cli/index.ts
 const collect = (value, previous = []) => [...previous, value];
+const FRAME_HELP = "iframe selector to run in (cross-origin frames supported)";
+/** Resolves `<selector>` or `--text` (substring; `--exact` for exact match) to one locator. */
+function resolveTarget(selector, options) {
+	if (selector && options.text) throw new Error("Pass either a selector or --text, not both");
+	if (options.text) return options.exact ? `text=${JSON.stringify(options.text)}` : `text=${options.text}`;
+	if (!selector) throw new Error("Missing target: pass a selector or --text <text>");
+	return selector;
+}
 async function main() {
 	const runtime = createCliRuntime();
 	const program = new Command();
@@ -375,19 +575,24 @@ async function main() {
 		const result = await agentNavigate(runtime, { url });
 		console.log(JSON.stringify(result));
 	});
-	agent.command("click").argument("<selector>").option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
+	agent.command("click").argument("[selector]", "CSS selector or composed locator (a >>> b)").option("--text <text>", "click the element with this visible text instead of a selector").option("--exact", "with --text: require an exact text match").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
 		const result = await agentInteract(runtime, {
 			action: "click",
-			selector,
+			selector: resolveTarget(selector, options),
+			frame: options.frame,
 			fallbackSelectors: options.fallback
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("type").argument("<selector>").argument("<text>").option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, text, options) => {
+	agent.command("type").argument("<selectorOrText>", "CSS selector, or the text to type when --into-text is used").argument("[text]").option("--into-text <label>", "target the field by its visible text/label/placeholder").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (first, second, options) => {
+		const selector = options.intoText ? `text=${options.intoText}` : first;
+		const text = options.intoText ? first : second;
+		if (text === void 0) throw new Error("Missing text to type");
 		const result = await agentInteract(runtime, {
 			action: "type",
 			selector,
 			text,
+			frame: options.frame,
 			fallbackSelectors: options.fallback
 		});
 		console.log(JSON.stringify(result));
@@ -399,35 +604,41 @@ async function main() {
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("wait").argument("<selector>").option("--timeout <ms>", "timeout in milliseconds", "2000").action(async (selector, options) => {
-		const result = await agentInteract(runtime, {
-			action: "waitFor",
+	agent.command("wait").description("Wait for an element, visible text, a URL and/or the page load").argument("[selector]").option("--text <text>", "wait until an element with this text exists").option("--url <pattern>", "wait until the URL matches (substring, * glob, or /regex/)").option("--load", "wait until document.readyState is complete").option("--frame <selector>", FRAME_HELP).option("--timeout <ms>", "timeout in milliseconds", "10000").action(async (selector, options) => {
+		const result = await agentWait(runtime, {
 			selector,
+			text: options.text,
+			url: options.url,
+			load: options.load,
+			frame: options.frame,
 			timeoutMs: Number.parseInt(options.timeout, 10)
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("hover").argument("<selector>").option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
+	agent.command("hover").argument("[selector]").option("--text <text>", "hover the element with this visible text").option("--exact", "with --text: require an exact text match").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
 		const result = await agentInteract(runtime, {
 			action: "hover",
-			selector,
+			selector: resolveTarget(selector, options),
+			frame: options.frame,
 			fallbackSelectors: options.fallback
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("select").argument("<selector>").argument("<value>").option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, value, options) => {
+	agent.command("select").argument("<selector>").argument("<value>").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, value, options) => {
 		const result = await agentInteract(runtime, {
 			action: "select",
 			selector,
 			value,
+			frame: options.frame,
 			fallbackSelectors: options.fallback
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("toggle").argument("<selector>").option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
+	agent.command("toggle").argument("<selector>").option("--frame <selector>", FRAME_HELP).option("--fallback <selector>", "backup CSS selector", collect, []).action(async (selector, options) => {
 		const result = await agentInteract(runtime, {
 			action: "toggle",
 			selector,
+			frame: options.frame,
 			fallbackSelectors: options.fallback
 		});
 		console.log(JSON.stringify(result));
@@ -466,6 +677,29 @@ async function main() {
 		const result = await agentDismissCookies(runtime);
 		console.log(JSON.stringify(result));
 	});
+	agent.command("eval").description("Evaluate a JavaScript expression in the page and print its JSON value").argument("<expression>", "expression; promises are awaited").option("--frame <selector>", FRAME_HELP).action(async (expression, options) => {
+		const result = await agentEval(runtime, {
+			expression,
+			frame: options.frame
+		});
+		console.log(JSON.stringify(result));
+	});
+	agent.command("tabs").description("List open tabs").action(async () => {
+		const result = await agentTabs(runtime);
+		console.log(JSON.stringify(result));
+	});
+	agent.command("tab").description("Switch the session to another tab").argument("<id>", "tab id (or unique prefix) from agent tabs").action(async (id) => {
+		const result = await agentTabSwitch(runtime, { id });
+		console.log(JSON.stringify(result));
+	});
+	agent.command("tab-new").description("Open a new tab, switch to it and optionally navigate").argument("[url]").action(async (url) => {
+		const result = await agentTabNew(runtime, { url });
+		console.log(JSON.stringify(result));
+	});
+	agent.command("tab-close").description("Close a tab (switches to another tab if it was active)").argument("<id>", "tab id (or unique prefix) from agent tabs").action(async (id) => {
+		const result = await agentTabClose(runtime, { id });
+		console.log(JSON.stringify(result));
+	});
 	agent.command("restart").action(async () => {
 		const result = await agentRestart(runtime);
 		console.log(JSON.stringify(result));
@@ -482,12 +716,25 @@ async function main() {
 		});
 		console.log(JSON.stringify(result));
 	});
-	agent.command("elements").description("List interactive elements on the current page").option("--roles <roles>", "comma-separated roles filter", (v) => v.split(",")).option("--visible-only", "only visible elements", true).option("--no-visible-only", "include hidden elements").option("--limit <n>", "max elements", "50").option("--selector <selector>", "scope to CSS selector subtree").action(async (options) => {
+	agent.command("screenshot").description("Save a screenshot of the current page to a file").option("--out <path>", "output file (default: <data dir>/screenshots/<session>-<ts>.<ext>)").option("--format <format>", "png|jpeg", "png").option("--quality <n>", "jpeg quality 0-100").option("--full-page", "capture the full scrollable page").action(async (options) => {
+		if (options.format !== "png" && options.format !== "jpeg") throw new Error(`Invalid --format: ${options.format} (expected png or jpeg)`);
+		const result = await agentScreenshot(runtime, {
+			out: options.out,
+			format: options.format,
+			quality: options.quality ? Number.parseInt(options.quality, 10) : void 0,
+			fullPage: Boolean(options.fullPage)
+		});
+		console.log(JSON.stringify(result));
+	});
+	agent.command("elements").description("List interactive elements on the current page").option("--roles <roles>", "comma-separated roles filter", (v) => v.split(",")).option("--visible-only", "only visible elements", true).option("--no-visible-only", "include hidden elements").option("--limit <n>", "max elements", "50").option("--selector <selector>", "scope to CSS selector subtree").option("--href <substring>", "only links whose href contains this").option("--text <substring>", "only elements whose text/label contains this (case-insensitive)").option("--frame <selector>", FRAME_HELP).action(async (options) => {
 		const result = await agentElements(runtime, {
 			roles: options.roles,
 			visibleOnly: options.visibleOnly,
 			limit: Number.parseInt(options.limit, 10),
-			selector: options.selector
+			selector: options.selector,
+			href: options.href,
+			text: options.text,
+			frame: options.frame
 		});
 		console.log(JSON.stringify(result));
 	});

package/dist/index.d.mts

@@ -12,6 +12,13 @@ interface InteractPayload {
   scrollX?: number;
   scrollY?: number;
   timeoutMs?: number;
+  /**
+   * Locator of an iframe to run the action in. Needed for cross-origin frames,
+   * which `>>>` cannot pierce from the page. Composed selectors like
+   * `iframe#consent >>> button` are split automatically when the frame is
+   * cross-origin, so this is only required for explicit control.
+   */
+  frame?: string;
 }
 type PageContentMode = "title" | "text" | "html" | "a11y" | "summary";
 interface PageContentOptions {
@@ -48,11 +55,36 @@ interface InteractiveElementsOptions {
   visibleOnly?: boolean;
   limit?: number;
   selector?: string;
+  /** Case-insensitive substring filter on the element's href. */
+  href?: string;
+  /** Case-insensitive substring filter on text, aria-label, placeholder, value or title. */
+  text?: string;
+  /** Discover elements inside this iframe (works for cross-origin frames). */
+  frame?: string;
+}
+/** An iframe whose content discovery could not enter from the page context. */
+interface CrossOriginFrameInfo {
+  selector: string;
+  title?: string;
+  src?: string;
 }
 interface InteractiveElementsResult {
   elements: InteractiveElement[];
   totalFound: number;
   truncated: boolean;
+  /** Cross-origin iframes skipped by discovery — pass one as `frame` to look inside. */
+  crossOriginFrames?: CrossOriginFrameInfo[];
+}
+interface PageState {
+  url: string;
+  title: string;
+  readyState: string;
+}
+interface TabInfo {
+  id: string;
+  url: string;
+  title: string;
+  targetWsUrl: string;
 }
 interface LaunchOptions {
   executablePath?: string;
@@ -62,7 +94,7 @@ interface LaunchOptions {
 }
 interface DismissCookieBannerResult {
   dismissed: boolean;
-  method?: "a11y" | "selector" | "text";
+  method?: "a11y" | "selector" | "text" | "iframe" | "iframe-text";
   detail?: string;
 }
 type ErrorCode = "SELECTOR_NOT_FOUND" | "ELEMENT_COVERED" | "ELEMENT_NOT_EDITABLE" | "NAVIGATION_TIMEOUT" | "NAVIGATION_FAILED" | "CDP_DISCONNECTED" | "SESSION_DEAD" | "DIALOG_BLOCKING" | "TIMEOUT" | "UNKNOWN";
@@ -95,6 +127,11 @@ interface BrowserController {
   dismissCookieBanner(targetWsUrl: string): Promise<DismissCookieBannerResult>;
   screenshot(targetWsUrl: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(targetWsUrl: string): Promise<string>;
+  getPageState(targetWsUrl: string): Promise<PageState>;
+  listTabs(cdpUrl: string): Promise<TabInfo[]>;
+  openTab(cdpUrl: string): Promise<TabInfo>;
+  activateTab(cdpUrl: string, tabId: string): Promise<void>;
+  closeTab(cdpUrl: string, tabId: string): Promise<void>;
   terminate(pid: number): void;
   closeConnection?(targetWsUrl: string): void;
   dispose?(): void;
@@ -462,6 +499,18 @@ declare class SessionManager {
   getInteractiveElements(sessionId: string, options: InteractiveElementsOptions): Promise<InteractiveElementsResult>;
   screenshot(sessionId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(sessionId: string): Promise<string>;
+  getPageState(sessionId: string): Promise<PageState>;
+  listTabs(sessionId: string): Promise<Array<TabInfo & {
+    active: boolean;
+  }>>;
+  /** Points the session at another tab; later commands run there. */
+  switchTab(sessionId: string, tabId: string): Promise<TabInfo>;
+  newTab(sessionId: string): Promise<TabInfo>;
+  /** Closes a tab; closing the active one moves the session to a remaining tab. */
+  closeTab(sessionId: string, tabId: string): Promise<{
+    closed: string;
+    active: TabInfo;
+  }>;
   dismissCookieBanner(sessionId: string): Promise<DismissCookieBannerResult>;
   setStatus(status: SessionStatus, reason: string): Session;
   terminateSession(sessionId: string): Promise<Session>;
@@ -622,6 +671,16 @@ declare class ControlApi {
   dismissCookieBanner(sessionId: string): Promise<DismissCookieBannerResult>;
   screenshot(sessionId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(sessionId: string): Promise<string>;
+  getPageState(sessionId: string): Promise<PageState>;
+  listTabs(sessionId: string): Promise<(TabInfo & {
+    active: boolean;
+  })[]>;
+  switchTab(sessionId: string, tabId: string): Promise<TabInfo>;
+  newTab(sessionId: string): Promise<TabInfo>;
+  closeTab(sessionId: string, tabId: string): Promise<{
+    closed: string;
+    active: TabInfo;
+  }>;
   listEvents(sessionId: string, limit?: number): {
     events: {
       eventId: string;
@@ -791,10 +850,23 @@ export declare class AgenticBrowserCore {
     visibleOnly?: boolean;
     limit?: number;
     selector?: string;
+    href?: string;
+    text?: string;
+    frame?: string;
   }): Promise<InteractiveElementsResult>;
   dismissCookieBanner(sessionId: string): Promise<DismissCookieBannerResult>;
   screenshot(sessionId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
   getCurrentUrl(sessionId: string): Promise<string>;
+  getPageState(sessionId: string): Promise<PageState>;
+  listTabs(sessionId: string): Promise<(TabInfo & {
+    active: boolean;
+  })[]>;
+  switchTab(sessionId: string, tabId: string): Promise<TabInfo>;
+  newTab(sessionId: string): Promise<TabInfo>;
+  closeTab(sessionId: string, tabId: string): Promise<{
+    closed: string;
+    active: TabInfo;
+  }>;
   restartSession(sessionId: string): Promise<{
     sessionId: string;
     status: "disconnected" | "failed" | "ready" | "starting" | "terminated";

package/dist/index.mjs

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { t as AgenticBrowserCore, n as createAgenticBrowserCore, i as createMockAgenticBrowserCore } from "./runtime-Bo7FmRYk.mjs";
+export { t as AgenticBrowserCore, n as createAgenticBrowserCore, i as createMockAgenticBrowserCore } from "./runtime-CfQ0xGAm.mjs";

package/dist/mcp/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as createAgenticBrowserCore } from "../runtime-Bo7FmRYk.mjs";
+import { n as createAgenticBrowserCore } from "../runtime-CfQ0xGAm.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";