brave-mcp 0.1.0

package/build/src/browser.js

@@ -0,0 +1,295 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { logger } from './logger.js';
+import { puppeteer } from './third_party/index.js';
+let browser;
+function makeTargetFilter(enableExtensions = false) {
+    const ignoredPrefixes = new Set([
+        'chrome://',
+        'chrome-untrusted://',
+        'brave://',
+    ]);
+    if (!enableExtensions) {
+        ignoredPrefixes.add('chrome-extension://');
+    }
+    return function targetFilter(target) {
+        if (target.url() === 'brave://newtab/' || target.url() === 'chrome://newtab/') {
+            return true;
+        }
+        if (target.url().startsWith('brave://inspect') || target.url().startsWith('chrome://inspect')) {
+            return true;
+        }
+        for (const prefix of ignoredPrefixes) {
+            if (target.url().startsWith(prefix)) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+function resolveBraveExecutablePath(channel) {
+    const envPath = process.env['BRAVE_PATH'];
+    if (envPath) {
+        if (!fs.existsSync(envPath)) {
+            throw new Error(`BRAVE_PATH points to ${envPath} but that file does not exist.`);
+        }
+        return envPath;
+    }
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        const paths = {
+            release: '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+            beta: '/Applications/Brave Browser Beta.app/Contents/MacOS/Brave Browser Beta',
+            nightly: '/Applications/Brave Browser Nightly.app/Contents/MacOS/Brave Browser Nightly',
+            dev: '/Applications/Brave Browser Dev.app/Contents/MacOS/Brave Browser Dev',
+        };
+        const resolved = paths[channel ?? 'release'];
+        if (fs.existsSync(resolved)) {
+            return resolved;
+        }
+        throw new Error(`Could not find Brave Browser (${channel ?? 'release'}) at ${resolved}. Install Brave or set the BRAVE_PATH environment variable.`);
+    }
+    if (platform === 'linux') {
+        const paths = {
+            release: ['brave-browser', 'brave-browser-stable'],
+            beta: ['brave-browser-beta'],
+            nightly: ['brave-browser-nightly'],
+            dev: ['brave-browser-dev'],
+        };
+        const candidates = paths[channel ?? 'release'];
+        for (const candidate of candidates) {
+            try {
+                const resolvedPath = execSync(`which ${candidate}`, { encoding: 'utf8' }).trim();
+                if (resolvedPath) {
+                    return resolvedPath;
+                }
+            }
+            catch {
+                // try next candidate
+            }
+        }
+        throw new Error(`Could not find Brave Browser (${channel ?? 'release'}) in PATH. Install Brave or set the BRAVE_PATH environment variable.`);
+    }
+    if (platform === 'win32') {
+        const programFiles = process.env['PROGRAMFILES'] ?? 'C:\\Program Files';
+        const localAppData = process.env['LOCALAPPDATA'] ?? '';
+        const paths = {
+            release: [
+                path.join(programFiles, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+                path.join(localAppData, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+            ],
+            beta: [
+                path.join(programFiles, 'BraveSoftware', 'Brave-Browser-Beta', 'Application', 'brave.exe'),
+                path.join(localAppData, 'BraveSoftware', 'Brave-Browser-Beta', 'Application', 'brave.exe'),
+            ],
+            nightly: [
+                path.join(programFiles, 'BraveSoftware', 'Brave-Browser-Nightly', 'Application', 'brave.exe'),
+                path.join(localAppData, 'BraveSoftware', 'Brave-Browser-Nightly', 'Application', 'brave.exe'),
+            ],
+            dev: [
+                path.join(programFiles, 'BraveSoftware', 'Brave-Browser-Dev', 'Application', 'brave.exe'),
+                path.join(localAppData, 'BraveSoftware', 'Brave-Browser-Dev', 'Application', 'brave.exe'),
+            ],
+        };
+        const candidates = paths[channel ?? 'release'];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error(`Could not find Brave Browser (${channel ?? 'release'}). Install Brave or set the BRAVE_PATH environment variable.`);
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+function resolveBraveUserDataDir(channel) {
+    const platform = os.platform();
+    const home = os.homedir();
+    if (platform === 'darwin') {
+        const dirs = {
+            release: path.join(home, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser'),
+            beta: path.join(home, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser-Beta'),
+            nightly: path.join(home, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser-Nightly'),
+            dev: path.join(home, 'Library', 'Application Support', 'BraveSoftware', 'Brave-Browser-Dev'),
+        };
+        return dirs[channel ?? 'release'];
+    }
+    if (platform === 'linux') {
+        const configDir = process.env['XDG_CONFIG_HOME'] ?? path.join(home, '.config');
+        const dirs = {
+            release: path.join(configDir, 'BraveSoftware', 'Brave-Browser'),
+            beta: path.join(configDir, 'BraveSoftware', 'Brave-Browser-Beta'),
+            nightly: path.join(configDir, 'BraveSoftware', 'Brave-Browser-Nightly'),
+            dev: path.join(configDir, 'BraveSoftware', 'Brave-Browser-Dev'),
+        };
+        return dirs[channel ?? 'release'];
+    }
+    if (platform === 'win32') {
+        const localAppData = process.env['LOCALAPPDATA'] ?? path.join(home, 'AppData', 'Local');
+        const dirs = {
+            release: path.join(localAppData, 'BraveSoftware', 'Brave-Browser', 'User Data'),
+            beta: path.join(localAppData, 'BraveSoftware', 'Brave-Browser-Beta', 'User Data'),
+            nightly: path.join(localAppData, 'BraveSoftware', 'Brave-Browser-Nightly', 'User Data'),
+            dev: path.join(localAppData, 'BraveSoftware', 'Brave-Browser-Dev', 'User Data'),
+        };
+        return dirs[channel ?? 'release'];
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+export async function ensureBrowserConnected(options) {
+    const { channel, enableExtensions } = options;
+    if (browser?.connected) {
+        return browser;
+    }
+    const connectOptions = {
+        targetFilter: makeTargetFilter(enableExtensions),
+        defaultViewport: null,
+        handleDevToolsAsPage: true,
+    };
+    let autoConnect = false;
+    if (options.wsEndpoint) {
+        connectOptions.browserWSEndpoint = options.wsEndpoint;
+        if (options.wsHeaders) {
+            connectOptions.headers = options.wsHeaders;
+        }
+    }
+    else if (options.browserURL) {
+        connectOptions.browserURL = options.browserURL;
+    }
+    else if (channel || options.userDataDir) {
+        const userDataDir = options.userDataDir ?? resolveBraveUserDataDir(channel);
+        autoConnect = true;
+        const portPath = path.join(userDataDir, 'DevToolsActivePort');
+        try {
+            const fileContent = await fs.promises.readFile(portPath, 'utf8');
+            const [rawPort, rawPath] = fileContent
+                .split('\n')
+                .map(line => {
+                return line.trim();
+            })
+                .filter(line => {
+                return !!line;
+            });
+            if (!rawPort || !rawPath) {
+                throw new Error(`Invalid DevToolsActivePort '${fileContent}' found`);
+            }
+            const port = parseInt(rawPort, 10);
+            if (isNaN(port) || port <= 0 || port > 65535) {
+                throw new Error(`Invalid port '${rawPort}' found`);
+            }
+            const browserWSEndpoint = `ws://127.0.0.1:${port}${rawPath}`;
+            connectOptions.browserWSEndpoint = browserWSEndpoint;
+        }
+        catch (error) {
+            throw new Error(`Could not connect to Brave in ${userDataDir}. Check if Brave is running and remote debugging is enabled by going to brave://inspect/#remote-debugging.`, {
+                cause: error,
+            });
+        }
+    }
+    else {
+        throw new Error('Either browserURL, wsEndpoint, channel or userDataDir must be provided');
+    }
+    logger('Connecting Puppeteer to ', JSON.stringify(connectOptions));
+    try {
+        browser = await puppeteer.connect(connectOptions);
+    }
+    catch (err) {
+        throw new Error(`Could not connect to Brave. ${autoConnect ? `Check if Brave is running and remote debugging is enabled by going to brave://inspect/#remote-debugging.` : `Check if Brave is running.`}`, {
+            cause: err,
+        });
+    }
+    logger('Connected Puppeteer');
+    return browser;
+}
+export function detectDisplay() {
+    if (os.platform() === 'win32' || os.platform() === 'darwin') {
+        return;
+    }
+    if (!process.env['DISPLAY']) {
+        try {
+            const result = execSync(`ps -u $(id -u) -o pid= | xargs -I{} cat /proc/{}/environ 2>/dev/null | tr '\\0' '\\n' | grep -m1 '^DISPLAY=' | cut -d= -f2`);
+            const display = result.toString('utf8').trim();
+            process.env['DISPLAY'] = display;
+        }
+        catch {
+            // no-op
+        }
+    }
+}
+export async function launch(options) {
+    const { channel, headless, isolated } = options;
+    const profileDirName = channel && channel !== 'release'
+        ? `brave-profile-${channel}`
+        : 'brave-profile';
+    const executablePath = options.executablePath ?? resolveBraveExecutablePath(channel);
+    let userDataDir = options.userDataDir;
+    if (!isolated && !userDataDir) {
+        userDataDir = path.join(os.homedir(), '.cache', options.viaCli ? 'brave-devtools-mcp-cli' : 'brave-devtools-mcp', profileDirName);
+        await fs.promises.mkdir(userDataDir, {
+            recursive: true,
+        });
+    }
+    const args = [
+        ...(options.braveArgs ?? []),
+        '--hide-crash-restore-bubble',
+    ];
+    const ignoreDefaultArgs = options.ignoreDefaultBraveArgs ?? false;
+    if (headless) {
+        args.push('--screen-info={3840x2160}');
+    }
+    if (options.devtools) {
+        args.push('--auto-open-devtools-for-tabs');
+    }
+    if (!headless) {
+        detectDisplay();
+    }
+    try {
+        const browser = await puppeteer.launch({
+            targetFilter: makeTargetFilter(options.enableExtensions),
+            executablePath,
+            defaultViewport: null,
+            userDataDir,
+            pipe: true,
+            headless,
+            args,
+            ignoreDefaultArgs: ignoreDefaultArgs,
+            acceptInsecureCerts: options.acceptInsecureCerts,
+            handleDevToolsAsPage: true,
+            enableExtensions: options.enableExtensions,
+        });
+        if (options.logFile) {
+            browser.process()?.stderr?.pipe(options.logFile);
+            browser.process()?.stdout?.pipe(options.logFile);
+        }
+        if (options.viewport) {
+            const [page] = await browser.pages();
+            await page?.resize({
+                contentWidth: options.viewport.width,
+                contentHeight: options.viewport.height,
+            });
+        }
+        return browser;
+    }
+    catch (error) {
+        if (userDataDir &&
+            error.message.includes('The browser is already running')) {
+            throw new Error(`The browser is already running for ${userDataDir}. Use --isolated to run multiple browser instances.`, {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}
+export async function ensureBrowserLaunched(options) {
+    if (browser?.connected) {
+        return browser;
+    }
+    browser = await launch(options);
+    return browser;
+}

package/build/src/daemon/client.js

@@ -0,0 +1,152 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import { logger } from '../logger.js';
+import { PipeTransport } from '../third_party/index.js';
+import { saveTemporaryFile } from '../utils/files.js';
+import { DAEMON_SCRIPT_PATH, getSocketPath, getPidFilePath, isDaemonRunning, } from './utils.js';
+const FILE_TIMEOUT = 10_000;
+/**
+ * Waits for a file to be created and populated (removed = false) or removed (removed = true).
+ */
+function waitForFile(filePath, removed = false) {
+    return new Promise((resolve, reject) => {
+        const check = () => {
+            const exists = fs.existsSync(filePath);
+            if (removed) {
+                return !exists;
+            }
+            if (!exists) {
+                return false;
+            }
+            try {
+                return fs.statSync(filePath).size > 0;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (check()) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(() => {
+            fs.unwatchFile(filePath);
+            reject(new Error(`Timeout: file ${filePath} ${removed ? 'not removed' : 'not found'} within ${FILE_TIMEOUT}ms`));
+        }, FILE_TIMEOUT);
+        fs.watchFile(filePath, { interval: 500 }, () => {
+            if (check()) {
+                clearTimeout(timer);
+                fs.unwatchFile(filePath);
+                resolve();
+            }
+        });
+    });
+}
+export async function startDaemon(mcpArgs = []) {
+    if (isDaemonRunning()) {
+        logger('Daemon is already running');
+        return;
+    }
+    const pidFilePath = getPidFilePath();
+    if (fs.existsSync(pidFilePath)) {
+        fs.unlinkSync(pidFilePath);
+    }
+    logger('Starting daemon...', ...mcpArgs);
+    const child = spawn(process.execPath, [DAEMON_SCRIPT_PATH, ...mcpArgs], {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env,
+        cwd: process.cwd(),
+        windowsHide: true,
+    });
+    child.unref();
+    await waitForFile(pidFilePath);
+}
+const SEND_COMMAND_TIMEOUT = 60_000; // ms
+/**
+ * `sendCommand` opens a socket connection sends a single command and disconnects.
+ */
+export async function sendCommand(command) {
+    const socketPath = getSocketPath();
+    const socket = net.createConnection({
+        path: socketPath,
+    });
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error('Timeout waiting for daemon response'));
+        }, SEND_COMMAND_TIMEOUT);
+        const transport = new PipeTransport(socket, socket);
+        transport.onmessage = async (message) => {
+            clearTimeout(timer);
+            logger('onmessage', message);
+            resolve(JSON.parse(message));
+        };
+        socket.on('error', error => {
+            clearTimeout(timer);
+            logger('Socket error:', error);
+            reject(error);
+        });
+        socket.on('close', () => {
+            clearTimeout(timer);
+            logger('Socket closed:');
+            reject(new Error('Socket closed'));
+        });
+        logger('Sending message', command);
+        transport.send(JSON.stringify(command));
+    });
+}
+export async function stopDaemon() {
+    if (!isDaemonRunning()) {
+        logger('Daemon is not running');
+        return;
+    }
+    const pidFilePath = getPidFilePath();
+    await sendCommand({ method: 'stop' });
+    await waitForFile(pidFilePath, /*removed=*/ true);
+}
+export async function handleResponse(response, format) {
+    if (response.isError) {
+        return JSON.stringify(response.content);
+    }
+    if (format === 'json') {
+        if (response.structuredContent) {
+            return JSON.stringify(response.structuredContent);
+        }
+        // Fall-through to text for backward compatibility.
+    }
+    const chunks = [];
+    for (const content of response.content) {
+        if (content.type === 'text') {
+            chunks.push(content.text);
+        }
+        else if (content.type === 'image') {
+            const imageData = content.data;
+            const mimeType = content.mimeType;
+            let extension = '.png';
+            switch (mimeType) {
+                case 'image/jpg':
+                case 'image/jpeg':
+                    extension = '.jpeg';
+                    break;
+                case 'webp':
+                    extension = '.webp';
+                    break;
+            }
+            const data = Buffer.from(imageData, 'base64');
+            const name = crypto.randomUUID();
+            const { filepath } = await saveTemporaryFile(data, `${name}${extension}`);
+            chunks.push(`Saved to ${filepath}.`);
+        }
+        else {
+            throw new Error('Not supported response content type');
+        }
+    }
+    return format === 'md' ? chunks.join(' ') : JSON.stringify(chunks);
+}

package/build/src/daemon/daemon.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import { createServer } from 'node:net';
+import path from 'node:path';
+import process from 'node:process';
+import { logger } from '../logger.js';
+import { Client, PipeTransport, StdioClientTransport, } from '../third_party/index.js';
+import { VERSION } from '../version.js';
+import { DAEMON_CLIENT_NAME, getDaemonPid, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
+const pid = getDaemonPid();
+if (isDaemonRunning(pid)) {
+    logger('Another daemon process is running.');
+    process.exit(1);
+}
+const pidFilePath = getPidFilePath();
+fs.mkdirSync(path.dirname(pidFilePath), {
+    recursive: true,
+});
+fs.writeFileSync(pidFilePath, process.pid.toString());
+logger(`Writing ${process.pid.toString()} to ${pidFilePath}`);
+const socketPath = getSocketPath();
+const startDate = new Date();
+const mcpServerArgs = process.argv.slice(2);
+let mcpClient = null;
+let mcpTransport = null;
+let server = null;
+async function setupMCPClient() {
+    console.log('Setting up MCP client connection...');
+    // Create stdio transport for brave-devtools-mcp
+    mcpTransport = new StdioClientTransport({
+        command: process.execPath,
+        args: [INDEX_SCRIPT_PATH, ...mcpServerArgs],
+        env: process.env,
+    });
+    mcpClient = new Client({
+        name: DAEMON_CLIENT_NAME,
+        version: VERSION,
+    }, {
+        capabilities: {},
+    });
+    await mcpClient.connect(mcpTransport);
+    console.log('MCP client connected');
+}
+async function handleRequest(msg) {
+    try {
+        if (msg.method === 'invoke_tool') {
+            if (!mcpClient) {
+                throw new Error('MCP client not initialized');
+            }
+            const { tool, args } = msg;
+            const result = (await mcpClient.callTool({
+                name: tool,
+                arguments: args || {},
+            }));
+            return {
+                success: true,
+                result: JSON.stringify(result),
+            };
+        }
+        else if (msg.method === 'stop') {
+            // Ensure we are not interrupting in-progress starting.
+            await started;
+            // Trigger cleanup asynchronously.
+            setImmediate(() => {
+                void cleanup();
+            });
+            return {
+                success: true,
+                message: 'stopping',
+            };
+        }
+        else if (msg.method === 'status') {
+            return {
+                success: true,
+                result: JSON.stringify({
+                    pid: process.pid,
+                    socketPath,
+                    startDate: startDate.toISOString(),
+                    version: VERSION,
+                    args: mcpServerArgs,
+                }),
+            };
+        }
+        {
+            return {
+                success: false,
+                error: `Unknown method: ${JSON.stringify(msg, null, 2)}`,
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+async function startSocketServer() {
+    // Remove existing socket file if it exists (only on non-Windows)
+    if (!IS_WINDOWS) {
+        try {
+            fs.unlinkSync(socketPath);
+        }
+        catch {
+            // ignore errors.
+        }
+    }
+    return await new Promise((resolve, reject) => {
+        server = createServer(socket => {
+            const transport = new PipeTransport(socket, socket);
+            transport.onmessage = async (message) => {
+                logger('onmessage', message);
+                const response = await handleRequest(JSON.parse(message));
+                transport.send(JSON.stringify(response));
+                socket.end();
+            };
+            socket.on('error', error => {
+                logger('Socket error:', error);
+            });
+        });
+        server.listen({
+            path: socketPath,
+            readableAll: false,
+            writableAll: false,
+        }, async () => {
+            console.log(`Daemon server listening on ${socketPath}`);
+            try {
+                // Setup MCP client
+                await setupMCPClient();
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        server.on('error', error => {
+            logger('Server error:', error);
+            reject(error);
+        });
+    });
+}
+async function cleanup() {
+    console.log('Cleaning up daemon...');
+    try {
+        await mcpClient?.close();
+    }
+    catch (error) {
+        logger('Error closing MCP client:', error);
+    }
+    try {
+        await mcpTransport?.close();
+    }
+    catch (error) {
+        logger('Error closing MCP transport:', error);
+    }
+    if (server) {
+        await new Promise(resolve => {
+            server.close(() => resolve());
+        });
+    }
+    if (!IS_WINDOWS) {
+        try {
+            fs.unlinkSync(socketPath);
+        }
+        catch {
+            // ignore errors
+        }
+    }
+    logger(`unlinking ${pidFilePath}`);
+    if (fs.existsSync(pidFilePath)) {
+        fs.unlinkSync(pidFilePath);
+    }
+    process.exit(0);
+}
+// Handle shutdown signals
+process.on('SIGTERM', () => {
+    void cleanup();
+});
+process.on('SIGINT', () => {
+    void cleanup();
+});
+process.on('SIGHUP', () => {
+    void cleanup();
+});
+// Handle uncaught errors
+process.on('uncaughtException', error => {
+    logger('Uncaught exception:', error);
+});
+process.on('unhandledRejection', error => {
+    logger('Unhandled rejection:', error);
+});
+// Start the server
+const started = startSocketServer().catch(error => {
+    logger('Failed to start daemon server:', error);
+    process.exit(1);
+});

package/build/src/daemon/types.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};