@xopcai/xopc 0.0.251 → 0.0.252

package/dist/src/browser/automations/schema.js

@@ -0,0 +1,135 @@
+import { z } from "zod";
+//#region src/browser/automations/schema.ts
+const ExpectationSchema = z.object({
+	urlIncludes: z.string().optional(),
+	titleIncludes: z.string().optional(),
+	textIncludes: z.string().optional(),
+	ref: z.string().optional(),
+	state: z.enum(["visible", "hidden"]).optional()
+}).strict();
+const TargetSchema = z.object({
+	role: z.string().min(1),
+	name: z.string().min(1).optional(),
+	nameIncludes: z.string().min(1).optional()
+}).strict().superRefine((target, ctx) => {
+	if (target.name && target.nameIncludes) ctx.addIssue({
+		code: "custom",
+		message: "Use name or nameIncludes, not both."
+	});
+});
+const StepSchema = z.discriminatedUnion("action", [
+	z.object({
+		action: z.literal("navigate"),
+		url: z.string().min(1),
+		expect: ExpectationSchema.optional()
+	}).strict(),
+	z.object({
+		action: z.literal("click"),
+		target: TargetSchema,
+		expect: ExpectationSchema.optional()
+	}).strict(),
+	z.object({
+		action: z.literal("fill"),
+		target: TargetSchema,
+		value: z.string(),
+		submit: z.boolean().optional(),
+		expect: ExpectationSchema.optional()
+	}).strict(),
+	z.object({
+		action: z.literal("select"),
+		target: TargetSchema,
+		value: z.string(),
+		expect: ExpectationSchema.optional()
+	}).strict(),
+	z.object({
+		action: z.literal("press"),
+		target: TargetSchema.optional(),
+		key: z.string().min(1),
+		expect: ExpectationSchema.optional()
+	}).strict(),
+	z.object({
+		action: z.literal("scroll"),
+		target: TargetSchema.optional(),
+		deltaY: z.number(),
+		expect: ExpectationSchema.optional()
+	}).strict(),
+	z.object({
+		action: z.literal("wait"),
+		condition: z.enum([
+			"page_idle",
+			"text",
+			"visible",
+			"hidden"
+		]),
+		value: z.string().optional(),
+		target: TargetSchema.optional(),
+		timeoutMs: z.number().int().min(100).max(12e4).optional()
+	}).strict()
+]);
+const InputSchema = z.object({
+	type: z.enum([
+		"string",
+		"number",
+		"boolean"
+	]),
+	required: z.boolean().optional(),
+	default: z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	]).optional(),
+	description: z.string().min(1).max(200).optional(),
+	choices: z.array(z.union([
+		z.string(),
+		z.number(),
+		z.boolean()
+	])).min(1).max(50).optional()
+}).strict().superRefine((input, ctx) => {
+	if (input.default !== void 0 && typeof input.default !== input.type) ctx.addIssue({
+		code: "custom",
+		message: `Default must be ${input.type}.`
+	});
+	if (input.choices?.some((choice) => typeof choice !== input.type)) ctx.addIssue({
+		code: "custom",
+		message: `Every choice must be ${input.type}.`
+	});
+});
+const DomainSchema = z.string().min(1).refine((value) => {
+	if (value !== value.toLowerCase() || value.includes("/") || value.includes(":")) return false;
+	try {
+		return new URL(`https://${value}`).hostname === value;
+	} catch {
+		return false;
+	}
+}, "Domain must be one exact lowercase hostname.");
+const BrowserAutomationDefinitionSchema = z.object({
+	id: z.string().regex(/^[a-z][a-z0-9-]{1,63}$/),
+	name: z.string().min(1).max(120),
+	description: z.string().max(500).optional(),
+	allowedDomains: z.array(DomainSchema).min(1),
+	risk: z.enum([
+		"read",
+		"draft",
+		"external_effect",
+		"destructive",
+		"sensitive"
+	]),
+	inputs: z.record(z.string(), InputSchema).default({}),
+	steps: z.array(StepSchema).min(1).max(100)
+}).strict().superRefine((definition, ctx) => {
+	if (new Set(definition.allowedDomains).size !== definition.allowedDomains.length) ctx.addIssue({
+		code: "custom",
+		path: ["allowedDomains"],
+		message: "Domains must be unique."
+	});
+	for (const [index, step] of definition.steps.entries()) {
+		const values = step.action === "navigate" ? [step.url] : step.action === "fill" || step.action === "select" ? [step.value] : step.action === "press" ? [step.key] : step.action === "wait" && step.value ? [step.value] : [];
+		for (const value of values) for (const match of value.matchAll(/\$\{input\.([a-zA-Z][a-zA-Z0-9_]*)\}/g)) if (!definition.inputs[match[1]]) ctx.addIssue({
+			code: "custom",
+			path: ["steps", index],
+			message: `Unknown input template: ${match[1]}.`
+		});
+	}
+});
+//#endregion
+export { BrowserAutomationDefinitionSchema };

package/dist/src/browser/automations/service.d.ts

@@ -0,0 +1,146 @@
+import type { BrowserAutomation, BrowserAutomationDefinition, BrowserAutomationRun, BrowserAutomationStatus } from './types.js';
+export type BrowserAutomationExecutor = (input: {
+    definition: BrowserAutomationDefinition;
+    inputs: Record<string, unknown>;
+    signal: AbortSignal;
+    onStep: (event: unknown) => void;
+}) => Promise<{
+    ok: boolean;
+    result?: unknown;
+    error?: string;
+}>;
+export declare class BrowserAutomationService {
+    private readonly executor;
+    private readonly emit?;
+    private activeRuns;
+    private executions;
+    private waiters;
+    constructor(executor: BrowserAutomationExecutor, emit?: (type: string, payload: unknown) => void);
+    list(): BrowserAutomation[];
+    get(id: string): BrowserAutomation;
+    listRuns(automationId?: string): BrowserAutomationRun[];
+    getRun(id: string): BrowserAutomationRun;
+    listRunEvents(id: string): import("./types.js").BrowserAutomationRunEvent[];
+    validate(definition: unknown): import("zod/index.cjs").ZodSafeParseResult<{
+        id: string;
+        name: string;
+        allowedDomains: string[];
+        risk: "read" | "sensitive" | "destructive" | "draft" | "external_effect";
+        inputs: Record<string, {
+            type: "string" | "number" | "boolean";
+            required?: boolean;
+            default?: string | number | boolean;
+            description?: string;
+            choices?: (string | number | boolean)[];
+        }>;
+        steps: ({
+            action: "navigate";
+            url: string;
+            expect?: {
+                urlIncludes?: string;
+                titleIncludes?: string;
+                textIncludes?: string;
+                ref?: string;
+                state?: "hidden" | "visible";
+            };
+        } | {
+            action: "click";
+            target: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+            };
+            expect?: {
+                urlIncludes?: string;
+                titleIncludes?: string;
+                textIncludes?: string;
+                ref?: string;
+                state?: "hidden" | "visible";
+            };
+        } | {
+            action: "fill";
+            target: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+            };
+            value: string;
+            submit?: boolean;
+            expect?: {
+                urlIncludes?: string;
+                titleIncludes?: string;
+                textIncludes?: string;
+                ref?: string;
+                state?: "hidden" | "visible";
+            };
+        } | {
+            action: "select";
+            target: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+            };
+            value: string;
+            expect?: {
+                urlIncludes?: string;
+                titleIncludes?: string;
+                textIncludes?: string;
+                ref?: string;
+                state?: "hidden" | "visible";
+            };
+        } | {
+            action: "press";
+            key: string;
+            target?: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+            };
+            expect?: {
+                urlIncludes?: string;
+                titleIncludes?: string;
+                textIncludes?: string;
+                ref?: string;
+                state?: "hidden" | "visible";
+            };
+        } | {
+            action: "scroll";
+            deltaY: number;
+            target?: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+            };
+            expect?: {
+                urlIncludes?: string;
+                titleIncludes?: string;
+                textIncludes?: string;
+                ref?: string;
+                state?: "hidden" | "visible";
+            };
+        } | {
+            action: "wait";
+            condition: "hidden" | "text" | "visible" | "page_idle";
+            value?: string;
+            target?: {
+                role: string;
+                name?: string;
+                nameIncludes?: string;
+            };
+            timeoutMs?: number;
+        })[];
+        description?: string;
+    }>;
+    save(input: {
+        definition: unknown;
+        status?: BrowserAutomationStatus;
+        expectedId?: string;
+    }): BrowserAutomation;
+    remove(id: string): boolean;
+    startRun(automationId: string, inputs: Record<string, unknown>): BrowserAutomationRun;
+    cancel(runId: string): boolean;
+    shutdown(): Promise<void>;
+    runAndWait(automationId: string, inputs: Record<string, unknown>, signal?: AbortSignal): Promise<BrowserAutomationRun>;
+    private addEvent;
+    private execute;
+}

package/dist/src/browser/automations/service.js

@@ -0,0 +1,168 @@
+import { BrowserAutomationDefinitionSchema } from "./schema.js";
+import { resolveBrowserAutomationInputs } from "./runner.js";
+import { appendBrowserAutomationRunEvent, deleteBrowserAutomation, getBrowserAutomation, getBrowserAutomationRun, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun } from "./repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/browser/automations/service.ts
+var BrowserAutomationService = class {
+	activeRuns = /* @__PURE__ */ new Map();
+	executions = /* @__PURE__ */ new Map();
+	waiters = /* @__PURE__ */ new Map();
+	constructor(executor, emit) {
+		this.executor = executor;
+		this.emit = emit;
+		for (const run of listActiveBrowserAutomationRuns()) {
+			const endedAtMs = Date.now();
+			saveBrowserAutomationRun({
+				...run,
+				status: "failed",
+				error: "Gateway stopped before the run completed.",
+				endedAtMs,
+				durationMs: run.startedAtMs ? endedAtMs - run.startedAtMs : void 0
+			});
+		}
+	}
+	list() {
+		return listBrowserAutomations();
+	}
+	get(id) {
+		return getBrowserAutomation(id);
+	}
+	listRuns(automationId) {
+		return listBrowserAutomationRuns(automationId);
+	}
+	getRun(id) {
+		return getBrowserAutomationRun(id);
+	}
+	listRunEvents(id) {
+		return listBrowserAutomationRunEvents(id);
+	}
+	validate(definition) {
+		return BrowserAutomationDefinitionSchema.safeParse(definition);
+	}
+	save(input) {
+		const parsed = BrowserAutomationDefinitionSchema.parse(input.definition);
+		if (input.expectedId && parsed.id !== input.expectedId) throw new Error("Browser automation id cannot change.");
+		const existing = getBrowserAutomation(parsed.id);
+		const now = Date.now();
+		const automation = {
+			id: parsed.id,
+			revision: (existing?.revision ?? 0) + 1,
+			status: input.status ?? existing?.status ?? "enabled",
+			definition: parsed,
+			createdAtMs: existing?.createdAtMs ?? now,
+			updatedAtMs: now
+		};
+		saveBrowserAutomation(automation);
+		return automation;
+	}
+	remove(id) {
+		if (hasActiveBrowserAutomationRuns(id)) throw new Error("Cannot delete a running browser automation.");
+		return deleteBrowserAutomation(id);
+	}
+	startRun(automationId, inputs) {
+		const automation = getBrowserAutomation(automationId);
+		if (!automation) throw new Error("Browser automation not found.");
+		if (automation.status !== "enabled") throw new Error("Browser automation is disabled.");
+		const resolvedInputs = resolveBrowserAutomationInputs(automation.definition, inputs);
+		const run = {
+			id: randomUUID(),
+			automationId,
+			automationRevision: automation.revision,
+			definition: automation.definition,
+			status: "queued",
+			inputs: resolvedInputs,
+			createdAtMs: Date.now()
+		};
+		saveBrowserAutomationRun(run);
+		this.addEvent(run.id, "run.queued", { automationId });
+		const execution = this.execute(run);
+		this.executions.set(run.id, execution);
+		execution.finally(() => this.executions.delete(run.id)).catch(() => void 0);
+		return run;
+	}
+	cancel(runId) {
+		const active = this.activeRuns.get(runId);
+		if (!active) return false;
+		active.abort();
+		return true;
+	}
+	async shutdown() {
+		for (const active of this.activeRuns.values()) active.abort();
+		await Promise.allSettled(this.executions.values());
+	}
+	async runAndWait(automationId, inputs, signal) {
+		const run = this.startRun(automationId, inputs);
+		return new Promise((resolve) => {
+			const complete = (value) => {
+				signal?.removeEventListener("abort", onAbort);
+				resolve(value);
+			};
+			const onAbort = () => this.cancel(run.id);
+			const set = this.waiters.get(run.id) ?? /* @__PURE__ */ new Set();
+			set.add(complete);
+			this.waiters.set(run.id, set);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (signal?.aborted) onAbort();
+		});
+	}
+	addEvent(runId, type, data) {
+		const event = {
+			id: randomUUID(),
+			runId,
+			seq: nextBrowserAutomationRunEventSeq(runId),
+			type,
+			data,
+			createdAtMs: Date.now()
+		};
+		appendBrowserAutomationRunEvent(event);
+		this.emit?.(`browser.automation.${type}`, event);
+	}
+	async execute(run) {
+		const controller = new AbortController();
+		this.activeRuns.set(run.id, controller);
+		const startedAtMs = Date.now();
+		let current = {
+			...run,
+			status: "running",
+			startedAtMs
+		};
+		saveBrowserAutomationRun(current);
+		this.addEvent(run.id, "run.started");
+		try {
+			const outcome = await this.executor({
+				definition: run.definition,
+				inputs: run.inputs,
+				signal: controller.signal,
+				onStep: (event) => this.addEvent(run.id, "step", event)
+			});
+			const endedAtMs = Date.now();
+			current = {
+				...current,
+				status: controller.signal.aborted ? "cancelled" : outcome.ok ? "succeeded" : "failed",
+				result: outcome.result,
+				error: outcome.error,
+				endedAtMs,
+				durationMs: endedAtMs - startedAtMs
+			};
+		} catch (error) {
+			const endedAtMs = Date.now();
+			current = {
+				...current,
+				status: controller.signal.aborted ? "cancelled" : "failed",
+				error: error instanceof Error ? error.message : String(error),
+				endedAtMs,
+				durationMs: endedAtMs - startedAtMs
+			};
+		}
+		saveBrowserAutomationRun(current);
+		this.addEvent(run.id, "run.completed", {
+			status: current.status,
+			error: current.error
+		});
+		this.activeRuns.delete(run.id);
+		for (const waiter of this.waiters.get(run.id) ?? []) waiter(current);
+		this.waiters.delete(run.id);
+	}
+};
+//#endregion
+export { BrowserAutomationService };

package/dist/src/browser/automations/types.d.ts

@@ -0,0 +1,90 @@
+import type { BrowserExpectation, BrowserRiskLevel } from '@xopcai/browser-control-contract';
+export type BrowserAutomationStatus = 'enabled' | 'disabled';
+export type BrowserAutomationRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export interface BrowserAutomationInputDefinition {
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    default?: string | number | boolean;
+    description?: string;
+    choices?: Array<string | number | boolean>;
+}
+export interface BrowserSemanticTarget {
+    role: string;
+    name?: string;
+    nameIncludes?: string;
+}
+export type BrowserAutomationStep = {
+    action: 'navigate';
+    url: string;
+    expect?: BrowserExpectation;
+} | {
+    action: 'click';
+    target: BrowserSemanticTarget;
+    expect?: BrowserExpectation;
+} | {
+    action: 'fill';
+    target: BrowserSemanticTarget;
+    value: string;
+    submit?: boolean;
+    expect?: BrowserExpectation;
+} | {
+    action: 'select';
+    target: BrowserSemanticTarget;
+    value: string;
+    expect?: BrowserExpectation;
+} | {
+    action: 'press';
+    target?: BrowserSemanticTarget;
+    key: string;
+    expect?: BrowserExpectation;
+} | {
+    action: 'scroll';
+    target?: BrowserSemanticTarget;
+    deltaY: number;
+    expect?: BrowserExpectation;
+} | {
+    action: 'wait';
+    condition: 'page_idle' | 'text' | 'visible' | 'hidden';
+    value?: string;
+    target?: BrowserSemanticTarget;
+    timeoutMs?: number;
+};
+export interface BrowserAutomationDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    allowedDomains: string[];
+    risk: BrowserRiskLevel;
+    inputs: Record<string, BrowserAutomationInputDefinition>;
+    steps: BrowserAutomationStep[];
+}
+export interface BrowserAutomation {
+    id: string;
+    revision: number;
+    status: BrowserAutomationStatus;
+    definition: BrowserAutomationDefinition;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export interface BrowserAutomationRun {
+    id: string;
+    automationId: string;
+    automationRevision: number;
+    definition: BrowserAutomationDefinition;
+    status: BrowserAutomationRunStatus;
+    inputs: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    createdAtMs: number;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    durationMs?: number;
+}
+export interface BrowserAutomationRunEvent {
+    id: string;
+    runId: string;
+    seq: number;
+    type: string;
+    data?: unknown;
+    createdAtMs: number;
+}

package/dist/src/browser/cache-dir-policy.d.ts

@@ -1,5 +1,5 @@
 /**
- * Where user-facing browser caches (CloakBrowser binaries, CDP launcher
+ * Where user-facing browser caches (extension artifacts and CDP launcher
  * profiles, etc.) are allowed to live.
  *
  * Restricting the writable set to the user's home directory makes it safe to

package/dist/src/browser/cache-dir-policy.js

@@ -1,4 +1,3 @@
-import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { homedir } from "node:os";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 //#region src/browser/cache-dir-policy.ts
@@ -47,7 +46,5 @@ function assertCacheDir(input) {
 	if (r.ok === false) throw new Error(r.message);
 	return r.resolved;
 }
-var init_cache_dir_policy = __esmMin((() => {}));
 //#endregion
-init_cache_dir_policy();
-export { assertCacheDir, checkCacheDir, expandHome, init_cache_dir_policy };
+export { assertCacheDir, checkCacheDir, expandHome };

package/dist/src/browser/drivers/browser-driver.d.ts

@@ -0,0 +1,17 @@
+import type { BrowserActionInput, BrowserControlResult, BrowserNavigateInput, BrowserObservation, BrowserObserveInput, BrowserTabsInput } from '@xopcai/browser-control-contract';
+export type BrowserPrimitiveInput = Exclude<BrowserActionInput, BrowserNavigateInput | BrowserObserveInput | BrowserTabsInput | {
+    action: 'sequence';
+} | {
+    action: 'close';
+}>;
+export interface BrowserDriver {
+    readonly kind: 'playwright' | 'extension';
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createSession(sessionId: string): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+    navigate(sessionId: string, input: BrowserNavigateInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    observe(sessionId: string, input: BrowserObserveInput, signal?: AbortSignal): Promise<BrowserObservation>;
+    perform(sessionId: string, input: BrowserPrimitiveInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    tabs(sessionId: string, input: BrowserTabsInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+}

package/dist/src/browser/drivers/create-driver.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '../../config/schema.js';
+import type { BrowserDriver } from './browser-driver.js';
+export declare function createBrowserDriver(config: Config['browser']): Promise<BrowserDriver>;

package/dist/src/browser/drivers/create-driver.js

@@ -0,0 +1,84 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { loadPlaywrightCoreModule } from "../providers/playwright-doctor.js";
+import { BrowserbaseProvider } from "../providers/browserbase.js";
+import { BrowserUseProvider } from "../providers/browser-use.js";
+import { acquireExtensionBrowserServer } from "../providers/extension-ws-acquire.js";
+import { ExtensionDriver } from "./extension-driver.js";
+import { PlaywrightDriver } from "./playwright-driver.js";
+//#region src/browser/drivers/create-driver.ts
+init_logger();
+const log = createLogger("BrowserDriverFactory");
+async function createBrowserDriver(config) {
+	const limits = config.limits;
+	if (config.driver.kind === "extension") {
+		const { provider, release } = await acquireExtensionBrowserServer({
+			host: "127.0.0.1",
+			port: 19820,
+			connectionTimeout: limits.actionTimeoutMs,
+			commandTimeout: limits.actionTimeoutMs
+		});
+		return new ExtensionDriver(provider, limits.actionTimeoutMs, config.observation.visualFallback, release);
+	}
+	const driver = config.driver;
+	return new PlaywrightDriver({
+		connect: () => connectPlaywright(driver),
+		maxNodes: config.observation.maxNodes,
+		maxCharacters: config.observation.maxCharacters,
+		visualFallback: config.observation.visualFallback,
+		actionTimeoutMs: limits.actionTimeoutMs
+	});
+}
+async function connectPlaywright(driver) {
+	if (driver.kind === "remote") {
+		const provider = driver.provider === "browserbase" ? new BrowserbaseProvider({
+			type: driver.provider,
+			apiKey: driver.apiKey,
+			projectId: driver.projectId,
+			region: driver.region
+		}) : new BrowserUseProvider({
+			type: driver.provider,
+			apiKey: driver.apiKey,
+			projectId: driver.projectId,
+			region: driver.region
+		});
+		return {
+			...await provider.connect(),
+			release: () => provider.disconnect()
+		};
+	}
+	const playwright = await loadPlaywrightCoreModule();
+	const chromium = playwright.chromium ?? playwright.default?.chromium;
+	if (!chromium) throw new Error("playwright-core did not expose Chromium");
+	if (driver.kind === "cdp") {
+		const browser = await chromium.connectOverCDP(driver.endpoint);
+		const context = browser.contexts()[0] ?? await browser.newContext();
+		log.info({ kind: driver.kind }, "Browser driver connected");
+		return {
+			browser,
+			context
+		};
+	}
+	const browser = await chromium.launch({
+		headless: driver.headless,
+		executablePath: driver.executablePath,
+		args: ["--no-sandbox", "--disable-setuid-sandbox"]
+	});
+	const context = await createContext(browser);
+	log.info({
+		kind: driver.kind,
+		headless: driver.headless
+	}, "Browser driver connected");
+	return {
+		browser,
+		context
+	};
+}
+async function createContext(browser) {
+	return browser.newContext({ viewport: {
+		width: 1280,
+		height: 720
+	} });
+}
+//#endregion
+export { createBrowserDriver };

package/dist/src/browser/drivers/extension-driver.d.ts

@@ -0,0 +1,20 @@
+import type { BrowserControlResult, BrowserNavigateInput, BrowserObservation, BrowserObserveInput, BrowserTabsInput } from '@xopcai/browser-control-contract';
+import type { ExtensionBrowserProvider } from '../providers/extension.js';
+import type { BrowserDriver, BrowserPrimitiveInput } from './browser-driver.js';
+export declare class ExtensionDriver implements BrowserDriver {
+    private readonly provider;
+    private readonly timeoutMs;
+    private readonly visualFallback;
+    private readonly release;
+    readonly kind: "extension";
+    constructor(provider: ExtensionBrowserProvider, timeoutMs: number, visualFallback: boolean, release: () => Promise<void>);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createSession(_sessionId: string): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+    navigate(_sessionId: string, input: BrowserNavigateInput): Promise<BrowserControlResult>;
+    observe(_sessionId: string, input: BrowserObserveInput): Promise<BrowserObservation>;
+    perform(_sessionId: string, input: BrowserPrimitiveInput): Promise<BrowserControlResult>;
+    tabs(_sessionId: string, input: BrowserTabsInput): Promise<BrowserControlResult>;
+    private send;
+}