@vibebrowser/cli 0.2.8

package/dist/browser-main.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { registerStandaloneBrowserCli } from './browser-cli.js';
+import { getPackageVersion } from './version.js';
+program
+    .name('vibebrowser-cli')
+    .description('OpenClaw-compatible browser CLI (relay mode by default, or chrome-devtools with --devtools)')
+    .version(getPackageVersion());
+registerStandaloneBrowserCli(program);
+program.parse();
+//# sourceMappingURL=browser-main.js.map

package/dist/connection.js

@@ -0,0 +1,536 @@
+/**
+ * Vibe MCP Server - Relay Connection
+ *
+ * Connects to the relay server as a WebSocket client.
+ * Supports two modes:
+ *   - Local: connects to local relay daemon at ws://127.0.0.1:19888
+ *   - Remote: connects to public relay at wss://relay.api.vibebrowser.app/<uuid>
+ */
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+import { dirname, join } from 'path';
+import { isRelayRunning, AGENT_PORT } from './relay.js';
+const NO_CONNECTION_MESSAGE = `No connection to Vibe extension. Please:
+1. Install the Vibe AI Browser extension from https://vibebrowser.app
+2. Click the Vibe extension icon in Chrome
+3. Enable "MCP External Control" in Settings`;
+const NO_CONNECTION_REMOTE_MESSAGE = `No connection to Vibe extension via remote relay. Please:
+1. Install the Vibe AI Browser extension from https://vibebrowser.app
+2. Open extension Settings > MCP External
+3. Select "Remote" mode and note your Extension UUID
+4. Make sure the extension is connected to the relay`;
+const RELAY_CONNECT_TIMEOUT = 10000;
+const RELAY_RECONNECT_DELAY = 2000;
+const DEFAULT_RELAY_URL = 'wss://relay.api.vibebrowser.app';
+function isRemoteRelayUrl(value) {
+    return /^wss?:\/\//i.test(value);
+}
+export function parseRemoteRelayUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid remote relay URL: ${message}`);
+    }
+    if (parsed.protocol !== 'ws:' && parsed.protocol !== 'wss:') {
+        throw new Error('Invalid remote relay URL: protocol must be ws:// or wss://');
+    }
+    const pathSegments = parsed.pathname.split('/').filter(Boolean);
+    const uuid = pathSegments[pathSegments.length - 1];
+    if (!uuid) {
+        throw new Error('Invalid remote relay URL: missing UUID path segment');
+    }
+    pathSegments.pop();
+    parsed.pathname = pathSegments.length > 0 ? `/${pathSegments.join('/')}` : '';
+    parsed.search = '';
+    parsed.hash = '';
+    return {
+        relayUrl: parsed.toString().replace(/\/$/, ''),
+        uuid,
+    };
+}
+export function normalizeRemoteConfig(remote) {
+    if (!remote) {
+        return undefined;
+    }
+    const relayUrl = remote.relayUrl?.replace(/\/$/, '');
+    if (!isRemoteRelayUrl(remote.uuid)) {
+        return { uuid: remote.uuid, relayUrl };
+    }
+    const parsed = parseRemoteRelayUrl(remote.uuid);
+    if (relayUrl && relayUrl !== parsed.relayUrl) {
+        throw new Error(`Remote relay URL mismatch: remote URL includes ${parsed.relayUrl}, but configured relay URL is ${relayUrl}`);
+    }
+    return {
+        uuid: parsed.uuid,
+        relayUrl: relayUrl || parsed.relayUrl,
+    };
+}
+/**
+ * Relay connection manager
+ *
+ * Connects to a relay server (local or remote) to reach the extension.
+ */
+export class ExtensionConnection extends EventEmitter {
+    ws = null;
+    status = 'disconnected';
+    pendingRequests = new Map();
+    requestIdCounter = 0;
+    port;
+    debug;
+    tools = [];
+    sessions = [];
+    reconnectTimer = null;
+    extensionConnected = false;
+    remoteConfig = null;
+    localSessionConfig;
+    stopping = false;
+    constructor(port = AGENT_PORT, debug = false, remote, localSessionConfig) {
+        super();
+        this.port = port;
+        this.debug = debug;
+        this.remoteConfig = normalizeRemoteConfig(remote) || null;
+        this.localSessionConfig = localSessionConfig || {};
+    }
+    /**
+     * Start connection to relay server.
+     * In local mode: spawns relay daemon if needed, then connects.
+     * In remote mode: connects directly to public relay.
+     */
+    async start() {
+        this.stopping = false;
+        if (this.remoteConfig) {
+            this.log(`Remote mode: connecting to relay for UUID ${this.remoteConfig.uuid}`);
+            await this.connectToRelay();
+            return;
+        }
+        // Local mode: check if relay is already running
+        if (!isRelayRunning()) {
+            this.log('Starting relay daemon...');
+            await this.spawnRelay();
+            // Wait for relay to start
+            await this.waitForRelay();
+        }
+        // Connect to relay
+        await this.connectToRelay();
+    }
+    async setRemoteUrl(url) {
+        const parsed = parseRemoteRelayUrl(url);
+        this.stopping = true;
+        this.clearReconnectTimer();
+        this.rejectPendingRequests(new Error('Remote relay changed'));
+        this.closeSocket();
+        this.remoteConfig = { uuid: parsed.uuid, relayUrl: parsed.relayUrl };
+        this.tools = [];
+        this.sessions = [];
+        this.extensionConnected = false;
+        this.status = 'disconnected';
+        this.emit('tools_updated', this.tools);
+        this.emit('extension_status', false);
+        this.stopping = false;
+        await this.connectToRelay();
+        return parsed;
+    }
+    /**
+     * Spawn relay daemon as detached process (local mode only)
+     */
+    async spawnRelay() {
+        // Use __dirname equivalent for ESM
+        const relayScript = join(dirname(new URL(import.meta.url).pathname), 'relay-daemon.js');
+        const child = spawn(process.execPath, [relayScript, this.debug ? '--debug' : ''], {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env,
+        });
+        child.unref();
+        this.log('Relay daemon spawned');
+    }
+    /**
+     * Wait for local relay to become available
+     */
+    async waitForRelay() {
+        const startTime = Date.now();
+        while (Date.now() - startTime < RELAY_CONNECT_TIMEOUT) {
+            try {
+                // Try to connect
+                await new Promise((resolve, reject) => {
+                    const ws = new WebSocket(`ws://127.0.0.1:${this.port}`);
+                    const timeout = setTimeout(() => {
+                        ws.removeAllListeners();
+                        ws.terminate();
+                        reject(new Error('Timeout'));
+                    }, 1000);
+                    ws.on('open', () => {
+                        clearTimeout(timeout);
+                        ws.removeAllListeners();
+                        ws.terminate();
+                        resolve();
+                    });
+                    ws.on('error', () => {
+                        clearTimeout(timeout);
+                        reject(new Error('Connection failed'));
+                    });
+                });
+                this.log('Relay is ready');
+                return;
+            }
+            catch (error) {
+                // Relay not ready yet, wait and retry
+                await new Promise(r => setTimeout(r, 200));
+            }
+        }
+        throw new Error('Relay failed to start within timeout');
+    }
+    /**
+     * Get the WebSocket URL for connection.
+     * Local mode: ws://127.0.0.1:<port>
+     * Remote mode: wss://relay.api.vibebrowser.app/<uuid>
+     */
+    getRelayUrl() {
+        if (this.remoteConfig) {
+            const base = this.remoteConfig.relayUrl || DEFAULT_RELAY_URL;
+            return `${base}/${this.remoteConfig.uuid}`;
+        }
+        return `ws://127.0.0.1:${this.port}`;
+    }
+    getRemoteConfig() {
+        return this.remoteConfig ? { ...this.remoteConfig } : null;
+    }
+    /**
+     * Connect to the relay server (local or remote)
+     */
+    async connectToRelay() {
+        return new Promise((resolve, reject) => {
+            const url = this.getRelayUrl();
+            this.log(`Connecting to relay at ${url}...`);
+            try {
+                this.ws = new WebSocket(url);
+                this.ws.on('open', () => {
+                    this.log('Connected to relay');
+                    this.status = 'connected';
+                    this.emit('connected');
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        this.log(`Failed to parse message: ${error}`);
+                    }
+                });
+                this.ws.on('close', () => {
+                    this.log('Disconnected from relay');
+                    this.ws = null;
+                    this.status = 'disconnected';
+                    // Reject all pending requests — responses will never arrive on a
+                    // closed socket.  Without this, requests sit until their individual
+                    // timeouts fire, and if the server reconnects before that the MCP
+                    // client may retry, causing duplicate tool execution.
+                    for (const [id, request] of this.pendingRequests) {
+                        clearTimeout(request.timeout);
+                        request.reject(new Error('Relay connection lost'));
+                    }
+                    this.pendingRequests.clear();
+                    this.emit('disconnected');
+                    if (!this.stopping) {
+                        // Schedule reconnect
+                        this.scheduleReconnect();
+                    }
+                });
+                this.ws.on('error', (error) => {
+                    this.log(`WebSocket error: ${error.message}`);
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Schedule reconnection attempt
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectTimer = setTimeout(async () => {
+            this.log('Attempting to reconnect to relay...');
+            try {
+                await this.connectToRelay();
+            }
+            catch (error) {
+                this.log(`Reconnect failed: ${error}`);
+                this.scheduleReconnect();
+            }
+        }, RELAY_RECONNECT_DELAY);
+    }
+    /**
+     * Stop the connection
+     */
+    async stop() {
+        this.stopping = true;
+        this.clearReconnectTimer();
+        this.rejectPendingRequests(new Error('Connection closed'));
+        this.closeSocket();
+        this.status = 'disconnected';
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    rejectPendingRequests(error) {
+        for (const [, request] of this.pendingRequests) {
+            clearTimeout(request.timeout);
+            request.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    closeSocket() {
+        if (!this.ws) {
+            return;
+        }
+        // Remove listeners so a deliberate reconnect does not trigger stale close
+        // handlers or schedule a reconnect against the previous relay URL.
+        this.ws.removeAllListeners();
+        this.ws.terminate();
+        this.ws = null;
+    }
+    /**
+     * Handle message from relay
+     */
+    handleMessage(message) {
+        this.log(`Received: ${message.type}`);
+        // Handle extension status updates
+        if (message.type === 'extension_status') {
+            this.extensionConnected = message.connected ?? false;
+            this.emit('extension_status', this.extensionConnected);
+            return;
+        }
+        if (message.type === 'extension_disconnected') {
+            this.extensionConnected = false;
+            this.tools = [];
+            this.sessions = [];
+            this.emit('extension_disconnected');
+            return;
+        }
+        // Handle responses to pending requests
+        if (message.requestId) {
+            const pending = this.pendingRequests.get(message.requestId);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(message.requestId);
+                if (message.type === 'error') {
+                    pending.reject(new Error(message.error || 'Unknown error'));
+                }
+                else {
+                    let payload = message.data;
+                    if (message.type === 'sessions_list') {
+                        payload = Array.isArray(message.sessions) ? message.sessions : message.data;
+                        this.sessions = Array.isArray(payload) ? payload : [];
+                        if (!this.remoteConfig) {
+                            const selected = this.resolveRequestedSessionId(this.sessions);
+                            this.extensionConnected = this.sessions.some((session) => session.sessionId === selected && session.connected);
+                        }
+                        this.emit('sessions_updated', this.sessions);
+                    }
+                    pending.resolve(payload);
+                }
+                return;
+            }
+        }
+        if (message.type === 'sessions_list') {
+            this.sessions = Array.isArray(message.sessions)
+                ? message.sessions
+                : Array.isArray(message.data)
+                    ? message.data
+                    : [];
+            if (!this.remoteConfig) {
+                const selected = this.resolveRequestedSessionId(this.sessions);
+                this.extensionConnected = this.sessions.some((session) => session.sessionId === selected && session.connected);
+            }
+            this.emit('sessions_updated', this.sessions);
+            return;
+        }
+        // Handle unsolicited messages
+        switch (message.type) {
+            case 'tools_list':
+                this.tools = message.data;
+                if (this.remoteConfig) {
+                    this.extensionConnected = true;
+                }
+                else if (this.sessions.length === 0) {
+                    this.extensionConnected = true;
+                }
+                this.emit('tools_updated', this.tools);
+                break;
+            case 'error':
+                this.log(`Error: ${message.error}`);
+                break;
+        }
+    }
+    /**
+     * Send a message to the extension via relay and wait for response
+     */
+    async sendRequest(type, data, timeoutMs = 30000) {
+        if (!this.ws || this.status !== 'connected') {
+            throw new Error('Not connected to relay');
+        }
+        const requestId = `req_${++this.requestIdCounter}`;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`Request timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pendingRequests.set(requestId, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            const enrichedData = this.withSessionSelection(data);
+            const message = { type, requestId, data: enrichedData };
+            this.ws.send(JSON.stringify(message));
+            this.log(`Sent: ${type} (${requestId})`);
+        });
+    }
+    withSessionSelection(data) {
+        if (this.remoteConfig) {
+            return data;
+        }
+        const sessionId = this.resolveRequestedSessionId(this.sessions);
+        if (!sessionId) {
+            return data;
+        }
+        return {
+            ...(data || {}),
+            sessionId,
+        };
+    }
+    resolveRequestedSessionId(sessions) {
+        if (this.localSessionConfig.sessionId) {
+            return this.localSessionConfig.sessionId;
+        }
+        const firstConnected = sessions.find((session) => session.connected);
+        return firstConnected?.sessionId;
+    }
+    getRequestedSessionConnectionError(sessions = this.sessions) {
+        if (this.remoteConfig || !this.localSessionConfig.sessionId || sessions.length === 0) {
+            return undefined;
+        }
+        const requested = this.localSessionConfig.sessionId;
+        const matched = sessions.find((session) => session.sessionId === requested);
+        if (!matched || !matched.connected) {
+            return `No browser session connected for sessionId=${requested}`;
+        }
+        return undefined;
+    }
+    getConnectionErrorMessage() {
+        if (this.remoteConfig) {
+            return NO_CONNECTION_REMOTE_MESSAGE;
+        }
+        return this.getRequestedSessionConnectionError() || NO_CONNECTION_MESSAGE;
+    }
+    /**
+     * Refresh available tools from extension
+     */
+    async refreshTools(timeoutMs = 30_000) {
+        const tools = await this.sendRequest('list_tools', undefined, timeoutMs);
+        this.tools = tools;
+        return tools;
+    }
+    async listSessions(timeoutMs = 5_000) {
+        if (this.remoteConfig) {
+            const session = {
+                sessionId: this.remoteConfig.uuid,
+                connected: this.extensionConnected,
+                toolCount: this.tools.length,
+            };
+            this.sessions = [session];
+            return this.sessions;
+        }
+        const sessions = await this.sendRequest('list_sessions', undefined, timeoutMs);
+        this.sessions = Array.isArray(sessions) ? sessions : [];
+        const selected = this.resolveRequestedSessionId(this.sessions);
+        this.extensionConnected = this.sessions.some((session) => session.sessionId === selected && session.connected);
+        return this.sessions;
+    }
+    /**
+     * Wait briefly for a tools update event without forcing a request.
+     * This keeps MCP startup responsive when extension announces tools asynchronously.
+     */
+    async waitForToolsUpdate(timeoutMs = 1_500) {
+        if (this.tools.length > 0) {
+            return this.tools;
+        }
+        return new Promise((resolve) => {
+            const onToolsUpdated = (tools) => {
+                cleanup();
+                resolve(tools);
+            };
+            const onExtensionDisconnected = () => {
+                cleanup();
+                resolve(this.tools);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve(this.tools);
+            }, timeoutMs);
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.off('tools_updated', onToolsUpdated);
+                this.off('extension_disconnected', onExtensionDisconnected);
+            };
+            this.on('tools_updated', onToolsUpdated);
+            this.on('extension_disconnected', onExtensionDisconnected);
+        });
+    }
+    /**
+     * Get cached list of available tools
+     */
+    getTools() {
+        return this.tools;
+    }
+    getSessions() {
+        return this.sessions;
+    }
+    /**
+     * Call a tool on the extension
+     */
+    async callTool(name, args, timeoutMs) {
+        return this.sendRequest('call_tool', { name, arguments: args }, timeoutMs);
+    }
+    /**
+     * Check if extension is connected (via relay)
+     */
+    isConnected() {
+        return this.status === 'connected' && this.extensionConnected;
+    }
+    /**
+     * Get connection status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Check if extension is connected to relay
+     */
+    isExtensionConnected() {
+        return this.extensionConnected;
+    }
+    /**
+     * Log message if debug is enabled
+     */
+    log(message) {
+        if (this.debug) {
+            console.error(`[vibebrowser-mcp] ${message}`);
+        }
+    }
+}
+//# sourceMappingURL=connection.js.map