brave-mcp 0.1.0

package/build/src/tools/ToolDefinition.js

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+export function defineTool(definition) {
+    if (typeof definition === 'function') {
+        const factory = definition;
+        return (args) => {
+            return factory(args);
+        };
+    }
+    return definition;
+}
+export function definePageTool(definition) {
+    if (typeof definition === 'function') {
+        return (args) => {
+            const tool = definition(args);
+            return {
+                ...tool,
+                pageScoped: true,
+            };
+        };
+    }
+    return {
+        ...definition,
+        pageScoped: true,
+    };
+}
+export const CLOSE_PAGE_ERROR = 'The last open page cannot be closed. It is fine to keep it open.';
+export const pageIdSchema = {
+    pageId: zod.number().optional().describe('Targets a specific page by ID.'),
+};
+export const timeoutSchema = {
+    timeout: zod
+        .number()
+        .int()
+        .optional()
+        .describe(`Maximum wait time in milliseconds. If set to 0, the default timeout will be used.`)
+        .transform(value => {
+        return value && value <= 0 ? undefined : value;
+    }),
+};
+export function viewportTransform(arg) {
+    if (!arg) {
+        return undefined;
+    }
+    const [dimensions, ...tags] = arg.split(',');
+    const isMobile = tags.includes('mobile');
+    const hasTouch = tags.includes('touch');
+    const isLandscape = tags.includes('landscape');
+    const [width, height, dpr] = dimensions.split('x').map(Number);
+    return {
+        width,
+        height,
+        deviceScaleFactor: dpr,
+        isMobile: isMobile,
+        isLandscape: isLandscape,
+        hasTouch: hasTouch,
+    };
+}
+export function geolocationTransform(arg) {
+    if (!arg) {
+        return undefined;
+    }
+    const [latitude, longitude] = arg.split('x').map(Number);
+    return {
+        latitude,
+        longitude,
+    };
+}

package/build/src/tools/categories.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export var ToolCategory;
+(function (ToolCategory) {
+    ToolCategory["INPUT"] = "input";
+    ToolCategory["NAVIGATION"] = "navigation";
+    ToolCategory["EMULATION"] = "emulation";
+    ToolCategory["PERFORMANCE"] = "performance";
+    ToolCategory["NETWORK"] = "network";
+    ToolCategory["DEBUGGING"] = "debugging";
+    ToolCategory["EXTENSIONS"] = "extensions";
+    ToolCategory["IN_PAGE"] = "in-page";
+})(ToolCategory || (ToolCategory = {}));
+export const labels = {
+    [ToolCategory.INPUT]: 'Input automation',
+    [ToolCategory.NAVIGATION]: 'Navigation automation',
+    [ToolCategory.EMULATION]: 'Emulation',
+    [ToolCategory.PERFORMANCE]: 'Performance',
+    [ToolCategory.NETWORK]: 'Network',
+    [ToolCategory.DEBUGGING]: 'Debugging',
+    [ToolCategory.EXTENSIONS]: 'Extensions',
+    [ToolCategory.IN_PAGE]: 'In-page tools',
+};

package/build/src/tools/console.js

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+const FILTERABLE_MESSAGE_TYPES = [
+    'log',
+    'debug',
+    'info',
+    'error',
+    'warn',
+    'dir',
+    'dirxml',
+    'table',
+    'trace',
+    'clear',
+    'startGroup',
+    'startGroupCollapsed',
+    'endGroup',
+    'assert',
+    'profile',
+    'profileEnd',
+    'count',
+    'timeEnd',
+    'verbose',
+    'issue',
+];
+export const listConsoleMessages = definePageTool({
+    name: 'list_console_messages',
+    description: 'List all console messages for the currently selected page since the last navigation.',
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: true,
+    },
+    schema: {
+        pageSize: zod
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe('Maximum number of messages to return. When omitted, returns all messages.'),
+        pageIdx: zod
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe('Page number to return (0-based). When omitted, returns the first page.'),
+        types: zod
+            .array(zod.enum(FILTERABLE_MESSAGE_TYPES))
+            .optional()
+            .describe('Filter messages to only return messages of the specified resource types. When omitted or empty, returns all messages.'),
+        includePreservedMessages: zod
+            .boolean()
+            .default(false)
+            .optional()
+            .describe('Set to true to return the preserved messages over the last 3 navigations.'),
+    },
+    handler: async (request, response) => {
+        response.setIncludeConsoleData(true, {
+            pageSize: request.params.pageSize,
+            pageIdx: request.params.pageIdx,
+            types: request.params.types,
+            includePreservedMessages: request.params.includePreservedMessages,
+        });
+    },
+});
+export const getConsoleMessage = definePageTool({
+    name: 'get_console_message',
+    description: `Gets a console message by its ID. You can get all messages by calling ${listConsoleMessages.name}.`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: true,
+    },
+    schema: {
+        msgid: zod
+            .number()
+            .describe('The msgid of a console message on the page from the listed console messages'),
+    },
+    handler: async (request, response) => {
+        response.attachConsoleMessage(request.params.msgid);
+    },
+});

package/build/src/tools/emulation.js

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+import { zod, PredefinedNetworkConditions } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool, geolocationTransform, viewportTransform, } from './ToolDefinition.js';
+const throttlingOptions = [
+    'Offline',
+    ...Object.keys(PredefinedNetworkConditions),
+];
+export const emulate = definePageTool({
+    name: 'emulate',
+    description: `Emulates various features on the selected page.`,
+    annotations: {
+        category: ToolCategory.EMULATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        networkConditions: zod
+            .enum(throttlingOptions)
+            .optional()
+            .describe(`Throttle network. Omit to disable throttling.`),
+        cpuThrottlingRate: zod
+            .number()
+            .min(1)
+            .max(20)
+            .optional()
+            .describe('Represents the CPU slowdown factor. Omit or set the rate to 1 to disable throttling'),
+        geolocation: zod
+            .string()
+            .optional()
+            .transform(geolocationTransform)
+            .describe('Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.'),
+        userAgent: zod
+            .string()
+            .optional()
+            .describe('User agent to emulate. Set to empty string to clear the user agent override.'),
+        colorScheme: zod
+            .enum(['dark', 'light', 'auto'])
+            .optional()
+            .describe('Emulate the dark or the light mode. Set to "auto" to reset to the default.'),
+        viewport: zod
+            .string()
+            .optional()
+            .transform(viewportTransform)
+            .describe(`Emulate device viewports '<width>x<height>x<devicePixelRatio>[,mobile][,touch][,landscape]'. 'touch' and 'mobile' to emulate mobile devices. 'landscape' to emulate landscape mode.`),
+    },
+    handler: async (request, _response, context) => {
+        const page = request.page;
+        await context.emulate(request.params, page.pptrPage);
+    },
+});

package/build/src/tools/extensions.js

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+const EXTENSIONS_CONDITION = 'experimentalExtensionSupport';
+export const installExtension = defineTool({
+    name: 'install_extension',
+    description: 'Installs a Chrome extension from the given path.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        path: zod
+            .string()
+            .describe('Absolute path to the unpacked extension folder.'),
+    },
+    handler: async (request, response, context) => {
+        const { path } = request.params;
+        const id = await context.installExtension(path);
+        response.appendResponseLine(`Extension installed. Id: ${id}`);
+    },
+});
+export const uninstallExtension = defineTool({
+    name: 'uninstall_extension',
+    description: 'Uninstalls a Chrome extension by its ID.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to uninstall.'),
+    },
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        await context.uninstallExtension(id);
+        response.appendResponseLine(`Extension uninstalled. Id: ${id}`);
+    },
+});
+export const listExtensions = defineTool({
+    name: 'list_extensions',
+    description: 'Lists all extensions via this server, including their name, ID, version, and enabled status.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: true,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {},
+    handler: async (_request, response, _context) => {
+        response.setListExtensions();
+    },
+});
+export const reloadExtension = defineTool({
+    name: 'reload_extension',
+    description: 'Reloads an unpacked Chrome extension by its ID.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to reload.'),
+    },
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        const extension = context.getExtension(id);
+        if (!extension) {
+            throw new Error(`Extension with ID ${id} not found.`);
+        }
+        await context.installExtension(extension.path);
+        response.appendResponseLine('Extension reloaded.');
+    },
+});
+export const triggerExtensionAction = defineTool({
+    name: 'trigger_extension_action',
+    description: 'Triggers an action in a Chrome extension.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+        conditions: [EXTENSIONS_CONDITION],
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension.'),
+    },
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        await context.triggerExtensionAction(id);
+        response.appendResponseLine(`Extension action triggered. Id: ${id}`);
+    },
+});

package/build/src/tools/inPage.js

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod, ajv, } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+export const listInPageTools = definePageTool({
+    name: 'list_in_page_tools',
+    description: `Lists all in-page tools the page exposes for providing runtime information.
+  In-page tools can be called via the 'execute_in_page_tool()' MCP tool.
+  Alternatively, in-page tools can be executed by calling 'evaluate_script' and adding the
+  following command to the script:
+  'window.__dtmcp.executeTool(toolName, params)'
+  This might be helpful when the in-page-tools return non-serializable values or when composing
+  the in-page-tools with additional functionality.`,
+    annotations: {
+        category: ToolCategory.IN_PAGE,
+        readOnlyHint: true,
+        conditions: ['inPageTools'],
+    },
+    schema: {},
+    handler: async (_request, response, _context) => {
+        response.setListInPageTools();
+    },
+});
+export const executeInPageTool = definePageTool({
+    name: 'execute_in_page_tool',
+    description: `Executes a tool exposed by the page.`,
+    annotations: {
+        category: ToolCategory.IN_PAGE,
+        readOnlyHint: false,
+        conditions: ['inPageTools'],
+    },
+    schema: {
+        toolName: zod.string().describe('The name of the tool to execute'),
+        params: zod
+            .string()
+            .optional()
+            .describe('The JSON-stringified parameters to pass to the tool'),
+    },
+    handler: async (request, response) => {
+        const toolName = request.params.toolName;
+        let params = {};
+        if (request.params.params) {
+            try {
+                const parsed = JSON.parse(request.params.params);
+                if (typeof parsed === 'object' && parsed !== null) {
+                    params = parsed;
+                }
+                else {
+                    throw new Error('Parsed params is not an object');
+                }
+            }
+            catch (e) {
+                const errorMessage = e instanceof Error ? e.message : String(e);
+                throw new Error(`Failed to parse params as JSON: ${errorMessage}`);
+            }
+        }
+        // Creates array of ElementHandles from the UIDs in the params.
+        // We do not replace the uids with the ElementsHandles yet, because
+        // the `evaluate` function only turns them into DOM elements if they
+        // are passed as non-nested arguments.
+        const handles = [];
+        for (const value of Object.values(params)) {
+            if (value instanceof Object &&
+                'uid' in value &&
+                typeof value.uid === 'string' &&
+                Object.keys(value).length === 1) {
+                handles.push(await request.page.getElementByUid(value.uid));
+            }
+        }
+        const toolGroup = request.page.getInPageTools();
+        const tool = toolGroup?.tools.find(t => t.name === toolName);
+        if (!tool) {
+            throw new Error(`Tool ${toolName} not found`);
+        }
+        const ajvInstance = new ajv();
+        const validate = ajvInstance.compile(tool.inputSchema);
+        const valid = validate(params);
+        if (!valid) {
+            throw new Error(`Invalid parameters for tool ${toolName}: ${ajvInstance.errorsText(validate.errors)}`);
+        }
+        const result = await request.page.pptrPage.evaluate(async (name, args, ...elements) => {
+            // Replace the UIDs with DOM elements.
+            for (const [key, value] of Object.entries(args)) {
+                if (value instanceof Object &&
+                    'uid' in value &&
+                    typeof value.uid === 'string' &&
+                    Object.keys(value).length === 1) {
+                    args[key] = elements.shift();
+                }
+            }
+            if (!window.__dtmcp?.executeTool) {
+                throw new Error('No tools found on the page');
+            }
+            const toolResult = await window.__dtmcp.executeTool(name, args);
+            return {
+                result: toolResult,
+            };
+        }, toolName, params, ...handles);
+        response.appendResponseLine(JSON.stringify(result, null, 2));
+    },
+});