browser-use 0.0.1 → 0.0.2

package/dist/sync/auth.js

@@ -0,0 +1,205 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import axios from 'axios';
+import { CONFIG } from '../config.js';
+import { createLogger } from '../logging-config.js';
+import { uuid7str } from '../utils.js';
+export const TEMP_USER_ID = '99999999-9999-9999-9999-999999999999';
+const logger = createLogger('browser_use.sync.auth');
+const CONFIG_DIR = () => CONFIG.BROWSER_USE_CONFIG_DIR ?? path.join(process.cwd(), '.browseruse');
+const DEVICE_ID_PATH = () => path.join(CONFIG_DIR(), 'device_id');
+const CLOUD_AUTH_PATH = () => path.join(CONFIG_DIR(), 'cloud_auth.json');
+const ensureDir = () => {
+    fs.mkdirSync(CONFIG_DIR(), { recursive: true });
+};
+const loadAuthConfig = () => {
+    try {
+        const contents = fs.readFileSync(CLOUD_AUTH_PATH(), 'utf-8');
+        const parsed = JSON.parse(contents);
+        return {
+            api_token: parsed.api_token ?? null,
+            user_id: parsed.user_id ?? null,
+            authorized_at: parsed.authorized_at ?? null,
+        };
+    }
+    catch {
+        return { api_token: null, user_id: null, authorized_at: null };
+    }
+};
+const saveAuthConfig = (config) => {
+    ensureDir();
+    fs.writeFileSync(CLOUD_AUTH_PATH(), JSON.stringify(config, null, 2), 'utf-8');
+    try {
+        fs.chmodSync(CLOUD_AUTH_PATH(), 0o600);
+    }
+    catch {
+        /* noop */
+    }
+};
+const getOrCreateDeviceId = () => {
+    ensureDir();
+    try {
+        const existing = fs.readFileSync(DEVICE_ID_PATH(), 'utf-8').trim();
+        if (existing) {
+            return existing;
+        }
+    }
+    catch {
+        /* continue */
+    }
+    const deviceId = uuid7str();
+    fs.writeFileSync(DEVICE_ID_PATH(), deviceId, 'utf-8');
+    return deviceId;
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const stripTrailingSlash = (input) => input.replace(/\/+$/, '');
+const terminalWidth = () => Math.max((process.stdout?.columns ?? 80) - 40, 20);
+export class DeviceAuthClient {
+    baseUrl;
+    clientId = 'library';
+    scope = 'read write';
+    httpClient;
+    authConfig;
+    _deviceId;
+    constructor(baseUrl, httpClient) {
+        this.baseUrl = stripTrailingSlash(baseUrl ?? CONFIG.BROWSER_USE_CLOUD_API_URL);
+        this.httpClient = httpClient;
+        this.authConfig = loadAuthConfig();
+        this._deviceId = getOrCreateDeviceId();
+    }
+    get device_id() {
+        return this._deviceId;
+    }
+    get is_authenticated() {
+        return Boolean(this.authConfig.api_token && this.authConfig.user_id);
+    }
+    get api_token() {
+        return this.authConfig.api_token;
+    }
+    get user_id() {
+        return this.authConfig.user_id ?? TEMP_USER_ID;
+    }
+    get client() {
+        return this.httpClient ?? axios;
+    }
+    buildUrl(pathname) {
+        return `${this.baseUrl}${pathname}`;
+    }
+    async postForm(pathname, data) {
+        const form = new URLSearchParams();
+        for (const [key, value] of Object.entries(data)) {
+            if (value !== undefined && value !== null) {
+                form.append(key, String(value));
+            }
+        }
+        return this.client.post(this.buildUrl(pathname), form, {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+    }
+    async start_device_authorization(agent_session_id) {
+        const response = await this.postForm('/api/v1/oauth/device/authorize', {
+            client_id: this.clientId,
+            scope: this.scope,
+            agent_session_id: agent_session_id ?? undefined,
+            device_id: this.device_id,
+        });
+        return response.data;
+    }
+    async poll_for_token(device_code, interval = 3, timeout = 1800) {
+        const started = Date.now();
+        let delay = interval;
+        while (Date.now() - started < timeout * 1000) {
+            try {
+                const response = await this.postForm('/api/v1/oauth/device/token', {
+                    grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    device_code,
+                    client_id: this.clientId,
+                });
+                const data = response.data;
+                if (data.error === 'authorization_pending') {
+                    await sleep(delay * 1000);
+                    continue;
+                }
+                if (data.error === 'slow_down') {
+                    delay = data.interval ?? delay * 2;
+                    await sleep(delay * 1000);
+                    continue;
+                }
+                if (data.error) {
+                    logger.warning(`Device token error: ${data.error}`);
+                    return null;
+                }
+                if (data.access_token) {
+                    return data;
+                }
+            }
+            catch (error) {
+                const status = error?.response?.status;
+                const payload = error?.response?.data;
+                if (status === 400 &&
+                    payload?.error &&
+                    ['authorization_pending', 'slow_down'].includes(payload.error)) {
+                    if (payload.error === 'slow_down') {
+                        delay = payload.interval ?? delay * 2;
+                    }
+                    await sleep(delay * 1000);
+                    continue;
+                }
+                logger.debug(`Error polling for token: ${error?.message ?? error}`);
+                return null;
+            }
+            await sleep(delay * 1000);
+        }
+        return null;
+    }
+    async authenticate(agent_session_id, show_instructions = true) {
+        try {
+            const deviceAuth = await this.start_device_authorization(agent_session_id);
+            const frontendBase = CONFIG.BROWSER_USE_CLOUD_UI_URL ||
+                this.baseUrl.replace('//api.', '//cloud.');
+            const replaceHost = (value) => value?.replace(this.baseUrl, frontendBase);
+            const verificationUri = replaceHost(deviceAuth.verification_uri);
+            const verificationUriComplete = replaceHost(deviceAuth.verification_uri_complete);
+            if (show_instructions) {
+                const divider = '─'.repeat(terminalWidth());
+                logger.info(divider);
+                logger.info('🌐  View the details of this run in Browser Use Cloud:');
+                logger.info(`    👉  ${verificationUriComplete}`);
+                logger.info(divider + '\n');
+            }
+            const tokenData = await this.poll_for_token(deviceAuth.device_code, deviceAuth.interval ?? 5);
+            if (tokenData?.access_token) {
+                this.authConfig = {
+                    api_token: tokenData.access_token,
+                    user_id: tokenData.user_id ?? this.user_id,
+                    authorized_at: new Date().toISOString(),
+                };
+                saveAuthConfig(this.authConfig);
+                if (show_instructions) {
+                    logger.debug('✅ Authentication successful, cloud sync enabled.');
+                }
+                return true;
+            }
+        }
+        catch (error) {
+            const status = error?.response?.status;
+            if (status === 404) {
+                logger.warning('Cloud sync authentication endpoint not found (404).');
+            }
+            else {
+                logger.warning(`Cloud sync auth error: ${error?.message ?? error}`);
+            }
+        }
+        if (show_instructions) {
+            logger.debug(`❌ Sync authentication failed for ${this.baseUrl}`);
+        }
+        return false;
+    }
+    get_headers() {
+        return this.api_token ? { Authorization: `Bearer ${this.api_token}` } : {};
+    }
+    clear_auth() {
+        this.authConfig = { api_token: null, user_id: null, authorized_at: null };
+        saveAuthConfig(this.authConfig);
+    }
+}

package/dist/sync/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth.js';
+export * from './service.js';

package/dist/sync/index.js

@@ -0,0 +1,2 @@
+export * from './auth.js';
+export * from './service.js';

package/dist/sync/service.d.ts

@@ -0,0 +1,21 @@
+import type { BaseEvent } from '../agent/cloud-events.js';
+import { DeviceAuthClient } from './auth.js';
+export interface CloudSyncOptions {
+    baseUrl?: string;
+    enableAuth?: boolean;
+}
+export declare class CloudSync {
+    private readonly baseUrl;
+    private readonly enableAuth;
+    readonly auth_client?: DeviceAuthClient;
+    private pendingEvents;
+    private authTask;
+    private sessionId;
+    constructor(options?: CloudSyncOptions);
+    handle_event(event: BaseEvent): Promise<void>;
+    private sendEvent;
+    private backgroundAuth;
+    private resendPendingEvents;
+    wait_for_auth(): Promise<void>;
+    authenticate(showInstructions?: boolean): Promise<boolean>;
+}

package/dist/sync/service.js

@@ -0,0 +1,146 @@
+import axios from 'axios';
+import { createLogger } from '../logging-config.js';
+import { CONFIG } from '../config.js';
+import { DeviceAuthClient, TEMP_USER_ID } from './auth.js';
+const logger = createLogger('browser_use.sync');
+const stripTrailingSlash = (input) => input.replace(/\/+$/, '');
+const ensureArray = (value) => Array.isArray(value) ? value : [value];
+export class CloudSync {
+    baseUrl;
+    enableAuth;
+    auth_client;
+    pendingEvents = [];
+    authTask = null;
+    sessionId = null;
+    constructor(options = {}) {
+        this.baseUrl = stripTrailingSlash(options.baseUrl ?? CONFIG.BROWSER_USE_CLOUD_API_URL);
+        this.enableAuth = options.enableAuth ?? true;
+        this.auth_client = this.enableAuth
+            ? new DeviceAuthClient(this.baseUrl)
+            : undefined;
+    }
+    async handle_event(event) {
+        try {
+            if (event.event_type === 'CreateAgentSessionEvent' &&
+                event?.id) {
+                this.sessionId = String(event.id);
+            }
+            if (event.event_type === 'CreateAgentStepEvent') {
+                const raw = event;
+                const step = raw?.step ?? raw?.payload?.step;
+                if (step === 2 &&
+                    this.enableAuth &&
+                    this.auth_client &&
+                    !this.authTask) {
+                    if (this.sessionId) {
+                        this.authTask = this.backgroundAuth(this.sessionId);
+                    }
+                    else {
+                        logger.warning('Cannot start cloud auth, session_id missing');
+                    }
+                }
+            }
+            await this.sendEvent(event);
+        }
+        catch (error) {
+            logger.error(`Failed to handle ${event.event_type}: ${error.message}`);
+        }
+    }
+    async sendEvent(event) {
+        try {
+            const headers = {};
+            const authClient = this.auth_client;
+            const userId = authClient ? authClient.user_id : TEMP_USER_ID;
+            event.user_id = userId;
+            if (authClient) {
+                Object.assign(headers, authClient.get_headers());
+                event.device_id = authClient.device_id;
+            }
+            const payload = typeof event?.toJSON === 'function'
+                ? event.toJSON()
+                : { ...event };
+            const events = ensureArray(payload);
+            await axios.post(`${this.baseUrl}/api/v1/events`, {
+                events: events.map((entry) => ({
+                    ...entry,
+                    device_id: entry.device_id ?? authClient?.device_id,
+                })),
+            }, { headers, timeout: 10_000 });
+        }
+        catch (error) {
+            const status = error?.response?.status;
+            if (status === 401 &&
+                this.auth_client &&
+                !this.auth_client.is_authenticated) {
+                this.pendingEvents.push(event);
+                return;
+            }
+            if (status) {
+                logger.debug(`Cloud sync HTTP ${status}: ${error?.response?.data ?? error}`);
+            }
+            else if (error?.code === 'ECONNABORTED') {
+                logger.warning(`Cloud sync timeout sending ${event.event_type}`);
+            }
+            else {
+                logger.warning(`Cloud sync error: ${error?.message ?? error}`);
+            }
+        }
+    }
+    async backgroundAuth(agentSessionId) {
+        const authClient = this.auth_client;
+        if (!authClient) {
+            return;
+        }
+        try {
+            if (authClient.is_authenticated) {
+                const frontend = CONFIG.BROWSER_USE_CLOUD_UI_URL ||
+                    this.baseUrl.replace('//api.', '//cloud.');
+                const sessionUrl = `${stripTrailingSlash(frontend)}/agent/${agentSessionId}`;
+                const divider = '─'.repeat(Math.max((process.stdout?.columns ?? 80) - 40, 20));
+                logger.info(divider);
+                logger.info('🌐  View the details of this run in Browser Use Cloud:');
+                logger.info(`    👉  ${sessionUrl}`);
+                logger.info(divider + '\n');
+                return;
+            }
+            const success = await authClient.authenticate(agentSessionId, true);
+            if (success) {
+                await this.resendPendingEvents();
+            }
+        }
+        catch (error) {
+            logger.debug(`Cloud sync auth error: ${error.message}`);
+        }
+    }
+    async resendPendingEvents() {
+        if (!this.pendingEvents.length) {
+            return;
+        }
+        const events = [...this.pendingEvents];
+        this.pendingEvents = [];
+        for (const event of events) {
+            try {
+                await this.sendEvent(event);
+            }
+            catch (error) {
+                logger.warning(`Failed to resend event ${event.event_type}: ${error.message}`);
+            }
+        }
+    }
+    async wait_for_auth() {
+        if (this.authTask) {
+            try {
+                await this.authTask;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    async authenticate(showInstructions = true) {
+        if (!this.auth_client) {
+            return false;
+        }
+        return this.auth_client.authenticate(this.sessionId, showInstructions);
+    }
+}

package/dist/telemetry/index.d.ts

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

package/dist/telemetry/index.js

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

package/dist/telemetry/service.d.ts

@@ -0,0 +1,12 @@
+import type { BaseTelemetryEvent } from './views.js';
+export declare class ProductTelemetry {
+    private client;
+    private debugLogging;
+    private userIdFile;
+    private cachedUserId;
+    constructor();
+    capture(event: BaseTelemetryEvent): void;
+    flush(): void;
+    get userId(): string;
+}
+export declare const productTelemetry: ProductTelemetry;

package/dist/telemetry/service.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PostHog } from 'posthog-node';
+import { createLogger } from '../logging-config.js';
+import { CONFIG } from '../config.js';
+import { uuid7str } from '../utils.js';
+const logger = createLogger('browser_use.telemetry');
+const POSTHOG_EVENT_SETTINGS = {
+    process_person_profile: true,
+};
+export class ProductTelemetry {
+    client = null;
+    debugLogging;
+    userIdFile;
+    cachedUserId = null;
+    constructor() {
+        this.debugLogging = CONFIG.BROWSER_USE_LOGGING_LEVEL === 'debug';
+        this.userIdFile = path.join(CONFIG.BROWSER_USE_CONFIG_DIR, 'device_id');
+        if (!CONFIG.ANONYMIZED_TELEMETRY) {
+            logger.debug('Telemetry disabled');
+            return;
+        }
+        try {
+            this.client = new PostHog('phc_F8JMNjW1i2KbGUTaW1unnDdLSPCoyc52SGRU0JecaUh', {
+                host: 'https://eu.i.posthog.com',
+                disableGeoip: false,
+                enableExceptionAutocapture: true,
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to initialize PostHog client: ${error.message}`);
+            this.client = null;
+        }
+    }
+    capture(event) {
+        if (!this.client) {
+            return;
+        }
+        try {
+            this.client.capture({
+                distinctId: this.userId,
+                event: event.name,
+                properties: {
+                    ...event.properties(),
+                    ...POSTHOG_EVENT_SETTINGS,
+                },
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to send telemetry event ${event.name}: ${error.message}`);
+        }
+    }
+    flush() {
+        if (!this.client) {
+            return;
+        }
+        try {
+            this.client.flush();
+            logger.debug('PostHog client telemetry queue flushed.');
+        }
+        catch (error) {
+            logger.error(`Failed to flush PostHog client: ${error.message}`);
+        }
+    }
+    get userId() {
+        if (this.cachedUserId) {
+            return this.cachedUserId;
+        }
+        try {
+            if (!fs.existsSync(this.userIdFile)) {
+                fs.mkdirSync(path.dirname(this.userIdFile), { recursive: true });
+                this.cachedUserId = uuid7str();
+                fs.writeFileSync(this.userIdFile, this.cachedUserId, 'utf-8');
+            }
+            else {
+                this.cachedUserId = fs.readFileSync(this.userIdFile, 'utf-8');
+            }
+        }
+        catch {
+            this.cachedUserId = 'UNKNOWN_USER_ID';
+        }
+        return this.cachedUserId;
+    }
+}
+export const productTelemetry = new ProductTelemetry();

package/dist/telemetry/views.d.ts

@@ -0,0 +1,112 @@
+export declare abstract class BaseTelemetryEvent {
+    abstract name: string;
+    properties(): Record<string, unknown>;
+}
+type BaseSequence = Array<string | null | undefined> | undefined;
+export interface AgentTelemetryPayload {
+    task: string;
+    model: string;
+    model_provider: string;
+    planner_llm: string | null;
+    max_steps: number;
+    max_actions_per_step: number;
+    use_vision: boolean;
+    use_validation: boolean;
+    version: string;
+    source: string;
+    cdp_url: string | null;
+    action_errors: BaseSequence;
+    action_history: Array<Array<Record<string, unknown>> | null> | undefined;
+    urls_visited: BaseSequence;
+    steps: number;
+    total_input_tokens: number;
+    total_duration_seconds: number;
+    success: boolean | null;
+    final_result_response: string | null;
+    error_message: string | null;
+}
+export declare class AgentTelemetryEvent extends BaseTelemetryEvent implements AgentTelemetryPayload {
+    name: string;
+    task: string;
+    model: string;
+    model_provider: string;
+    planner_llm: string | null;
+    max_steps: number;
+    max_actions_per_step: number;
+    use_vision: boolean;
+    use_validation: boolean;
+    version: string;
+    source: string;
+    cdp_url: string | null;
+    action_errors: BaseSequence;
+    action_history: Array<Array<Record<string, unknown>> | null> | undefined;
+    urls_visited: BaseSequence;
+    steps: number;
+    total_input_tokens: number;
+    total_duration_seconds: number;
+    success: boolean | null;
+    final_result_response: string | null;
+    error_message: string | null;
+    constructor(payload: AgentTelemetryPayload);
+}
+export interface MCPClientTelemetryPayload {
+    server_name: string;
+    command: string;
+    tools_discovered: number;
+    version: string;
+    action: string;
+    tool_name?: string | null;
+    duration_seconds?: number | null;
+    error_message?: string | null;
+}
+export declare class MCPClientTelemetryEvent extends BaseTelemetryEvent implements MCPClientTelemetryPayload {
+    name: string;
+    server_name: string;
+    command: string;
+    tools_discovered: number;
+    version: string;
+    action: string;
+    tool_name: string | null;
+    duration_seconds: number | null;
+    error_message: string | null;
+    constructor(payload: MCPClientTelemetryPayload);
+}
+export interface MCPServerTelemetryPayload {
+    version: string;
+    action: string;
+    tool_name?: string | null;
+    duration_seconds?: number | null;
+    error_message?: string | null;
+    parent_process_cmdline?: string | null;
+}
+export declare class MCPServerTelemetryEvent extends BaseTelemetryEvent implements MCPServerTelemetryPayload {
+    name: string;
+    version: string;
+    action: string;
+    tool_name: string | null;
+    duration_seconds: number | null;
+    error_message: string | null;
+    parent_process_cmdline: string | null;
+    constructor(payload: MCPServerTelemetryPayload);
+}
+export interface CLITelemetryPayload {
+    version: string;
+    action: string;
+    mode: string;
+    model?: string | null;
+    model_provider?: string | null;
+    duration_seconds?: number | null;
+    error_message?: string | null;
+}
+export declare class CLITelemetryEvent extends BaseTelemetryEvent implements CLITelemetryPayload {
+    name: string;
+    version: string;
+    action: string;
+    mode: string;
+    model: string | null;
+    model_provider: string | null;
+    duration_seconds: number | null;
+    error_message: string | null;
+    constructor(payload: CLITelemetryPayload);
+}
+export {};