browser-use 0.4.0 → 0.6.0

package/dist/skill-cli/tunnel.js

@@ -0,0 +1,257 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+const TUNNEL_URL_PATTERN = /(https:\/\/\S+\.trycloudflare\.com)/;
+const DEFAULT_TUNNELS_DIR = path.join(os.homedir(), '.browser-use', 'tunnels');
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const findSystemBinary = (binary) => {
+    const command = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(command, [binary], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    return (result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? null);
+};
+export class TunnelManager {
+    tunnel_dir;
+    binary_resolver;
+    spawn_impl;
+    sleep_impl;
+    is_process_alive_impl;
+    kill_process_impl;
+    binary_path = null;
+    constructor(options = {}) {
+        this.tunnel_dir = options.tunnel_dir ?? DEFAULT_TUNNELS_DIR;
+        this.binary_resolver = options.binary_resolver ?? findSystemBinary;
+        this.spawn_impl = options.spawn_impl ?? spawn;
+        this.sleep_impl = options.sleep_impl ?? sleep;
+        this.is_process_alive_impl =
+            options.is_process_alive ?? default_is_process_alive;
+        this.kill_process_impl = options.kill_process ?? default_kill_process;
+    }
+    get_tunnel_file(port) {
+        return path.join(this.tunnel_dir, `${port}.json`);
+    }
+    get_tunnel_log_file(port) {
+        return path.join(this.tunnel_dir, `${port}.log`);
+    }
+    save_tunnel_info(port, pid, url) {
+        fs.mkdirSync(this.tunnel_dir, { recursive: true });
+        fs.writeFileSync(this.get_tunnel_file(port), JSON.stringify({ port, pid, url }), 'utf-8');
+    }
+    load_tunnel_info(port) {
+        const filePath = this.get_tunnel_file(port);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            if (!parsed ||
+                typeof parsed.port !== 'number' ||
+                typeof parsed.pid !== 'number' ||
+                typeof parsed.url !== 'string') {
+                fs.rmSync(filePath, { force: true });
+                return null;
+            }
+            if (!this.is_process_alive_impl(parsed.pid)) {
+                fs.rmSync(filePath, { force: true });
+                fs.rmSync(this.get_tunnel_log_file(port), { force: true });
+                return null;
+            }
+            return {
+                port: parsed.port,
+                pid: parsed.pid,
+                url: parsed.url,
+            };
+        }
+        catch {
+            fs.rmSync(filePath, { force: true });
+            return null;
+        }
+    }
+    get_binary_path() {
+        if (this.binary_path) {
+            return this.binary_path;
+        }
+        const systemBinary = this.binary_resolver('cloudflared');
+        if (systemBinary) {
+            this.binary_path = systemBinary;
+            return systemBinary;
+        }
+        throw new Error('cloudflared not installed.\n\nInstall cloudflared:\n  macOS:   brew install cloudflared\n  Linux:   curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o ~/.local/bin/cloudflared && chmod +x ~/.local/bin/cloudflared\n  Windows: winget install Cloudflare.cloudflared');
+    }
+    is_available() {
+        if (this.binary_path) {
+            return true;
+        }
+        return Boolean(this.binary_resolver('cloudflared'));
+    }
+    get_status() {
+        const systemBinary = this.binary_resolver('cloudflared');
+        if (systemBinary) {
+            return {
+                available: true,
+                source: 'system',
+                path: systemBinary,
+                note: 'cloudflared installed',
+            };
+        }
+        return {
+            available: false,
+            source: null,
+            path: null,
+            note: 'cloudflared not installed - install it manually before using tunnel',
+        };
+    }
+    async start_tunnel(port) {
+        const existing = this.load_tunnel_info(port);
+        if (existing) {
+            return { url: existing.url, port, existing: true };
+        }
+        let binaryPath;
+        try {
+            binaryPath = this.get_binary_path();
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+        fs.mkdirSync(this.tunnel_dir, { recursive: true });
+        const logPath = this.get_tunnel_log_file(port);
+        const logFd = fs.openSync(logPath, 'w');
+        try {
+            const child = this.spawn_impl(binaryPath, ['tunnel', '--url', `http://localhost:${port}`], {
+                detached: true,
+                stdio: ['ignore', 'ignore', logFd],
+            });
+            child.unref?.();
+            const deadline = Date.now() + 15_000;
+            while (Date.now() < deadline) {
+                const pid = child.pid;
+                if (typeof pid === 'number' && !this.is_process_alive_impl(pid)) {
+                    const content = fs.existsSync(logPath)
+                        ? fs.readFileSync(logPath, 'utf-8')
+                        : '';
+                    return {
+                        error: `cloudflared exited unexpectedly: ${content.slice(0, 500)}`,
+                    };
+                }
+                const content = fs.existsSync(logPath)
+                    ? fs.readFileSync(logPath, 'utf-8')
+                    : '';
+                const match = content.match(TUNNEL_URL_PATTERN);
+                if (match?.[1] && typeof child.pid === 'number') {
+                    this.save_tunnel_info(port, child.pid, match[1]);
+                    return { url: match[1], port };
+                }
+                await this.sleep_impl(200);
+            }
+            if (typeof child.pid === 'number') {
+                await this.kill_process_impl(child.pid);
+            }
+            return { error: 'Timed out waiting for cloudflare tunnel URL (15s)' };
+        }
+        finally {
+            fs.closeSync(logFd);
+        }
+    }
+    list_tunnels() {
+        const tunnels = [];
+        if (!fs.existsSync(this.tunnel_dir)) {
+            return { tunnels, count: 0 };
+        }
+        for (const entry of fs.readdirSync(this.tunnel_dir)) {
+            if (!entry.endsWith('.json')) {
+                continue;
+            }
+            const port = Number.parseInt(path.basename(entry, '.json'), 10);
+            if (!Number.isFinite(port)) {
+                continue;
+            }
+            const info = this.load_tunnel_info(port);
+            if (info) {
+                tunnels.push({ port: info.port, url: info.url });
+            }
+        }
+        return { tunnels, count: tunnels.length };
+    }
+    async stop_tunnel(port) {
+        const info = this.load_tunnel_info(port);
+        if (!info) {
+            return { error: `No tunnel running on port ${port}` };
+        }
+        await this.kill_process_impl(info.pid);
+        fs.rmSync(this.get_tunnel_file(port), { force: true });
+        fs.rmSync(this.get_tunnel_log_file(port), { force: true });
+        return {
+            stopped: port,
+            url: info.url,
+        };
+    }
+    async stop_all_tunnels() {
+        const stopped = [];
+        if (!fs.existsSync(this.tunnel_dir)) {
+            return { stopped, count: 0 };
+        }
+        for (const entry of fs.readdirSync(this.tunnel_dir)) {
+            if (!entry.endsWith('.json')) {
+                continue;
+            }
+            const port = Number.parseInt(path.basename(entry, '.json'), 10);
+            if (!Number.isFinite(port)) {
+                continue;
+            }
+            const result = await this.stop_tunnel(port);
+            if ('stopped' in result) {
+                stopped.push(result.stopped);
+            }
+        }
+        return {
+            stopped,
+            count: stopped.length,
+        };
+    }
+}
+const default_is_process_alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const default_kill_process = async (pid) => {
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        return false;
+    }
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        if (!default_is_process_alive(pid)) {
+            return true;
+        }
+        await sleep(100);
+    }
+    try {
+        process.kill(pid, 'SIGKILL');
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+let tunnel_manager = null;
+export const get_tunnel_manager = () => {
+    if (!tunnel_manager) {
+        tunnel_manager = new TunnelManager();
+    }
+    return tunnel_manager;
+};

package/dist/sync/auth.d.ts

@@ -1,5 +1,12 @@
 import { type AxiosInstance } from 'axios';
 export declare const TEMP_USER_ID = "99999999-9999-9999-9999-999999999999";
+interface CloudAuthConfigData {
+    api_token: string | null;
+    user_id: string | null;
+    authorized_at: string | null;
+}
+export declare const load_cloud_auth_config: () => CloudAuthConfigData;
+export declare const save_cloud_api_token: (api_token: string, user_id?: string | null) => void;
 export declare class DeviceAuthClient {
     private readonly baseUrl;
     private readonly clientId;
@@ -25,3 +32,4 @@ export declare class DeviceAuthClient {
     };
     clear_auth(): void;
 }
+export {};

package/dist/sync/auth.js

@@ -36,6 +36,18 @@ const saveAuthConfig = (config) => {
         /* noop */
     }
 };
+export const load_cloud_auth_config = () => loadAuthConfig();
+export const save_cloud_api_token = (api_token, user_id = TEMP_USER_ID) => {
+    const normalized = api_token.trim();
+    if (!normalized) {
+        throw new Error('API token cannot be empty');
+    }
+    saveAuthConfig({
+        api_token: normalized,
+        user_id,
+        authorized_at: new Date().toISOString(),
+    });
+};
 const getOrCreateDeviceId = () => {
     ensureDir();
     try {

package/dist/utils.d.ts

@@ -116,7 +116,7 @@ export declare function createSemaphore(maxConcurrent: number): {
     getQueueLength(): number;
 };
 /**
- * Check if a URL is a new tab page (about:blank, chrome://new-tab-page, or chrome://newtab).
+ * Check if a URL is a new tab page (about:blank/about:newtab/chrome://new-tab-page/chrome://newtab).
  */
 export declare function is_new_tab_page(url: string): boolean;
 /**

package/dist/utils.js

@@ -488,10 +488,11 @@ export function createSemaphore(maxConcurrent) {
     };
 }
 /**
- * Check if a URL is a new tab page (about:blank, chrome://new-tab-page, or chrome://newtab).
+ * Check if a URL is a new tab page (about:blank/about:newtab/chrome://new-tab-page/chrome://newtab).
  */
 export function is_new_tab_page(url) {
     return (url === 'about:blank' ||
+        url === 'about:newtab' ||
         url === 'chrome://new-tab-page/' ||
         url === 'chrome://new-tab-page' ||
         url === 'chrome://newtab/' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-use",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A TypeScript-first library for programmatic browser control, designed for building AI-powered web agents.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -101,6 +101,16 @@
       "import": "./dist/llm/google/index.js",
       "default": "./dist/llm/google/index.js"
     },
+    "./llm/litellm": {
+      "types": "./dist/llm/litellm/index.d.ts",
+      "import": "./dist/llm/litellm/index.js",
+      "default": "./dist/llm/litellm/index.js"
+    },
+    "./llm/oci-raw": {
+      "types": "./dist/llm/oci-raw/index.d.ts",
+      "import": "./dist/llm/oci-raw/index.js",
+      "default": "./dist/llm/oci-raw/index.js"
+    },
     "./llm/groq": {
       "types": "./dist/llm/groq/index.d.ts",
       "import": "./dist/llm/groq/index.js",
@@ -171,6 +181,11 @@
       "import": "./dist/skill-cli/index.js",
       "default": "./dist/skill-cli/index.js"
     },
+    "./skill-cli/direct": {
+      "types": "./dist/skill-cli/direct.d.ts",
+      "import": "./dist/skill-cli/direct.js",
+      "default": "./dist/skill-cli/direct.js"
+    },
     "./skills": {
       "types": "./dist/skills/index.d.ts",
       "import": "./dist/skills/index.js",
@@ -235,7 +250,8 @@
     "./dist/*": "./dist/*"
   },
   "bin": {
-    "browser-use": "./dist/cli.js"
+    "browser-use": "./dist/cli.js",
+    "browser-use-direct": "./dist/skill-cli/direct.js"
   },
   "type": "module",
   "files": [
@@ -264,10 +280,10 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
-    "@aws-sdk/client-bedrock-runtime": "^3.995.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1012.0",
     "@cfworker/json-schema": "^4.1.1",
     "@google/genai": "^1.40.0",
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "adm-zip": "^0.5.16",
     "axios": "^1.13.4",
     "canvas": "^3.2.1",
@@ -279,6 +295,8 @@
     "gpt-tokenizer": "^3.4.0",
     "groq-sdk": "^0.37.0",
     "minimatch": "^10.2.3",
+    "oci-common": "^2.126.2",
+    "oci-generativeaiinference": "^2.126.2",
     "ollama": "^0.6.3",
     "openai": "^6.18.0",
     "pdf-parse": "^2.4.5",