browser-use 0.5.0 → 0.6.0

package/dist/browser/watchdogs/base.js

@@ -1,4 +1,20 @@
 const resolveEventType = (eventTypeRef) => typeof eventTypeRef === 'string' ? eventTypeRef : eventTypeRef.name;
+const LIFECYCLE_EVENT_NAMES = new Set([
+    'BrowserStartEvent',
+    'BrowserStopEvent',
+    'BrowserStoppedEvent',
+    'BrowserLaunchEvent',
+    'BrowserKillEvent',
+    'BrowserConnectedEvent',
+    'BrowserReconnectingEvent',
+    'BrowserReconnectedEvent',
+    'BrowserErrorEvent',
+]);
+const createConnectionError = (message) => {
+    const error = new Error(message);
+    error.name = 'ConnectionError';
+    return error;
+};
 export class BaseWatchdog {
     static LISTENS_TO = [];
     static EMITS = [];
@@ -32,7 +48,24 @@ export class BaseWatchdog {
                 continue;
             }
             const bound = method.bind(this);
-            this.event_bus.on(event_type, bound, { handler_id });
+            const wrapped = async (event) => {
+                if (!LIFECYCLE_EVENT_NAMES.has(event_type) &&
+                    this.browser_session.should_gate_watchdog_events &&
+                    !this.browser_session.is_cdp_connected) {
+                    if (this.browser_session.is_reconnecting) {
+                        await this.browser_session.wait_for_reconnect();
+                        if (!this.browser_session.is_cdp_connected) {
+                            throw createConnectionError(`[${this.constructor.name}.${methodName}] Reconnection failed; browser connection is still unavailable`);
+                        }
+                    }
+                    else {
+                        this.browser_session.logger.debug(`[${this.constructor.name}.${methodName}] Skipped because browser connection is not available`);
+                        return null;
+                    }
+                }
+                return await bound(event);
+            };
+            this.event_bus.on(event_type, wrapped, { handler_id });
             this._registeredHandlers.push({ event_type, handler_id });
             registeredEventTypes.add(event_type);
         }

package/dist/browser/watchdogs/captcha-watchdog.d.ts

@@ -0,0 +1,26 @@
+import { BrowserConnectedEvent, BrowserStoppedEvent, CaptchaSolverFinishedEvent, CaptchaSolverStartedEvent } from '../events.js';
+import { BaseWatchdog } from './base.js';
+type CaptchaResultType = 'success' | 'failed' | 'timeout' | 'unknown';
+export interface CaptchaWaitResult {
+    waited: boolean;
+    vendor: string;
+    url: string;
+    duration_ms: number;
+    result: CaptchaResultType;
+}
+export declare class CaptchaWatchdog extends BaseWatchdog {
+    static LISTENS_TO: (typeof BrowserConnectedEvent | typeof BrowserStoppedEvent)[];
+    static EMITS: (typeof CaptchaSolverStartedEvent | typeof CaptchaSolverFinishedEvent)[];
+    private _cdpSession;
+    private _handlers;
+    private _captchaSolving;
+    private _captchaInfo;
+    private _captchaResult;
+    private _captchaDurationMs;
+    private _waiters;
+    on_BrowserConnectedEvent(): Promise<void>;
+    on_BrowserStoppedEvent(): Promise<void>;
+    protected onDetached(): void;
+    wait_if_captcha_solving(timeoutSeconds?: number): Promise<CaptchaWaitResult | null>;
+}
+export {};

package/dist/browser/watchdogs/captcha-watchdog.js

@@ -0,0 +1,151 @@
+import { BrowserConnectedEvent, BrowserStoppedEvent, CaptchaSolverFinishedEvent, CaptchaSolverStartedEvent, } from '../events.js';
+import { BaseWatchdog } from './base.js';
+export class CaptchaWatchdog extends BaseWatchdog {
+    static LISTENS_TO = [BrowserConnectedEvent, BrowserStoppedEvent];
+    static EMITS = [
+        CaptchaSolverStartedEvent,
+        CaptchaSolverFinishedEvent,
+    ];
+    _cdpSession = null;
+    _handlers = [];
+    _captchaSolving = false;
+    _captchaInfo = {
+        vendor: 'unknown',
+        url: '',
+        target_id: '',
+    };
+    _captchaResult = 'unknown';
+    _captchaDurationMs = 0;
+    _waiters = new Set();
+    async on_BrowserConnectedEvent() {
+        if (this._cdpSession) {
+            return;
+        }
+        const page = await this.browser_session.get_current_page();
+        if (!page) {
+            return;
+        }
+        try {
+            const cdpSession = (await this.browser_session.get_or_create_cdp_session(page));
+            const onStarted = (payload) => {
+                this._captchaSolving = true;
+                this._captchaResult = 'unknown';
+                this._captchaDurationMs = 0;
+                this._captchaInfo = {
+                    vendor: String(payload?.vendor ?? 'unknown'),
+                    url: String(payload?.url ?? ''),
+                    target_id: String(payload?.targetId ?? ''),
+                };
+                void this.event_bus.dispatch(new CaptchaSolverStartedEvent({
+                    target_id: this._captchaInfo.target_id,
+                    vendor: this._captchaInfo.vendor,
+                    url: this._captchaInfo.url,
+                    started_at: Number(payload?.startedAt ?? Date.now()),
+                }));
+            };
+            const onFinished = (payload) => {
+                this._captchaSolving = false;
+                this._captchaDurationMs = Number(payload?.durationMs ?? 0);
+                this._captchaResult = payload?.success ? 'success' : 'failed';
+                const vendor = String(payload?.vendor ?? this._captchaInfo.vendor);
+                const url = String(payload?.url ?? this._captchaInfo.url);
+                const targetId = String(payload?.targetId ?? this._captchaInfo.target_id);
+                for (const resolve of this._waiters) {
+                    resolve();
+                }
+                this._waiters.clear();
+                void this.event_bus.dispatch(new CaptchaSolverFinishedEvent({
+                    target_id: targetId,
+                    vendor,
+                    url,
+                    duration_ms: this._captchaDurationMs,
+                    finished_at: Number(payload?.finishedAt ?? Date.now()),
+                    success: Boolean(payload?.success),
+                }));
+            };
+            cdpSession.on?.('BrowserUse.captchaSolverStarted', onStarted);
+            cdpSession.on?.('BrowserUse.captchaSolverFinished', onFinished);
+            this._cdpSession = cdpSession;
+            this._handlers = [
+                { event: 'BrowserUse.captchaSolverStarted', handler: onStarted },
+                { event: 'BrowserUse.captchaSolverFinished', handler: onFinished },
+            ];
+        }
+        catch (error) {
+            this.browser_session.logger.debug(`CaptchaWatchdog monitoring unavailable: ${error.message}`);
+            await this.on_BrowserStoppedEvent();
+        }
+    }
+    async on_BrowserStoppedEvent() {
+        this._captchaSolving = false;
+        this._captchaResult = 'unknown';
+        this._captchaDurationMs = 0;
+        this._captchaInfo = { vendor: 'unknown', url: '', target_id: '' };
+        for (const resolve of this._waiters) {
+            resolve();
+        }
+        this._waiters.clear();
+        if (!this._cdpSession) {
+            return;
+        }
+        for (const { event, handler } of this._handlers) {
+            this._cdpSession.off?.(event, handler);
+        }
+        this._handlers = [];
+        try {
+            await this._cdpSession.detach?.();
+        }
+        catch {
+            // Ignore detach errors during shutdown.
+        }
+        finally {
+            this._cdpSession = null;
+        }
+    }
+    onDetached() {
+        void this.on_BrowserStoppedEvent();
+    }
+    async wait_if_captcha_solving(timeoutSeconds = 120) {
+        if (!this._captchaSolving) {
+            return null;
+        }
+        const vendor = this._captchaInfo.vendor;
+        const url = this._captchaInfo.url;
+        const timeoutMs = Math.max(0, timeoutSeconds * 1000);
+        try {
+            await new Promise((resolve, reject) => {
+                const onResolved = () => {
+                    cleanup();
+                    resolve();
+                };
+                const timeoutHandle = setTimeout(() => {
+                    cleanup();
+                    reject(new Error('timeout'));
+                }, timeoutMs);
+                const cleanup = () => {
+                    clearTimeout(timeoutHandle);
+                    this._waiters.delete(onResolved);
+                };
+                this._waiters.add(onResolved);
+            });
+            return {
+                waited: true,
+                vendor,
+                url,
+                duration_ms: this._captchaDurationMs,
+                result: this._captchaResult,
+            };
+        }
+        catch {
+            this._captchaSolving = false;
+            this._waiters.clear();
+            return {
+                waited: true,
+                vendor,
+                url,
+                duration_ms: timeoutMs,
+                result: 'timeout',
+            };
+        }
+    }
+}

package/dist/browser/watchdogs/index.d.ts

@@ -1,6 +1,7 @@
 export * from './base.js';
 export * from './aboutblank-watchdog.js';
 export * from './cdp-session-watchdog.js';
+export * from './captcha-watchdog.js';
 export * from './crash-watchdog.js';
 export * from './default-action-watchdog.js';
 export * from './dom-watchdog.js';

package/dist/browser/watchdogs/index.js

@@ -1,6 +1,7 @@
 export * from './base.js';
 export * from './aboutblank-watchdog.js';
 export * from './cdp-session-watchdog.js';
+export * from './captcha-watchdog.js';
 export * from './crash-watchdog.js';
 export * from './default-action-watchdog.js';
 export * from './dom-watchdog.js';

package/dist/browser/watchdogs/screenshot-watchdog.js

@@ -4,10 +4,11 @@ export class ScreenshotWatchdog extends BaseWatchdog {
     static LISTENS_TO = [ScreenshotEvent];
     async on_ScreenshotEvent(event) {
         try {
-            return await this.browser_session.take_screenshot(event.full_page);
-        }
-        finally {
             await this.browser_session.remove_highlights();
         }
+        catch {
+            // Highlight cleanup is best-effort and should not block screenshots.
+        }
+        return await this.browser_session.take_screenshot(event.full_page, event.clip);
     }
 }

package/dist/cli.d.ts

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
 import { BrowserProfile } from './browser/profile.js';
+import { CloudBrowserClient } from './browser/cloud/cloud.js';
+import { CloudManagementClient } from './browser/cloud/management.js';
 import type { BaseChatModel } from './llm/base.js';
+import { get_tunnel_manager } from './skill-cli/tunnel.js';
 type CliModelProvider = 'openai' | 'anthropic' | 'google' | 'deepseek' | 'groq' | 'openrouter' | 'azure' | 'mistral' | 'cerebras' | 'vercel' | 'oci' | 'aws-anthropic' | 'aws' | 'ollama' | 'browser-use';
 export interface ParsedCliArgs {
     help: boolean;
@@ -21,6 +25,10 @@ export interface ParsedCliArgs {
     provider: CliModelProvider | null;
     prompt: string | null;
     mcp: boolean;
+    json: boolean;
+    yes: boolean;
+    setup_mode: string | null;
+    api_key: string | null;
     positional: string[];
 }
 export declare const CLI_HISTORY_LIMIT = 100;
@@ -39,5 +47,117 @@ export declare const shouldStartInteractiveMode: (task: string | null, options?:
 export declare const getLlmFromCliArgs: (args: ParsedCliArgs) => BaseChatModel;
 export declare const buildBrowserProfileFromCliArgs: (args: ParsedCliArgs) => BrowserProfile | null;
 export declare const getCliUsage: () => string;
+export interface RunInstallCommandOptions {
+    playwright_cli_path?: string;
+    spawn_impl?: typeof spawnSync;
+}
+type WritableLike = {
+    write(chunk: string): unknown;
+};
+export interface RunTunnelCommandOptions {
+    manager?: Pick<ReturnType<typeof get_tunnel_manager>, 'start_tunnel' | 'list_tunnels' | 'stop_tunnel' | 'stop_all_tunnels'>;
+    stdout?: WritableLike;
+    stderr?: WritableLike;
+    json_output?: boolean;
+}
+export interface RunSetupCommandOptions {
+    run_doctor_checks?: (options?: RunDoctorChecksOptions) => Promise<CliDoctorReport>;
+    install_command?: () => void | Promise<void>;
+    save_api_key?: (api_key: string) => void;
+    stdout?: WritableLike;
+    stderr?: WritableLike;
+    json_output?: boolean;
+}
+export interface RunTaskCommandOptions {
+    client?: Pick<CloudManagementClient, 'list_tasks' | 'get_task' | 'update_task' | 'get_task_logs'>;
+    stdout?: WritableLike;
+    stderr?: WritableLike;
+}
+export interface RunSessionCommandOptions {
+    client?: Pick<CloudManagementClient, 'list_sessions' | 'get_session' | 'update_session' | 'create_session' | 'create_session_public_share' | 'delete_session_public_share'>;
+    stdout?: WritableLike;
+    stderr?: WritableLike;
+}
+export interface RunProfileCommandOptions {
+    client?: Pick<CloudManagementClient, 'list_profiles' | 'get_profile' | 'create_profile' | 'update_profile' | 'delete_profile'>;
+    profile_lister?: () => Array<{
+        directory: string;
+        name: string;
+        email?: string;
+    }>;
+    local_session_factory?: (profile_directory: string) => {
+        start: () => Promise<unknown>;
+        stop?: () => Promise<void>;
+        get_cookies?: () => Promise<BrowserCookieInit[]>;
+    };
+    remote_session_factory?: (init: {
+        cdp_url: string;
+    }) => {
+        start: () => Promise<unknown>;
+        stop?: () => Promise<void>;
+        browser_context?: {
+            addCookies?: (cookies: BrowserCookieInit[]) => Promise<unknown>;
+        } | null;
+    };
+    cloud_browser_client_factory?: () => Pick<CloudBrowserClient, 'create_browser' | 'stop_browser'>;
+    stdout?: WritableLike;
+    stderr?: WritableLike;
+}
+export interface RunCloudTaskCommandOptions {
+    client?: Pick<CloudManagementClient, 'create_task' | 'create_session' | 'get_task' | 'update_session'>;
+    stdout?: WritableLike;
+    stderr?: WritableLike;
+    sleep_impl?: (ms: number) => Promise<void>;
+}
+type BrowserCookieInit = {
+    name: string;
+    value: string;
+    url?: string;
+    domain?: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    partitionKey?: string;
+};
+export declare const runInstallCommand: (options?: RunInstallCommandOptions) => void;
+export declare const runTunnelCommand: (argv: string[], options?: RunTunnelCommandOptions) => Promise<0 | 1>;
+export declare const runSetupCommand: (params: {
+    mode?: string | null;
+    yes?: boolean;
+    api_key?: string | null;
+}, options?: RunSetupCommandOptions) => Promise<number>;
+export declare const runTaskCommand: (argv: string[], options?: RunTaskCommandOptions) => Promise<0 | 1>;
+export declare const runSessionCommand: (argv: string[], options?: RunSessionCommandOptions) => Promise<0 | 1>;
+export declare const runProfileCommand: (argv: string[], options?: RunProfileCommandOptions) => Promise<0 | 1>;
+export declare const hasCloudRunFlags: (argv: string[]) => boolean;
+type PrefixedSubcommand = {
+    command: 'run' | 'task' | 'session' | 'profile';
+    argv: string[];
+    debug: boolean;
+    forwardedArgs: string[];
+};
+export declare const extractPrefixedSubcommand: (argv: string[]) => PrefixedSubcommand | null;
+export declare const runCloudTaskCommand: (argv: string[], options?: RunCloudTaskCommandOptions) => Promise<0 | 1>;
+export interface CliDoctorCheck {
+    status: 'ok' | 'warning' | 'missing' | 'error';
+    message: string;
+    note?: string;
+    fix?: string;
+}
+export interface CliDoctorReport {
+    status: 'healthy' | 'issues_found';
+    checks: Record<string, CliDoctorCheck>;
+    summary: string;
+}
+export interface RunDoctorChecksOptions {
+    version?: string;
+    browser_executable?: string | null;
+    api_key?: string | null;
+    cloudflared_path?: string | null;
+    fetch_impl?: typeof fetch;
+}
+export declare const runDoctorChecks: (options?: RunDoctorChecksOptions) => Promise<CliDoctorReport>;
 export declare function main(argv?: string[]): Promise<void>;
 export {};