@gabrielbryk/arc-devtools-mcp 1.3.0

package/build/src/tools/ToolDefinition.js

@@ -0,0 +1,73 @@
+/**
+ * @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().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(',').map(Number);
+    return {
+        latitude,
+        longitude,
+    };
+}
+//# sourceMappingURL=ToolDefinition.js.map

package/build/src/tools/categories.js

@@ -0,0 +1,36 @@
+/**
+ * @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["THIRD_PARTY"] = "experimentalThirdParty";
+    ToolCategory["MEMORY"] = "memory";
+    ToolCategory["WEBMCP"] = "experimentalWebmcp";
+})(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.THIRD_PARTY]: 'Third-party',
+    [ToolCategory.MEMORY]: 'Memory',
+    [ToolCategory.WEBMCP]: 'WebMCP',
+};
+export const OFF_BY_DEFAULT_CATEGORIES = [
+    ToolCategory.EXTENSIONS,
+    ToolCategory.THIRD_PARTY,
+    ToolCategory.WEBMCP,
+];
+//# sourceMappingURL=categories.js.map

package/build/src/tools/console.js

@@ -0,0 +1,98 @@
+/**
+ * @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',
+];
+const LIST_CONSOLE_MESSAGES_TOOL_NAME = 'list_console_messages';
+export const listConsoleMessages = definePageTool(cliArgs => {
+    return {
+        name: LIST_CONSOLE_MESSAGES_TOOL_NAME,
+        description: `List all console messages for the currently selected page since the last navigation.${cliArgs?.categoryExtensions ? ' This includes console messages originating from extensions content scripts.' : ''}`,
+        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.'),
+            serviceWorkerId: zod
+                .string()
+                .optional()
+                .describe('Filter messages to only return messages of the specified service worker.'),
+        },
+        blockedByDialog: false,
+        verifyFilesSchema: [],
+        handler: async (request, response) => {
+            response.setIncludeConsoleData(true, {
+                pageSize: request.params.pageSize,
+                pageIdx: request.params.pageIdx,
+                types: request.params.types,
+                includePreservedMessages: request.params.includePreservedMessages,
+                serviceWorkerId: request.params.serviceWorkerId,
+            });
+        },
+    };
+});
+export const getConsoleMessage = definePageTool({
+    name: 'get_console_message',
+    description: `Gets a console message by its ID. You can get all messages by calling ${LIST_CONSOLE_MESSAGES_TOOL_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'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (request, response) => {
+        response.attachConsoleMessage(request.params.msgid);
+    },
+});
+//# sourceMappingURL=console.js.map

package/build/src/tools/emulation.js

@@ -0,0 +1,84 @@
+/**
+ * @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';
+function headerStringTransform(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === '') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            throw new Error('Headers must be a JSON object');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON for headers: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+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>,<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.`),
+        extraHttpHeaders: zod
+            .string()
+            .optional()
+            .transform(headerStringTransform)
+            .describe('Extra HTTP headers as a JSON string object, e.g. {"X-Custom": "value", "Authorization": "Bearer token"}. Headers are included into every HTTP request originating from the page and persist across navigations until cleared. Pass an empty string to clear all extra headers.'),
+    },
+    blockedByDialog: true,
+    verifyFilesSchema: [],
+    handler: async (request, response, context) => {
+        const page = request.page;
+        await context.emulate(request.params, page.pptrPage);
+        response.appendResponseLine('Emulation configured successfully');
+    },
+});
+//# sourceMappingURL=emulation.js.map

package/build/src/tools/extensions.js

@@ -0,0 +1,101 @@
+/**
+ * @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';
+export const installExtension = defineTool({
+    name: 'install_extension',
+    description: 'Installs a Chrome extension from the given path.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+    },
+    schema: {
+        path: zod
+            .string()
+            .describe('Absolute path to the unpacked extension folder.'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: ['path'],
+    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,
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to uninstall.'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    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 the Chrome extensions installed in the browser. This includes their name, ID, version, and enabled status.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: true,
+    },
+    schema: {},
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    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,
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to reload.'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        const extension = await 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 the default action of an extension by its ID.',
+    annotations: {
+        category: ToolCategory.EXTENSIONS,
+        readOnlyHint: false,
+    },
+    schema: {
+        id: zod.string().describe('ID of the extension to trigger the action for.'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (request, response, context) => {
+        const { id } = request.params;
+        await context.triggerExtensionAction(id);
+        response.appendResponseLine(`Extension action triggered for ID ${id}`);
+    },
+});
+//# sourceMappingURL=extensions.js.map