@andrew-chen-wang/camoufox-mcp 0.0.1

package/lib/tools/dialogs.js

@@ -0,0 +1,52 @@
+/**
+ * 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 handleDialog = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_handle_dialog',
+        title: 'Handle a dialog',
+        description: 'Handle a dialog',
+        inputSchema: z.object({
+            accept: z.boolean().describe('Whether to accept the dialog.'),
+            promptText: z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const dialogState = context.modalStates().find(state => state.type === 'dialog');
+        if (!dialogState)
+            throw new Error('No dialog visible');
+        if (params.accept)
+            await dialogState.dialog.accept(params.promptText);
+        else
+            await dialogState.dialog.dismiss();
+        context.clearModalState(dialogState);
+        const code = [
+            `// <internal code to handle "${dialogState.dialog.type()}" dialog>`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+    clearsModalState: 'dialog',
+});
+export default (captureSnapshot) => [
+    handleDialog(captureSnapshot),
+];

package/lib/tools/files.js

@@ -0,0 +1,51 @@
+/**
+ * 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 uploadFile = captureSnapshot => defineTool({
+    capability: 'files',
+    schema: {
+        name: 'browser_file_upload',
+        title: 'Upload files',
+        description: 'Upload one or multiple files',
+        inputSchema: z.object({
+            paths: z.array(z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const modalState = context.modalStates().find(state => state.type === 'fileChooser');
+        if (!modalState)
+            throw new Error('No file chooser visible');
+        const code = [
+            `// <internal code to chose files ${params.paths.join(', ')}`,
+        ];
+        const action = async () => {
+            await modalState.fileChooser.setFiles(params.paths);
+            context.clearModalState(modalState);
+        };
+        return {
+            code,
+            action,
+            captureSnapshot,
+            waitForNetwork: true,
+        };
+    },
+    clearsModalState: 'fileChooser',
+});
+export default (captureSnapshot) => [
+    uploadFile(captureSnapshot),
+];

package/lib/tools/forms.js

@@ -0,0 +1,67 @@
+/**
+ * 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 * as javascript from '../javascript.js';
+import { defineTool } from './tool.js';
+import { generateLocator } from './utils.js';
+const fillForm = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_fill_form',
+        title: 'Fill form',
+        description: 'Fill multiple form fields',
+        inputSchema: z.object({
+            fields: z.array(z.object({
+                name: z.string().describe('Human-readable field name'),
+                type: z.enum(['textbox', 'checkbox', 'radio', 'combobox', 'slider']).describe('Type of the field'),
+                ref: z.string().describe('Exact target field reference from the page snapshot'),
+                value: z.string().describe('Value to fill in the field'),
+            })),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const snapshot = context.currentTabOrDie().snapshotOrDie();
+        const code = [];
+        const steps = [];
+        for (const field of params.fields) {
+            const locator = snapshot.refLocator({ element: field.name, ref: field.ref });
+            const locatorString = await generateLocator(locator);
+            if (field.type === 'textbox' || field.type === 'slider') {
+                code.push(`await page.${locatorString}.fill(${javascript.quote(field.value)});`);
+                steps.push(() => locator.fill(field.value));
+            }
+            else if (field.type === 'checkbox' || field.type === 'radio') {
+                const shouldCheck = field.value === 'true';
+                code.push(`await page.${locatorString}.${shouldCheck ? 'check' : 'uncheck'}();`);
+                steps.push(() => shouldCheck ? locator.check() : locator.uncheck());
+            }
+            else {
+                code.push(`await page.${locatorString}.selectOption({ label: ${javascript.quote(field.value)} });`);
+                steps.push(() => locator.selectOption({ label: field.value }).then(() => { }));
+            }
+        }
+        return {
+            code,
+            action: () => steps.reduce((promise, step) => promise.then(step), Promise.resolve()),
+            captureSnapshot: true,
+            waitForNetwork: true,
+        };
+    },
+});
+export default [
+    fillForm,
+];

package/lib/tools/install.js

@@ -0,0 +1,57 @@
+/**
+ * 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 { fork } from 'child_process';
+import path from 'path';
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+import { fileURLToPath } from 'node:url';
+const install = defineTool({
+    capability: 'install',
+    schema: {
+        name: 'browser_install',
+        title: 'Install the browser specified in the config',
+        description: 'Install the browser specified in the config. Call this if you get an error about the browser not being installed.',
+        inputSchema: z.object({}),
+        type: 'destructive',
+    },
+    handle: async (context) => {
+        const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.browserName ?? 'chrome';
+        const cliUrl = import.meta.resolve('camoufox-js/package.json');
+        const cliPath = path.join(fileURLToPath(cliUrl), '..', 'dist', '__main__.js');
+        const child = fork(cliPath, ['fetch'], {
+            stdio: 'pipe',
+        });
+        const output = [];
+        child.stdout?.on('data', data => output.push(data.toString()));
+        child.stderr?.on('data', data => output.push(data.toString()));
+        await new Promise((resolve, reject) => {
+            child.on('close', code => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Failed to install browser: ${output.join('')}`));
+            });
+        });
+        return {
+            code: [`// Camoufox browser assets installed for ${channel}`],
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+export default [
+    install,
+];

package/lib/tools/keyboard.js

@@ -0,0 +1,158 @@
+/**
+ * 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 pressKey = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_press_key',
+        title: 'Press a key',
+        description: 'Press a key on the keyboard',
+        inputSchema: z.object({
+            key: z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Press ${params.key}`,
+            `await page.keyboard.press('${params.key}');`,
+        ];
+        const action = () => tab.page.keyboard.press(params.key);
+        return {
+            code,
+            action,
+            captureSnapshot,
+            waitForNetwork: true
+        };
+    },
+});
+const keyDown = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_key_down',
+        title: 'Key down',
+        description: 'Press and hold a key on the keyboard',
+        inputSchema: z.object({
+            key: z.string().describe('Name of the key to press down'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        return {
+            code: [
+                `// Press and hold ${params.key}`,
+                `await page.keyboard.down('${params.key}');`,
+            ],
+            action: () => tab.page.keyboard.down(params.key),
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+const keyUp = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_key_up',
+        title: 'Key up',
+        description: 'Release a previously held key on the keyboard',
+        inputSchema: z.object({
+            key: z.string().describe('Name of the key to release'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        return {
+            code: [
+                `// Release ${params.key}`,
+                `await page.keyboard.up('${params.key}');`,
+            ],
+            action: () => tab.page.keyboard.up(params.key),
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+const keyDownCompat = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_keydown',
+        title: 'Key down',
+        description: 'Press and hold a key on the keyboard',
+        inputSchema: z.object({
+            key: z.string().describe('Name of the key to press down'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => keyDown(captureSnapshot).handle(context, params),
+});
+const keyUpCompat = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_keyup',
+        title: 'Key up',
+        description: 'Release a previously held key on the keyboard',
+        inputSchema: z.object({
+            key: z.string().describe('Name of the key to release'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => keyUp(captureSnapshot).handle(context, params),
+});
+const pressSequentially = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_press_sequentially',
+        title: 'Type text sequentially',
+        description: 'Type text into the currently focused element one character at a time',
+        inputSchema: z.object({
+            text: z.string(),
+            submit: z.boolean().optional(),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Press "${params.text}" sequentially into the focused element`,
+            `await page.keyboard.type(${JSON.stringify(params.text)});`,
+        ];
+        const action = async () => {
+            await tab.page.keyboard.type(params.text);
+            if (params.submit)
+                await tab.page.keyboard.press('Enter');
+        };
+        if (params.submit)
+            code.push(`await page.keyboard.press('Enter');`);
+        return {
+            code,
+            action,
+            captureSnapshot,
+            waitForNetwork: true,
+        };
+    },
+});
+export default (captureSnapshot) => [
+    pressKey(captureSnapshot),
+    keyDown(captureSnapshot),
+    keyDownCompat(captureSnapshot),
+    keyUp(captureSnapshot),
+    keyUpCompat(captureSnapshot),
+    pressSequentially(captureSnapshot),
+];

package/lib/tools/mouse.js

@@ -0,0 +1,119 @@
+/**
+ * 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 moveMouse = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_mouse_move',
+        title: 'Move mouse',
+        description: 'Move the mouse to page coordinates',
+        inputSchema: z.object({
+            x: z.number(),
+            y: z.number(),
+            steps: z.number().optional(),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const page = context.currentTabOrDie().page;
+        return {
+            code: [
+                `// Move mouse to (${params.x}, ${params.y})`,
+                `await page.mouse.move(${params.x}, ${params.y}${params.steps !== undefined ? `, { steps: ${params.steps} }` : ''});`,
+            ],
+            action: () => page.mouse.move(params.x, params.y, params.steps !== undefined ? { steps: params.steps } : undefined),
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+const moveMouseCompat = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_mouse_move_xy',
+        title: 'Move mouse',
+        description: 'Move the mouse to page coordinates',
+        inputSchema: z.object({
+            x: z.number(),
+            y: z.number(),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => moveMouse(captureSnapshot).handle(context, params),
+});
+function defineMouseButtonTool(name, title, actionName) {
+    return defineTool({
+        capability: 'core',
+        schema: {
+            name,
+            title,
+            description: `${title} at the current mouse location`,
+            inputSchema: z.object({
+                button: z.enum(['left', 'middle', 'right']).optional(),
+                clickCount: z.number().optional(),
+            }),
+            type: 'destructive',
+        },
+        handle: async (context, params) => {
+            const page = context.currentTabOrDie().page;
+            const options = { button: params.button, clickCount: params.clickCount };
+            return {
+                code: [
+                    `// Mouse ${actionName}`,
+                    `await page.mouse.${actionName}(${Object.values(options).some(v => v !== undefined) ? `{ button: '${params.button ?? 'left'}'${params.clickCount !== undefined ? `, clickCount: ${params.clickCount}` : ''} }` : ''});`,
+                ],
+                action: () => page.mouse[actionName](options),
+                captureSnapshot: true,
+                waitForNetwork: false,
+            };
+        },
+    });
+}
+const mouseDown = defineMouseButtonTool('browser_mouse_down', 'Mouse down', 'down');
+const mouseUp = defineMouseButtonTool('browser_mouse_up', 'Mouse up', 'up');
+const mouseWheel = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_mouse_wheel',
+        title: 'Mouse wheel',
+        description: 'Scroll using the mouse wheel',
+        inputSchema: z.object({
+            deltaX: z.number(),
+            deltaY: z.number(),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const page = context.currentTabOrDie().page;
+        return {
+            code: [
+                `// Mouse wheel by (${params.deltaX}, ${params.deltaY})`,
+                `await page.mouse.wheel(${params.deltaX}, ${params.deltaY});`,
+            ],
+            action: () => page.mouse.wheel(params.deltaX, params.deltaY),
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+export default (captureSnapshot) => [
+    moveMouse(captureSnapshot),
+    moveMouseCompat(captureSnapshot),
+    mouseDown,
+    mouseUp,
+    mouseWheel(captureSnapshot),
+];

package/lib/tools/navigate.js

@@ -0,0 +1,117 @@
+/**
+ * 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 navigate = captureSnapshot => defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_navigate',
+        title: 'Navigate to a URL',
+        description: 'Navigate to a URL',
+        inputSchema: z.object({
+            url: z.string().describe('The URL to navigate to'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params) => {
+        const tab = await context.ensureTab();
+        await tab.navigate(params.url);
+        const code = [
+            `// Navigate to ${params.url}`,
+            `await page.goto('${params.url}');`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+const goBack = captureSnapshot => defineTool({
+    capability: 'history',
+    schema: {
+        name: 'browser_navigate_back',
+        title: 'Go back',
+        description: 'Go back to the previous page',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context) => {
+        const tab = await context.ensureTab();
+        await tab.page.goBack();
+        const code = [
+            `// Navigate back`,
+            `await page.goBack();`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+const goForward = captureSnapshot => defineTool({
+    capability: 'history',
+    schema: {
+        name: 'browser_navigate_forward',
+        title: 'Go forward',
+        description: 'Go forward to the next page',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context) => {
+        const tab = context.currentTabOrDie();
+        await tab.page.goForward();
+        const code = [
+            `// Navigate forward`,
+            `await page.goForward();`,
+        ];
+        return {
+            code,
+            captureSnapshot,
+            waitForNetwork: false,
+        };
+    },
+});
+const reload = captureSnapshot => defineTool({
+    capability: 'history',
+    schema: {
+        name: 'browser_reload',
+        title: 'Reload page',
+        description: 'Reload the current page',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context) => {
+        const tab = context.currentTabOrDie();
+        const code = [
+            `// Reload the page`,
+            `await page.reload();`,
+        ];
+        return {
+            code,
+            action: () => tab.page.reload({ waitUntil: 'domcontentloaded' }).then(() => { }),
+            captureSnapshot,
+            waitForNetwork: true,
+        };
+    },
+});
+export default (captureSnapshot) => [
+    navigate(captureSnapshot),
+    goBack(captureSnapshot),
+    goForward(captureSnapshot),
+    reload(captureSnapshot),
+];