browser-use 0.2.0 → 0.4.0

package/dist/logging-config.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 const LEVEL_PRIORITY = {
     debug: 10,
     info: 20,
@@ -6,8 +8,17 @@ const LEVEL_PRIORITY = {
     error: 40,
 };
 let configured = false;
-let globalLevel = process.env.BROWSER_USE_LOGGING_LEVEL || 'info';
-let outputStream = process.stderr;
+let consoleLevel = process.env.BROWSER_USE_LOGGING_LEVEL || 'info';
+let consoleStream = process.stderr;
+let debugLogStream = null;
+let infoLogStream = null;
+const normalizeLogLevel = (candidate, fallback) => {
+    if (!candidate) {
+        return fallback;
+    }
+    const normalized = candidate.toLowerCase();
+    return normalized in LEVEL_PRIORITY ? normalized : fallback;
+};
 const formatMessage = (level, name, message) => {
     if (level === 'result') {
         return message;
@@ -15,39 +26,66 @@ const formatMessage = (level, name, message) => {
     const paddedLevel = level.toUpperCase().padEnd(7, ' ');
     return `${paddedLevel} [${name}] ${message}`;
 };
+const formatFileMessage = (level, name, message) => `${new Date().toISOString()} ${formatMessage(level, name, message)}`;
+const writePayload = (stream, level, payload) => {
+    if ('write' in stream) {
+        stream.write(`${payload}\n`);
+        return;
+    }
+    switch (level) {
+        case 'error':
+            console.error(payload);
+            break;
+        case 'warning':
+            console.warn(payload);
+            break;
+        default:
+            console.log(payload);
+            break;
+    }
+};
+const ensureFilePathReady = (filePath) => {
+    fs.mkdirSync(path.dirname(path.resolve(filePath)), { recursive: true });
+};
+const closeFileStreams = () => {
+    if (debugLogStream) {
+        debugLogStream.end();
+        debugLogStream = null;
+    }
+    if (infoLogStream) {
+        infoLogStream.end();
+        infoLogStream = null;
+    }
+};
 export class Logger {
     name;
     constructor(name) {
         this.name = name;
     }
-    shouldLog(level) {
-        return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[globalLevel];
+    shouldLog(level, threshold) {
+        return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[threshold];
     }
     get level() {
-        return globalLevel;
+        return consoleLevel;
     }
     emit(level, message, ...args) {
-        if (!this.shouldLog(level)) {
-            return;
-        }
+        const argsPayload = args.length
+            ? args
+                .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+                .join(' ')
+            : '';
         const formatted = formatMessage(level, this.name, message);
-        const payload = args.length
-            ? `${formatted} ${args.map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' ')}`
-            : formatted;
-        if ('write' in outputStream) {
-            outputStream.write(`${payload}\n`);
+        const payload = argsPayload ? `${formatted} ${argsPayload}` : formatted;
+        if (this.shouldLog(level, consoleLevel)) {
+            writePayload(consoleStream, level, payload);
         }
-        else {
-            switch (level) {
-                case 'error':
-                    console.error(payload);
-                    break;
-                case 'warning':
-                    console.warn(payload);
-                    break;
-                default:
-                    console.log(payload);
-            }
+        if (debugLogStream && this.shouldLog(level, 'debug')) {
+            const filePayload = formatFileMessage(level, this.name, message);
+            debugLogStream.write(`${argsPayload ? `${filePayload} ${argsPayload}` : filePayload}\n`);
+        }
+        if (infoLogStream && this.shouldLog(level, 'info')) {
+            const filePayload = formatFileMessage(level, this.name, message);
+            infoLogStream.write(`${argsPayload ? `${filePayload} ${argsPayload}` : filePayload}\n`);
         }
     }
     debug(message, ...args) {
@@ -78,12 +116,27 @@ export const setupLogging = (options = {}) => {
     if (configured && !options.forceSetup) {
         return createLogger('browser_use');
     }
-    globalLevel =
-        options.logLevel ||
-            process.env.BROWSER_USE_LOGGING_LEVEL ||
-            'info';
-    outputStream = options.stream || process.stderr;
+    closeFileStreams();
+    consoleLevel = normalizeLogLevel(options.logLevel ?? process.env.BROWSER_USE_LOGGING_LEVEL, 'info');
+    consoleStream = options.stream || process.stderr;
+    const debugLogFile = options.debugLogFile ?? process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
+    if (debugLogFile && debugLogFile.trim().length > 0) {
+        ensureFilePathReady(debugLogFile);
+        debugLogStream = fs.createWriteStream(path.resolve(debugLogFile), {
+            flags: 'a',
+            encoding: 'utf-8',
+        });
+    }
+    const infoLogFile = options.infoLogFile ?? process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
+    if (infoLogFile && infoLogFile.trim().length > 0) {
+        ensureFilePathReady(infoLogFile);
+        infoLogStream = fs.createWriteStream(path.resolve(infoLogFile), {
+            flags: 'a',
+            encoding: 'utf-8',
+        });
+    }
     configured = true;
     return createLogger('browser_use');
 };
+setupLogging();
 export const logger = createLogger('browser_use');

package/dist/mcp/client.d.ts

@@ -5,10 +5,10 @@
  * MCP tools are dynamically discovered and registered as browser-use actions.
  *
  * Example usage:
- *     import { Controller } from './controller/service.js';
+ *     import { Tools } from './tools/service.js';
  *     import { MCPClient } from './mcp/client.js';
  *
- *     const controller = new Controller();
+ *     const tools = new Tools();
  *
  *     // Connect to an MCP server
  *     const mcpClient = new MCPClient(
@@ -18,12 +18,13 @@
  *     );
  *
  *     // Register all MCP tools as browser-use actions
- *     await mcpClient.registerToController(controller);
+ *     await mcpClient.registerToTools(tools);
  *
  *     // Now use with Agent as normal - MCP tools are available as actions
  */
 import { type Tool, type Prompt } from '@modelcontextprotocol/sdk/types.js';
 import type { Controller } from '../controller/service.js';
+import type { Tools } from '../tools/service.js';
 export interface MCPClientOptions {
     /** Maximum number of connection retry attempts (default: 3) */
     maxRetries?: number;
@@ -76,12 +77,16 @@ export declare class MCPClient {
      */
     callTool(name: string, args: any): Promise<any>;
     /**
-     * Register MCP tools as actions in the browser-use controller
+     * Register MCP tools as actions in browser-use tools.
      *
-     * @param controller - Browser-use controller to register actions to
+     * @param tools - Browser-use tools to register actions to
      * @param toolFilter - Optional list of tool names to register (undefined = all tools)
      * @param prefix - Optional prefix to add to action names (e.g., "playwright_")
      */
+    registerToTools(tools: Pick<Tools, 'registry'>, toolFilter?: string[], prefix?: string): Promise<void>;
+    /**
+     * @deprecated Use `registerToTools` instead.
+     */
     registerToController(controller: Controller<any>, toolFilter?: string[], prefix?: string): Promise<void>;
     private _registerToolAsAction;
     private _convertToolSchemaToParamModel;

package/dist/mcp/client.js

@@ -5,10 +5,10 @@
  * MCP tools are dynamically discovered and registered as browser-use actions.
  *
  * Example usage:
- *     import { Controller } from './controller/service.js';
+ *     import { Tools } from './tools/service.js';
  *     import { MCPClient } from './mcp/client.js';
  *
- *     const controller = new Controller();
+ *     const tools = new Tools();
  *
  *     // Connect to an MCP server
  *     const mcpClient = new MCPClient(
@@ -18,7 +18,7 @@
  *     );
  *
  *     // Register all MCP tools as browser-use actions
- *     await mcpClient.registerToController(controller);
+ *     await mcpClient.registerToTools(tools);
  *
  *     // Now use with Agent as normal - MCP tools are available as actions
  */
@@ -250,17 +250,17 @@ export class MCPClient {
         }
     }
     /**
-     * Register MCP tools as actions in the browser-use controller
+     * Register MCP tools as actions in browser-use tools.
      *
-     * @param controller - Browser-use controller to register actions to
+     * @param tools - Browser-use tools to register actions to
      * @param toolFilter - Optional list of tool names to register (undefined = all tools)
      * @param prefix - Optional prefix to add to action names (e.g., "playwright_")
      */
-    async registerToController(controller, toolFilter, prefix) {
+    async registerToTools(tools, toolFilter, prefix) {
         if (!this._connected) {
             await this.connect();
         }
-        const registry = controller.registry;
+        const registry = tools.registry;
         for (const [toolName, tool] of this._tools.entries()) {
             // Skip if not in filter
             if (toolFilter && !toolFilter.includes(toolName)) {
@@ -278,6 +278,12 @@ export class MCPClient {
         }
         logger.info(`✅ Registered ${this._registeredActions.size} MCP tools from '${this.serverName}' as browser-use actions`);
     }
+    /**
+     * @deprecated Use `registerToTools` instead.
+     */
+    async registerToController(controller, toolFilter, prefix) {
+        await this.registerToTools(controller, toolFilter, prefix);
+    }
     _registerToolAsAction(registry, actionName, tool) {
         /**
          * Register a single MCP tool as a browser-use action
@@ -291,7 +297,6 @@ export class MCPClient {
                 });
             }
             const startTime = Date.now() / 1000;
-            let errorMsg = null;
             try {
                 // Call the MCP tool
                 const result = await this.callTool(tool.name, params || {});
@@ -303,7 +308,7 @@ export class MCPClient {
                 });
             }
             catch (error) {
-                errorMsg = error instanceof Error ? error.message : String(error);
+                const errorMsg = error instanceof Error ? error.message : String(error);
                 logger.error(`MCP tool '${tool.name}' failed: ${errorMsg}`);
                 return new ActionResult({
                     error: `MCP tool '${tool.name}' failed: ${errorMsg}`,

package/dist/mcp/controller.d.ts

@@ -1,6 +1,45 @@
+import type { Registry } from '../tools/registry/service.js';
+import type { Tools } from '../tools/service.js';
+import { MCPClient, type MCPClientOptions } from './client.js';
+export interface MCPToolWrapperOptions {
+    serverName?: string;
+    env?: Record<string, string>;
+    clientOptions?: MCPClientOptions;
+}
+export declare class MCPToolWrapper {
+    private registry;
+    private client;
+    constructor(registry: Registry, mcpCommand: string, mcpArgs?: string[], options?: MCPToolWrapperOptions);
+    connect(toolFilter?: string[], prefix?: string, tools?: Pick<Tools, 'registry'>): Promise<void>;
+    disconnect(): Promise<void>;
+    getClient(): MCPClient;
+    getStats(): {
+        serverName: string;
+        connected: boolean;
+        toolsDiscovered: number;
+        promptsDiscovered: number;
+        toolCallCount: number;
+        errorCount: number;
+        successRate: number;
+        uptime?: number;
+        lastHealthCheck?: number;
+    };
+}
+export declare function registerMcpTools(registry: Registry, mcpCommand: string, mcpArgs?: string[], options?: MCPToolWrapperOptions): Promise<MCPToolWrapper>;
+export interface AddMCPServerOptions {
+    serverName?: string;
+    env?: Record<string, string>;
+    clientOptions?: MCPClientOptions;
+    toolFilter?: string[];
+    prefix?: string;
+    tools?: Pick<Tools, 'registry'>;
+}
 export declare class MCPController {
     private clients;
-    constructor();
-    addServer(command: string, args: string[]): Promise<void>;
-    private registerTools;
+    private tools;
+    constructor(tools?: Pick<Tools, 'registry'> | null);
+    setTools(tools: Pick<Tools, 'registry'>): void;
+    addServer(command: string, args?: string[], options?: AddMCPServerOptions): Promise<MCPClient>;
+    getClients(): MCPClient[];
+    disconnectAll(): Promise<void>;
 }

package/dist/mcp/controller.js

@@ -1,38 +1,63 @@
+import { createLogger } from '../logging-config.js';
 import { MCPClient } from './client.js';
-import { z } from 'zod';
-// This controller integrates MCP tools into the browser-use registry
+const logger = createLogger('browser_use.mcp.controller');
+export class MCPToolWrapper {
+    registry;
+    client;
+    constructor(registry, mcpCommand, mcpArgs = [], options = {}) {
+        this.registry = registry;
+        this.client = new MCPClient(options.serverName ?? 'browser-use-mcp-tools', mcpCommand, mcpArgs, options.env, options.clientOptions);
+    }
+    async connect(toolFilter, prefix, tools) {
+        if (!this.client.isConnected()) {
+            await this.client.connect();
+        }
+        const targetTools = tools ?? { registry: this.registry };
+        await this.client.registerToTools(targetTools, toolFilter, prefix);
+    }
+    async disconnect() {
+        await this.client.disconnect();
+    }
+    getClient() {
+        return this.client;
+    }
+    getStats() {
+        return this.client.getStats();
+    }
+}
+export async function registerMcpTools(registry, mcpCommand, mcpArgs = [], options = {}) {
+    const wrapper = new MCPToolWrapper(registry, mcpCommand, mcpArgs, options);
+    await wrapper.connect();
+    return wrapper;
+}
+// Backward-compatible helper that can manage multiple MCP clients.
 export class MCPController {
     clients = [];
-    constructor() { }
-    async addServer(command, args) {
-        const client = new MCPClient('browser-use-client', command, args);
+    tools;
+    constructor(tools = null) {
+        this.tools = tools;
+    }
+    setTools(tools) {
+        this.tools = tools;
+    }
+    async addServer(command, args = [], options = {}) {
+        const client = new MCPClient(options.serverName ?? `browser-use-client-${this.clients.length + 1}`, command, args, options.env, options.clientOptions);
         await client.connect();
-        this.clients.push(client);
-        await this.registerTools(client);
-    }
-    async registerTools(client) {
-        const tools = await client.listTools();
-        for (const tool of tools) {
-            // We need to convert JSON schema to Zod schema dynamically if we want to validate
-            // For now, we might just use a generic schema or skip validation at the registry level
-            // and let the MCP server validate.
-            // However, the Registry expects a Zod schema.
-            // We can create a dynamic Zod schema that accepts anything if we can't easily convert.
-            // Or we can try to convert using json-schema-to-zod (if we had it) or just use z.any()
-            const paramModel = z.any().describe(tool.description || '');
-            // Register the action
-            // Note: We need to access the singleton registry or pass it in.
-            // Assuming we can use the decorator or manual registration.
-            // Since we are registering dynamically, we might need a method on Registry to register actions at runtime.
-            // Let's assume Registry has a static method or we can access the instance.
-            // In the migration plan, Registry is a class.
-            // We might need to modify Registry to support runtime registration if it doesn't already.
-            // But wait, the Registry in `src/controller/registry/service.ts` has an `action` method which is a decorator.
-            // It also has a `registry` property which holds the actions.
-            // We'll assume we can access the global registry or pass it to this controller.
-            // For now, I'll just log it as a placeholder for actual registration logic which might require
-            // more complex integration with the Controller class.
-            console.log(`Discovered MCP tool: ${tool.name}`);
+        const targetTools = options.tools ?? this.tools;
+        if (targetTools) {
+            await client.registerToTools(targetTools, options.toolFilter, options.prefix);
+        }
+        else {
+            logger.warning('MCPController.addServer connected but skipped tool registration because no Tools instance was provided');
         }
+        this.clients.push(client);
+        return client;
+    }
+    getClients() {
+        return [...this.clients];
+    }
+    async disconnectAll() {
+        await Promise.all(this.clients.map((client) => client.disconnect()));
+        this.clients = [];
     }
 }

package/dist/mcp/server.d.ts

@@ -50,16 +50,31 @@ export declare class MCPServer {
     private toolExecutionCount;
     private errorCount;
     private abortController;
+    private activeSessions;
+    private sessionTimeoutMinutes;
+    private sessionCleanupInterval;
     constructor(name: string, version: string);
     private resolvePath;
     private getDefaultProfileConfig;
     private getDefaultLlmConfig;
+    private isPlaceholderOpenAiApiKey;
+    private seedOpenAiApiKeyFromConfig;
+    private createLlmFromModelName;
     private sanitizeProfileConfig;
     private buildDirectSessionProfile;
     private buildRetryProfile;
     private initializeLlmForDirectTools;
     private initializeFileSystem;
     private formatRetryResult;
+    private trackSession;
+    private updateSessionActivity;
+    private serializeTrackedSessions;
+    private shutdownSession;
+    private closeSessionById;
+    private closeAllTrackedSessions;
+    private cleanupExpiredSessions;
+    private startSessionCleanupLoop;
+    private stopSessionCleanupLoop;
     private setupHandlers;
     private ensureController;
     private ensureBrowserSession;