@andrew-chen-wang/camoufox-mcp 0.0.1

package/lib/tools/network.js

@@ -0,0 +1,197 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+const networkRequests = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_network_requests',
+        title: 'List network requests',
+        description: 'Returns all network requests since loading the page',
+        inputSchema: z.object({
+            static: z.boolean().optional().describe('Include static resources like images, scripts, fonts, and stylesheets'),
+            requestBody: z.boolean().optional().describe('Include request body'),
+            requestHeaders: z.boolean().optional().describe('Include request headers'),
+            filter: z.string().optional().describe('Only include requests whose URL matches this regular expression'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const entries = [...context.currentTabOrDie().requests().entries()]
+            .filter(([request, response]) => includeRequest(request, response, !!params.static, params.filter));
+        const log = entries.map(([request, response]) => renderRequest(request, response, !!params.requestBody, !!params.requestHeaders)).join('\n\n');
+        return {
+            code: ['// <internal code to list network requests>'],
+            action: async () => ({ content: [{ type: 'text', text: log }] }),
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+const networkClear = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_network_clear',
+        title: 'Clear network requests',
+        description: 'Clear the collected network request log',
+        inputSchema: z.object({}),
+        type: 'destructive',
+    },
+    handle: async (context) => {
+        context.currentTabOrDie().clearRequests();
+        return {
+            code: ['// <internal code to clear network requests>'],
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+const route = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_route',
+        title: 'Mock route',
+        description: 'Mock network requests matching a URL pattern',
+        inputSchema: z.object({
+            pattern: z.string(),
+            status: z.number().optional(),
+            body: z.string().optional(),
+            contentType: z.string().optional(),
+            headers: z.array(z.string()).optional(),
+            removeHeaders: z.array(z.string()).optional(),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => ({
+        code: ['// <internal code to add route>'],
+        action: async () => {
+            await context.addRouteRule(params.pattern, async (route) => {
+                const headers = parseHeaders(params.headers);
+                if (params.removeHeaders) {
+                    for (const name of params.removeHeaders)
+                        delete headers[name.toLowerCase()];
+                }
+                if (params.contentType)
+                    headers['content-type'] = params.contentType;
+                await route.fulfill({
+                    status: params.status ?? 200,
+                    body: params.body ?? '',
+                    headers,
+                });
+            });
+        },
+        captureSnapshot: false,
+        waitForNetwork: false,
+    }),
+});
+const routeList = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_route_list',
+        title: 'List routes',
+        description: 'List active network route patterns',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context) => ({
+        code: ['// <internal code to list routes>'],
+        action: async () => ({ content: [{ type: 'text', text: context.listRouteRules().join('\n') }] }),
+        captureSnapshot: false,
+        waitForNetwork: false,
+    }),
+});
+const unroute = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_unroute',
+        title: 'Remove routes',
+        description: 'Remove route mocks matching a pattern, or all routes',
+        inputSchema: z.object({
+            pattern: z.string().optional(),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => ({
+        code: ['// <internal code to remove routes>'],
+        action: async () => {
+            await context.removeRouteRule(params.pattern);
+        },
+        captureSnapshot: false,
+        waitForNetwork: false,
+    }),
+});
+const networkState = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_network_state_set',
+        title: 'Set network state',
+        description: 'Set the browser network state to online or offline',
+        inputSchema: z.object({
+            state: z.enum(['online', 'offline']),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => ({
+        code: [`// Set network state to ${params.state}`],
+        action: async () => {
+            await context.setNetworkOffline(params.state === 'offline');
+        },
+        captureSnapshot: false,
+        waitForNetwork: false,
+    }),
+});
+function includeRequest(request, response, includeStatic, filter) {
+    if (filter && !(new RegExp(filter).test(request.url())))
+        return false;
+    if (includeStatic)
+        return true;
+    const staticTypes = new Set(['image', 'media', 'font', 'stylesheet', 'script']);
+    if (response && response.ok() && staticTypes.has(request.resourceType()))
+        return false;
+    return true;
+}
+function renderRequest(request, response, includeBody, includeHeaders) {
+    const result = [];
+    result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
+    if (response)
+        result.push(`=> [${response.status()}] ${response.statusText()}`);
+    if (includeHeaders)
+        result.push(`headers: ${JSON.stringify(request.headers(), null, 2)}`);
+    if (includeBody) {
+        const body = request.postData();
+        if (body)
+            result.push(`body: ${body}`);
+    }
+    return result.join('\n');
+}
+function parseHeaders(headers) {
+    const result = {};
+    for (const entry of headers ?? []) {
+        const separator = entry.indexOf(':');
+        if (separator === -1)
+            continue;
+        result[entry.slice(0, separator).trim().toLowerCase()] = entry.slice(separator + 1).trim();
+    }
+    return result;
+}
+export default [
+    networkRequests,
+    networkClear,
+    route,
+    routeList,
+    unroute,
+    networkState,
+];

package/lib/tools/pdf.js

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+import * as javascript from '../javascript.js';
+import { outputFile } from '../config.js';
+const pdfSchema = z.object({
+    filename: z.string().optional().describe('File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified.'),
+});
+const pdf = defineTool({
+    capability: 'pdf',
+    schema: {
+        name: 'browser_pdf_save',
+        title: 'Save as PDF',
+        description: 'Save page as PDF',
+        inputSchema: pdfSchema,
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const fileName = await outputFile(context.config, params.filename ?? `page-${new Date().toISOString()}.pdf`);
+        const code = [
+            `// Save page as ${fileName}`,
+            `await page.pdf(${javascript.formatObject({ path: fileName })});`,
+        ];
+        return {
+            code,
+            action: async () => tab.page.pdf({ path: fileName }).then(() => { }),
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+export default [
+    pdf,
+];

package/lib/tools/screenshot.js

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+import * as javascript from '../javascript.js';
+import { outputFile } from '../config.js';
+import { generateLocator, resolveLocator } from './utils.js';
+const screenshotSchema = z.object({
+    raw: z.boolean().optional().describe('Whether to return without compression (in PNG format). Default is false, which returns a JPEG image.'),
+    filename: z.string().optional().describe('File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified.'),
+    element: z.string().optional().describe('Optional human-readable target element description. If not provided, selector or ref can still be used.'),
+    ref: z.string().optional().describe('Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too.'),
+    selector: z.string().optional().describe('Selector for the target element. Mutually exclusive with ref.'),
+    fullPage: z.boolean().optional().describe('Capture the full page instead of the current viewport.'),
+}).refine(data => {
+    const targetCount = Number(!!data.ref) + Number(!!data.selector);
+    return targetCount <= 1;
+}, {
+    message: 'Provide at most one of ref or selector.',
+    path: ['ref']
+});
+const screenshot = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_take_screenshot',
+        title: 'Take a screenshot',
+        description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
+        inputSchema: screenshotSchema,
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const snapshot = tab.snapshotOrDie();
+        const fileType = params.raw ? 'png' : 'jpeg';
+        const fileName = await outputFile(context.config, params.filename ?? `page-${new Date().toISOString()}.${fileType}`);
+        const options = { type: fileType, quality: fileType === 'png' ? undefined : 50, scale: 'css', path: fileName, fullPage: params.fullPage };
+        const isElementScreenshot = !!params.element;
+        const code = [
+            `// Screenshot ${isElementScreenshot ? params.element : 'viewport'} and save it as ${fileName}`,
+        ];
+        const locator = params.element ? resolveLocator(tab, { element: params.element, ref: params.ref, selector: params.selector }) : null;
+        if (locator)
+            code.push(`await page.${await generateLocator(locator)}.screenshot(${javascript.formatObject(options)});`);
+        else
+            code.push(`await page.screenshot(${javascript.formatObject(options)});`);
+        const includeBase64 = context.clientSupportsImages();
+        const action = async () => {
+            const screenshot = locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
+            return {
+                content: includeBase64 ? [{
+                        type: 'image',
+                        data: screenshot.toString('base64'),
+                        mimeType: fileType === 'png' ? 'image/png' : 'image/jpeg',
+                    }] : []
+            };
+        };
+        return {
+            code,
+            action,
+            captureSnapshot: true,
+            waitForNetwork: false,
+        };
+    }
+});
+export default [
+    screenshot,
+];

package/lib/tools/snapshot.js

@@ -0,0 +1,307 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+import * as javascript from '../javascript.js';
+import { generateLocator, resolveLocator } from './utils.js';
+const snapshot = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_snapshot',
+        title: 'Page snapshot',
+        description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
+        inputSchema: z.object({
+            filename: z.string().optional().describe('Ignored compatibility field accepted for Playwright CLI parity.'),
+            selector: z.string().optional().describe('Ignored compatibility field accepted for Playwright CLI parity.'),
+            depth: z.number().optional().describe('Ignored compatibility field accepted for Playwright CLI parity.'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context) => {
+        await context.ensureTab();
+        return {
+            code: ['// <internal code to capture accessibility snapshot>'],
+            captureSnapshot: true,
+            waitForNetwork: false,
+        };
+    },
+});
+const elementBaseSchema = z.object({
+    element: z.string().optional().describe('Optional human-readable element description'),
+    ref: z.string().optional().describe('Exact target element reference from the page snapshot'),
+    selector: z.string().optional().describe('Selector for the target element'),
+});
+const elementSchema = elementBaseSchema.refine(value => !!value.ref !== !!value.selector, {
+    message: 'Provide exactly one of ref or selector.',
+    path: ['ref'],
+});
+const click = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_click',
+        title: 'Click',
+        description: 'Perform click on a web page',
+        inputSchema: elementBaseSchema.extend({
+            button: z.enum(['left', 'middle', 'right']).optional(),
+            modifiers: z.array(z.enum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift'])).optional(),
+            doubleClick: z.boolean().optional(),
+        }).refine(value => !!value.ref !== !!value.selector, {
+            message: 'Provide exactly one of ref or selector.',
+            path: ['ref'],
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const locator = resolveLocator(tab, params);
+        const options = {
+            button: params.button,
+            modifiers: params.modifiers,
+        };
+        return {
+            code: [
+                `// Click ${params.element ?? params.selector ?? params.ref}`,
+                `await page.${await generateLocator(locator)}.${params.doubleClick ? 'dblclick' : 'click'}(${javascript.formatObject(options)});`,
+            ],
+            action: () => params.doubleClick ? locator.dblclick(options) : locator.click(options),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+const doubleClick = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_double_click',
+        title: 'Double click',
+        description: 'Perform double click on a web page',
+        inputSchema: elementSchema,
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const locator = resolveLocator(tab, params);
+        return {
+            code: [
+                `// Double click ${params.element ?? params.selector ?? params.ref}`,
+                `await page.${await generateLocator(locator)}.dblclick();`,
+            ],
+            action: () => locator.dblclick(),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+const drag = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_drag',
+        title: 'Drag mouse',
+        description: 'Perform drag and drop between two elements',
+        inputSchema: z.object({
+            startElement: z.string().optional().describe('Optional human-readable source element description'),
+            startRef: z.string().optional().describe('Exact source element reference from the page snapshot'),
+            startSelector: z.string().optional().describe('Selector for the source element'),
+            endElement: z.string().optional().describe('Optional human-readable target element description'),
+            endRef: z.string().optional().describe('Exact target element reference from the page snapshot'),
+            endSelector: z.string().optional().describe('Selector for the target element'),
+        }).refine(value => !!value.startRef !== !!value.startSelector, {
+            message: 'Provide exactly one of startRef or startSelector.',
+            path: ['startRef'],
+        }).refine(value => !!value.endRef !== !!value.endSelector, {
+            message: 'Provide exactly one of endRef or endSelector.',
+            path: ['endRef'],
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const startLocator = resolveLocator(tab, { element: params.startElement, ref: params.startRef, selector: params.startSelector });
+        const endLocator = resolveLocator(tab, { element: params.endElement, ref: params.endRef, selector: params.endSelector });
+        return {
+            code: [
+                `// Drag ${params.startElement ?? params.startSelector ?? params.startRef} to ${params.endElement ?? params.endSelector ?? params.endRef}`,
+                `await page.${await generateLocator(startLocator)}.dragTo(page.${await generateLocator(endLocator)});`,
+            ],
+            action: () => startLocator.dragTo(endLocator),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+const hover = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_hover',
+        title: 'Hover mouse',
+        description: 'Hover over element on page',
+        inputSchema: elementSchema,
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const locator = resolveLocator(tab, params);
+        return {
+            code: [
+                `// Hover over ${params.element ?? params.selector ?? params.ref}`,
+                `await page.${await generateLocator(locator)}.hover();`,
+            ],
+            action: () => locator.hover(),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+const fill = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_fill',
+        title: 'Fill text',
+        description: 'Fill text into editable element',
+        inputSchema: elementBaseSchema.extend({
+            text: z.string().describe('Text to fill into the element'),
+        }).refine(value => !!value.ref !== !!value.selector, {
+            message: 'Provide exactly one of ref or selector.',
+            path: ['ref'],
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const locator = resolveLocator(tab, params);
+        return {
+            code: [
+                `// Fill "${params.text}" into "${params.element ?? params.selector ?? params.ref}"`,
+                `await page.${await generateLocator(locator)}.fill(${javascript.quote(params.text)});`,
+            ],
+            action: () => locator.fill(params.text),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+const typeSchema = elementBaseSchema.extend({
+    text: z.string().describe('Text to type into the element'),
+    submit: z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
+    slowly: z.boolean().optional().describe('Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.'),
+}).refine(value => !!value.ref !== !!value.selector, {
+    message: 'Provide exactly one of ref or selector.',
+    path: ['ref'],
+});
+const type = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_type',
+        title: 'Type text',
+        description: 'Type text into editable element',
+        inputSchema: typeSchema,
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const locator = resolveLocator(tab, params);
+        const code = [];
+        const steps = [];
+        if (params.slowly) {
+            code.push(`// Press "${params.text}" sequentially into "${params.element ?? params.selector ?? params.ref}"`);
+            code.push(`await page.${await generateLocator(locator)}.pressSequentially(${javascript.quote(params.text)});`);
+            steps.push(() => locator.pressSequentially(params.text));
+        }
+        else {
+            code.push(`// Fill "${params.text}" into "${params.element ?? params.selector ?? params.ref}"`);
+            code.push(`await page.${await generateLocator(locator)}.fill(${javascript.quote(params.text)});`);
+            steps.push(() => locator.fill(params.text));
+        }
+        if (params.submit) {
+            code.push('// Submit text');
+            code.push(`await page.${await generateLocator(locator)}.press('Enter');`);
+            steps.push(() => locator.press('Enter'));
+        }
+        return {
+            code,
+            action: () => steps.reduce((acc, step) => acc.then(step), Promise.resolve()),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+const selectOption = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_select_option',
+        title: 'Select option',
+        description: 'Select an option in a dropdown',
+        inputSchema: elementBaseSchema.extend({
+            values: z.array(z.string()).describe('Array of values to select in the dropdown. This can be a single value or multiple values.'),
+        }).refine(value => !!value.ref !== !!value.selector, {
+            message: 'Provide exactly one of ref or selector.',
+            path: ['ref'],
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const locator = resolveLocator(tab, params);
+        return {
+            code: [
+                `// Select options [${params.values.join(', ')}] in ${params.element ?? params.selector ?? params.ref}`,
+                `await page.${await generateLocator(locator)}.selectOption(${javascript.formatObject(params.values)});`,
+            ],
+            action: () => locator.selectOption(params.values).then(() => { }),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+function defineCheckTool(name, title, checked) {
+    return defineTool({
+        capability: 'core',
+        schema: {
+            name,
+            title,
+            description: checked ? 'Check a checkbox or radio input' : 'Uncheck a checkbox input',
+            inputSchema: elementSchema,
+            type: 'destructive',
+        },
+        handle: async (context, params) => {
+            const tab = context.currentTabOrDie();
+            const locator = resolveLocator(tab, params);
+            return {
+                code: [
+                    `// ${checked ? 'Check' : 'Uncheck'} ${params.element ?? params.selector ?? params.ref}`,
+                    `await page.${await generateLocator(locator)}.${checked ? 'check' : 'uncheck'}();`,
+                ],
+                action: () => checked ? locator.check() : locator.uncheck(),
+                captureSnapshot: true,
+                waitForNetwork: true,
+            };
+        },
+    });
+}
+const check = defineCheckTool('browser_check', 'Check element', true);
+const uncheck = defineCheckTool('browser_uncheck', 'Uncheck element', false);
+export default [
+    snapshot,
+    click,
+    doubleClick,
+    drag,
+    hover,
+    fill,
+    type,
+    selectOption,
+    check,
+    uncheck,
+];