levisnkyyy-browser-use-mcp/src/client.ts

MCP server for Browser-Use API

import axios, { AxiosInstance } from 'axios';
import WebSocket from 'ws';

export interface TaskRequest {
	task: string;
	project_folder: string;
	temperature?: number;
	browser_config?: Record<string, any>;
	agent_settings?: Record<string, any>;
	output_format?: Record<string, any>;
	session_id?: string;
}

export interface TaskResponse {
	task_id: string;
	status: 'pending' | 'running' | 'completed' | 'failed' | 'paused' | 'cancelled';
	task: string;
	result?: any;
	error?: string;
	created_at: string;
	updated_at: string;
	session_id?: string;
	history?: Array<{
		step: number;
		action: string | null;
		result: any[] | null;
	}>;
}

export interface BrowserSessionConfig {
	headless?: boolean;
	viewport?: { width: number; height: number };
	user_agent?: string;
	proxy?: string;
	cookies?: Array<{ name: string; value: string; domain: string }>;
}

export interface ScanRequest {
	url: string;
	filename: string;
	project_folder: string;
}

export interface ScanResponse {
	url: string;
	page_title: string;
	screenshot_path: string;
	screenshot_description: string;
	timestamp: string;
}

export interface ScreenshotRequest {
	project_folder: string;
	filename?: string;
}

export interface ScreenshotResponse {
	task_id: string;
	task: string;
	current_url: string;
	page_title: string;
	screenshot_path: string;
	screenshot_description: string;
	timestamp: string;
}

export class BrowserUseClient {
	private api: AxiosInstance;

	constructor(baseURL: string, apiKey?: string) {
		this.api = axios.create({
			baseURL,
			headers: apiKey ? { 'X-API-Key': apiKey } : {},
		});
	}

	async createTask(params: TaskRequest): Promise<TaskResponse> {
		const { data } = await this.api.post('/api/v1/tasks', params);
		return data;
	}

	async createTaskSync(params: TaskRequest): Promise<TaskResponse> {
		const { data } = await this.api.post('/api/v1/tasks/sync', params);
		return data;
	}

	async getTask(taskId: string): Promise<TaskResponse> {
		const { data } = await this.api.get(`/api/v1/tasks/${taskId}`);
		return data;
	}

	async listTasks(): Promise<TaskResponse[]> {
		const { data } = await this.api.get('/api/v1/tasks');
		return data.tasks;
	}

	async cancelTask(taskId: string): Promise<void> {
		await this.api.post(`/api/v1/tasks/${taskId}/cancel`);
	}

	async pauseTask(taskId: string): Promise<void> {
		await this.api.post(`/api/v1/tasks/${taskId}/pause`);
	}

	async getTaskHistory(taskId: string): Promise<any[]> {
		const { data } = await this.api.get(`/api/v1/tasks/${taskId}/history`);
		return data.history;
	}

	async getScreenshot(taskId: string, params: ScreenshotRequest): Promise<ScreenshotResponse> {
		const { data } = await this.api.post(`/api/v1/tasks/${taskId}/screenshot`, params);
		return data;
	}

	async createBrowserSession(config: BrowserSessionConfig): Promise<{ session_id: string }> {
		const { data } = await this.api.post('/api/v1/browsers', config);
		return data;
	}

	async closeBrowserSession(sessionId: string): Promise<void> {
		await this.api.delete(`/api/v1/browsers/${sessionId}`);
	}

	async streamTask(taskId: string, onMessage: (message: any) => void): Promise<void> {
		return new Promise((resolve, reject) => {
			const wsUrl = this.api.defaults.baseURL!.replace('http', 'ws') + `/api/v1/tasks/${taskId}/stream`;
			const ws = new WebSocket(wsUrl, {
				headers: this.api.defaults.headers as any,
			});

			ws.on('message', (data) => {
				try {
					const message = JSON.parse(data.toString());
					onMessage(message);
					if (message.type === 'result' || message.type === 'error') {
						ws.close();
					}
				} catch (error) {
					console.error('Failed to parse WebSocket message:', error);
				}
			});

			ws.on('close', () => {
				resolve();
			});

			ws.on('error', (error) => {
				reject(error);
			});

			// Send ping every 30 seconds to keep connection alive
			const pingInterval = setInterval(() => {
				if (ws.readyState === WebSocket.OPEN) {
					ws.ping();
				}
			}, 30000);

			ws.on('close', () => {
				clearInterval(pingInterval);
			});
		});
	}

	async checkHealth(): Promise<any> {
		const { data } = await this.api.get('/api/v1/health');
		return data;
	}

	async scanUrl(params: ScanRequest): Promise<ScanResponse> {
		const { data } = await this.api.post('/api/v1/scan', params);
		return data;
	}

	async getSnapshot(taskId: string): Promise<string> {
		const { data } = await this.api.get(`/api/v1/tasks/${taskId}/snapshot`);
		return data;
	}
}