browser-use 0.2.0 → 0.3.0

package/dist/sandbox/views.d.ts

@@ -0,0 +1,67 @@
+export declare class SandboxError extends Error {
+    constructor(message: string);
+}
+export declare enum SSEEventType {
+    BROWSER_CREATED = "browser_created",
+    INSTANCE_CREATED = "instance_created",
+    INSTANCE_READY = "instance_ready",
+    LOG = "log",
+    RESULT = "result",
+    ERROR = "error",
+    STREAM_COMPLETE = "stream_complete"
+}
+export declare class BrowserCreatedData {
+    session_id: string;
+    live_url: string;
+    status: string;
+    constructor(init: {
+        session_id: string;
+        live_url: string;
+        status: string;
+    });
+}
+export declare class LogData {
+    message: string;
+    level: string;
+    constructor(init: {
+        message: string;
+        level?: string;
+    });
+}
+export interface ExecutionResponse {
+    success: boolean;
+    result?: unknown;
+    error?: string | null;
+    traceback?: string | null;
+}
+export declare class ResultData {
+    execution_response: ExecutionResponse;
+    constructor(init: {
+        execution_response: ExecutionResponse;
+    });
+}
+export declare class ErrorData {
+    error: string;
+    traceback: string | null;
+    status_code: number;
+    constructor(init: {
+        error: string;
+        traceback?: string | null;
+        status_code?: number;
+    });
+}
+export declare class SSEEvent {
+    type: SSEEventType;
+    data: BrowserCreatedData | LogData | ResultData | ErrorData | Record<string, unknown>;
+    timestamp: string | null;
+    constructor(init: {
+        type: SSEEventType;
+        data: BrowserCreatedData | LogData | ResultData | ErrorData | Record<string, unknown>;
+        timestamp?: string | null;
+    });
+    static from_json(event_json: string): SSEEvent;
+    is_browser_created(): boolean;
+    is_log(): boolean;
+    is_result(): boolean;
+    is_error(): boolean;
+}

package/dist/sandbox/views.js

@@ -0,0 +1,121 @@
+export class SandboxError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SandboxError';
+    }
+}
+export var SSEEventType;
+(function (SSEEventType) {
+    SSEEventType["BROWSER_CREATED"] = "browser_created";
+    SSEEventType["INSTANCE_CREATED"] = "instance_created";
+    SSEEventType["INSTANCE_READY"] = "instance_ready";
+    SSEEventType["LOG"] = "log";
+    SSEEventType["RESULT"] = "result";
+    SSEEventType["ERROR"] = "error";
+    SSEEventType["STREAM_COMPLETE"] = "stream_complete";
+})(SSEEventType || (SSEEventType = {}));
+export class BrowserCreatedData {
+    session_id;
+    live_url;
+    status;
+    constructor(init) {
+        this.session_id = init.session_id;
+        this.live_url = init.live_url;
+        this.status = init.status;
+    }
+}
+export class LogData {
+    message;
+    level;
+    constructor(init) {
+        this.message = init.message;
+        this.level = init.level ?? 'info';
+    }
+}
+export class ResultData {
+    execution_response;
+    constructor(init) {
+        this.execution_response = init.execution_response;
+    }
+}
+export class ErrorData {
+    error;
+    traceback;
+    status_code;
+    constructor(init) {
+        this.error = init.error;
+        this.traceback = init.traceback ?? null;
+        this.status_code = init.status_code ?? 500;
+    }
+}
+export class SSEEvent {
+    type;
+    data;
+    timestamp;
+    constructor(init) {
+        this.type = init.type;
+        this.data = init.data;
+        this.timestamp = init.timestamp ?? null;
+    }
+    static from_json(event_json) {
+        const raw = JSON.parse(event_json);
+        const type = raw.type;
+        const payload = raw.data ?? {};
+        let data;
+        if (type === SSEEventType.BROWSER_CREATED) {
+            data = new BrowserCreatedData({
+                session_id: String(payload.session_id ?? ''),
+                live_url: String(payload.live_url ?? ''),
+                status: String(payload.status ?? ''),
+            });
+        }
+        else if (type === SSEEventType.LOG) {
+            data = new LogData({
+                message: String(payload.message ?? ''),
+                level: payload.level == null ? undefined : String(payload.level),
+            });
+        }
+        else if (type === SSEEventType.RESULT) {
+            data = new ResultData({
+                execution_response: {
+                    success: Boolean(payload.execution_response?.success),
+                    result: payload.execution_response?.result,
+                    error: payload.execution_response?.error == null
+                        ? null
+                        : String(payload.execution_response?.error),
+                    traceback: payload.execution_response?.traceback == null
+                        ? null
+                        : String(payload.execution_response?.traceback),
+                },
+            });
+        }
+        else if (type === SSEEventType.ERROR) {
+            data = new ErrorData({
+                error: String(payload.error ?? ''),
+                traceback: payload.traceback == null ? null : String(payload.traceback),
+                status_code: payload.status_code == null ? undefined : Number(payload.status_code),
+            });
+        }
+        else {
+            data = payload;
+        }
+        return new SSEEvent({
+            type,
+            data,
+            timestamp: raw.timestamp ?? null,
+        });
+    }
+    is_browser_created() {
+        return (this.type === SSEEventType.BROWSER_CREATED &&
+            this.data instanceof BrowserCreatedData);
+    }
+    is_log() {
+        return this.type === SSEEventType.LOG && this.data instanceof LogData;
+    }
+    is_result() {
+        return this.type === SSEEventType.RESULT && this.data instanceof ResultData;
+    }
+    is_error() {
+        return this.type === SSEEventType.ERROR && this.data instanceof ErrorData;
+    }
+}

package/dist/skill-cli/index.d.ts

@@ -0,0 +1,3 @@
+export * from './protocol.js';
+export * from './sessions.js';
+export * from './server.js';

package/dist/skill-cli/index.js

@@ -0,0 +1,3 @@
+export * from './protocol.js';
+export * from './sessions.js';
+export * from './server.js';

package/dist/skill-cli/protocol.d.ts

@@ -0,0 +1,30 @@
+export interface RequestInit {
+    id: string;
+    action: string;
+    session: string;
+    params?: Record<string, unknown>;
+}
+export declare class Request {
+    id: string;
+    action: string;
+    session: string;
+    params: Record<string, unknown>;
+    constructor(init: RequestInit);
+    to_json(): string;
+    static from_json(data: string): Request;
+}
+export interface ResponseInit {
+    id: string;
+    success: boolean;
+    data?: unknown;
+    error?: string | null;
+}
+export declare class Response {
+    id: string;
+    success: boolean;
+    data: unknown;
+    error: string | null;
+    constructor(init: ResponseInit);
+    to_json(): string;
+    static from_json(data: string): Response;
+}

package/dist/skill-cli/protocol.js

@@ -0,0 +1,48 @@
+export class Request {
+    id;
+    action;
+    session;
+    params;
+    constructor(init) {
+        this.id = init.id;
+        this.action = init.action;
+        this.session = init.session;
+        this.params = init.params ?? {};
+    }
+    to_json() {
+        return JSON.stringify({
+            id: this.id,
+            action: this.action,
+            session: this.session,
+            params: this.params,
+        });
+    }
+    static from_json(data) {
+        const parsed = JSON.parse(data);
+        return new Request(parsed);
+    }
+}
+export class Response {
+    id;
+    success;
+    data;
+    error;
+    constructor(init) {
+        this.id = init.id;
+        this.success = init.success;
+        this.data = init.data ?? null;
+        this.error = init.error ?? null;
+    }
+    to_json() {
+        return JSON.stringify({
+            id: this.id,
+            success: this.success,
+            data: this.data,
+            error: this.error,
+        });
+    }
+    static from_json(data) {
+        const parsed = JSON.parse(data);
+        return new Response(parsed);
+    }
+}

package/dist/skill-cli/server.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response } from './protocol.js';
+import { SessionRegistry } from './sessions.js';
+export interface SkillCliServerOptions {
+    registry?: SessionRegistry;
+}
+export declare class SkillCliServer {
+    readonly registry: SessionRegistry;
+    constructor(options?: SkillCliServerOptions);
+    private _handle_browser_action;
+    handle_request(request: Request | string): Promise<Response>;
+}

package/dist/skill-cli/server.js

@@ -0,0 +1,85 @@
+import { Request, Response } from './protocol.js';
+import { SessionRegistry } from './sessions.js';
+export class SkillCliServer {
+    registry;
+    constructor(options = {}) {
+        this.registry = options.registry ?? new SessionRegistry();
+    }
+    async _handle_browser_action(action, sessionName, params) {
+        const session = await this.registry.get_or_create_session(sessionName);
+        const browser_session = session.browser_session;
+        if (action === 'open') {
+            const url = String(params.url ?? '');
+            if (!url) {
+                throw new Error('Missing url');
+            }
+            await browser_session.navigate_to(url);
+            return { url };
+        }
+        if (action === 'click') {
+            const index = Number(params.index);
+            if (!Number.isFinite(index)) {
+                throw new Error('Missing index');
+            }
+            const node = await browser_session.get_dom_element_by_index(index);
+            if (!node) {
+                return {
+                    error: `Element index ${index} not found - page may have changed`,
+                };
+            }
+            await browser_session._click_element_node(node);
+            return { clicked: index };
+        }
+        if (action === 'type') {
+            const text = String(params.text ?? '');
+            await browser_session.send_keys(text);
+            return { typed: text };
+        }
+        if (action === 'state') {
+            const state = await browser_session.get_browser_state_with_recovery({
+                include_screenshot: false,
+            });
+            return {
+                url: state.url,
+                title: state.title,
+                tabs: state.tabs,
+                llm_representation: state.llm_representation(),
+            };
+        }
+        if (action === 'close') {
+            await this.registry.close_session(sessionName);
+            return { closed: sessionName };
+        }
+        if (action === 'sessions') {
+            const sessions = this.registry.list_sessions();
+            return { sessions, count: sessions.length };
+        }
+        throw new Error(`Unknown action: ${action}`);
+    }
+    async handle_request(request) {
+        const req = typeof request === 'string' ? Request.from_json(request) : request;
+        try {
+            const data = await this._handle_browser_action(req.action, req.session, req.params);
+            if (data && typeof data === 'object' && 'error' in data) {
+                return new Response({
+                    id: req.id,
+                    success: false,
+                    data: null,
+                    error: String(data.error),
+                });
+            }
+            return new Response({
+                id: req.id,
+                success: true,
+                data,
+            });
+        }
+        catch (error) {
+            return new Response({
+                id: req.id,
+                success: false,
+                error: String(error?.message ?? error),
+            });
+        }
+    }
+}

package/dist/skill-cli/sessions.d.ts

@@ -0,0 +1,24 @@
+import { BrowserSession } from '../browser/session.js';
+export interface SessionInfo {
+    name: string;
+    browser_session: BrowserSession;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface SessionRegistryOptions {
+    session_factory?: (name: string) => BrowserSession;
+}
+export declare class SessionRegistry {
+    private readonly sessions;
+    private readonly session_factory;
+    constructor(options?: SessionRegistryOptions);
+    get_or_create_session(name: string): Promise<SessionInfo>;
+    list_sessions(): {
+        name: string;
+        created_at: string;
+        updated_at: string;
+        tab_count: number;
+    }[];
+    close_session(name: string): Promise<boolean>;
+    close_all(): Promise<void>;
+}

package/dist/skill-cli/sessions.js

@@ -0,0 +1,47 @@
+import { BrowserSession } from '../browser/session.js';
+export class SessionRegistry {
+    sessions = new Map();
+    session_factory;
+    constructor(options = {}) {
+        this.session_factory =
+            options.session_factory ?? (() => new BrowserSession());
+    }
+    async get_or_create_session(name) {
+        const existing = this.sessions.get(name);
+        if (existing) {
+            existing.updated_at = new Date();
+            return existing;
+        }
+        const browser_session = this.session_factory(name);
+        const session = {
+            name,
+            browser_session,
+            created_at: new Date(),
+            updated_at: new Date(),
+        };
+        this.sessions.set(name, session);
+        return session;
+    }
+    list_sessions() {
+        return [...this.sessions.values()].map((session) => ({
+            name: session.name,
+            created_at: session.created_at.toISOString(),
+            updated_at: session.updated_at.toISOString(),
+            tab_count: session.browser_session.tabs.length,
+        }));
+    }
+    async close_session(name) {
+        const existing = this.sessions.get(name);
+        if (!existing) {
+            return false;
+        }
+        await existing.browser_session.stop();
+        this.sessions.delete(name);
+        return true;
+    }
+    async close_all() {
+        for (const name of [...this.sessions.keys()]) {
+            await this.close_session(name);
+        }
+    }
+}

package/dist/skills/index.d.ts

@@ -0,0 +1,3 @@
+export * from './views.js';
+export * from './utils.js';
+export * from './service.js';

package/dist/skills/index.js

@@ -0,0 +1,3 @@
+export * from './views.js';
+export * from './utils.js';
+export * from './service.js';

package/dist/skills/service.d.ts

@@ -0,0 +1,27 @@
+import { build_skill_parameters_schema } from './utils.js';
+import { type BrowserCookie, type ExecuteSkillInput, type SkillDefinition, type SkillExecutionResult, type SkillService } from './views.js';
+interface CloudSkillServiceOptions {
+    skill_ids: Array<string | '*'>;
+    api_key?: string | null;
+    base_url?: string | null;
+    fetch_impl?: typeof fetch;
+}
+export declare class CloudSkillService implements SkillService {
+    private readonly skill_ids;
+    private readonly api_key;
+    private readonly base_url;
+    private readonly fetch_impl;
+    private initialized;
+    private readonly skills;
+    constructor(options: CloudSkillServiceOptions);
+    private requestJson;
+    private listSkillsPage;
+    private ensureInitialized;
+    get_skill(skill_id: string): Promise<SkillDefinition | null>;
+    get_all_skills(): Promise<SkillDefinition[]>;
+    execute_skill(input: ExecuteSkillInput): Promise<SkillExecutionResult>;
+    close(): Promise<void>;
+}
+export declare const register_skills_as_actions: (skills: SkillDefinition[], registerAction: (slug: string, description: string, params: ReturnType<typeof build_skill_parameters_schema>, skill: SkillDefinition) => void) => Promise<void>;
+export declare const cookies_to_map: (cookies: BrowserCookie[]) => Map<string, string>;
+export {};