@wordbricks/playwright-mcp 0.1.6 → 0.1.8

package/config.d.ts

@@ -63,6 +63,11 @@ export type Config = {
      * Remote endpoint to connect to an existing Playwright server.
      */
     remoteEndpoint?: string;
+
+    /**
+     * Path to a JavaScript file to inject into all pages using addInitScript.
+     */
+    initScript?: string;
   },
 
   server?: {

package/lib/browserContextFactory.js

@@ -27,6 +27,12 @@ import { createHash } from './utils/guid.js';
 import { outputFile } from './config.js';
 import { extensionPath } from './utils/extensionPath.js';
 const TIMEOUT_STR = '30m';
+async function applyInitScript(browserContext, config) {
+    if (config.browser.initScript) {
+        const scriptContent = await fs.promises.readFile(config.browser.initScript, 'utf8');
+        await browserContext.addInitScript(scriptContent);
+    }
+}
 export function contextFactory(config) {
     if (config.browser.remoteEndpoint)
         return new RemoteContextFactory(config);
@@ -138,7 +144,9 @@ class IsolatedContextFactory extends BaseContextFactory {
         });
     }
     async _doCreateContext(browser) {
-        return browser.newContext(this.config.browser.contextOptions);
+        const browserContext = await browser.newContext(this.config.browser.contextOptions);
+        await applyInitScript(browserContext, this.config);
+        return browserContext;
     }
 }
 class CdpContextFactory extends BaseContextFactory {
@@ -149,7 +157,9 @@ class CdpContextFactory extends BaseContextFactory {
         return playwright.chromium.connectOverCDP(this.config.browser.cdpEndpoint);
     }
     async _doCreateContext(browser) {
-        return this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
+        const browserContext = this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
+        await applyInitScript(browserContext, this.config);
+        return browserContext;
     }
 }
 class RemoteContextFactory extends BaseContextFactory {
@@ -164,7 +174,9 @@ class RemoteContextFactory extends BaseContextFactory {
         return playwright[this.config.browser.browserName].connect(String(url));
     }
     async _doCreateContext(browser) {
-        return browser.newContext();
+        const browserContext = await browser.newContext();
+        await applyInitScript(browserContext, this.config);
+        return browserContext;
     }
 }
 class PersistentContextFactory {
@@ -199,6 +211,7 @@ class PersistentContextFactory {
                     handleSIGTERM: false,
                     args,
                 });
+                await applyInitScript(browserContext, this.config);
                 // Start auto-close timer
                 this._startAutoCloseTimer(browserContext);
                 const close = () => this._closeBrowserContext(browserContext, userDataDir);

package/lib/config.js

@@ -120,6 +120,7 @@ export function configFromCLIOptions(cliOptions) {
             launchOptions,
             contextOptions,
             cdpEndpoint: cliOptions.cdpEndpoint,
+            initScript: cliOptions.initScript,
         },
         server: {
             port: cliOptions.port,
@@ -151,6 +152,7 @@ function configFromEnv() {
     options.headless = envToBoolean(process.env.PLAYWRIGHT_MCP_HEADLESS);
     options.host = envToString(process.env.PLAYWRIGHT_MCP_HOST);
     options.ignoreHttpsErrors = envToBoolean(process.env.PLAYWRIGHT_MCP_IGNORE_HTTPS_ERRORS);
+    options.initScript = envToString(process.env.PLAYWRIGHT_MCP_INIT_SCRIPT);
     options.isolated = envToBoolean(process.env.PLAYWRIGHT_MCP_ISOLATED);
     if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES === 'omit')
         options.imageResponses = 'omit';

package/lib/context.js

@@ -21,6 +21,7 @@ import { buildHookRegistry } from './hooks/registry.js';
 import { setEventStore, createEventStore } from './hooks/events.js';
 import { setupNetworkTracking } from './hooks/networkSetup.js';
 import { outputFile } from './config.js';
+import * as codegen from './utils/codegen.js';
 const testDebug = debug('pw:mcp:test');
 export class Context {
     tools;
@@ -184,6 +185,14 @@ export class Context {
         }
         return result;
     }
+    lookupSecret(secretName) {
+        // if (!this.config.secrets?.[secretName])
+        return { value: secretName, code: codegen.quote(secretName) };
+        // return {
+        //   value: this.config.secrets[secretName]!,
+        //   code: `process.env['${secretName}']`,
+        // };
+    }
 }
 export class InputRecorder {
     _context;

package/lib/hooks/schema.js

@@ -15,6 +15,7 @@ export const hookNameSchema = z.enum([
 export const toolNameSchema = z.enum([
     'browser_click',
     'browser_extract_framework_state',
+    'browser_fill_form',
     'browser_get_snapshot',
     // 'browser_get_visible_html',
     'browser_navigate',
@@ -26,6 +27,7 @@ export const toolNameSchema = z.enum([
     'browser_reload',
     'browser_repl',
     'browser_scroll',
+    'browser_type',
     'browser_wait',
 ]);
 export const EventTypeSchema = z.enum([

package/lib/mcp/tool.js

@@ -14,16 +14,25 @@
  * limitations under the License.
  */
 import { zodToJsonSchema } from 'zod-to-json-schema';
-export function toMcpTool(tool) {
+import { z } from 'zod';
+const typesWithIntent = ['action', 'assertion', 'input'];
+export function toMcpTool(tool, options) {
+    const inputSchema = options?.addIntent && typesWithIntent.includes(tool.type) ? tool.inputSchema.extend({
+        intent: z.string().describe('The intent of the call, for example the test step description plan idea')
+    }) : tool.inputSchema;
+    const readOnly = tool.type === 'readOnly' || tool.type === 'assertion';
     return {
         name: tool.name,
         description: tool.description,
-        inputSchema: zodToJsonSchema(tool.inputSchema, { strictUnions: true }),
+        inputSchema: zodToJsonSchema(inputSchema, { strictUnions: true }),
         annotations: {
             title: tool.title,
-            readOnlyHint: tool.type === 'readOnly',
-            destructiveHint: tool.type === 'destructive',
+            readOnlyHint: readOnly,
+            destructiveHint: !readOnly,
             openWorldHint: true,
         },
     };
 }
+export function defineToolSchema(tool) {
+    return tool;
+}

package/lib/program.js

@@ -20,7 +20,6 @@ import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList } from './
 import { packageJSON } from './utils/package.js';
 import { Context } from './context.js';
 import { contextFactory } from './browserContextFactory.js';
-import { runLoopTools } from './loopTools/main.js';
 import { ProxyBackend } from './mcp/proxyBackend.js';
 import { BrowserServerBackend } from './browserServerBackend.js';
 import { ExtensionContextFactory } from './extension/extensionContextFactory.js';
@@ -40,6 +39,7 @@ program
     .option('--headless', 'run browser in headless mode, headed by default')
     .option('--host <host>', 'host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.')
     .option('--ignore-https-errors', 'ignore https errors')
+    .option('--init-script <path>', 'path to a JavaScript file to inject into all pages using addInitScript.')
     .option('--isolated', 'keep the browser profile in memory, do not save it to disk.')
     .option('--image-responses <mode>', 'whether to send image responses to the client. Can be "allow" or "omit", Defaults to "allow".')
     .option('--no-sandbox', 'disable the sandbox for all process types that are normally sandboxed.')
@@ -71,10 +71,6 @@ program
         await mcpTransport.start(serverBackendFactory, config.server);
         return;
     }
-    if (options.loopTools) {
-        await runLoopTools(config);
-        return;
-    }
     const browserContextFactory = contextFactory(config);
     const providers = [mcpProviderForBrowserContextFactory(config, browserContextFactory)];
     if (options.connectTool)

package/lib/response.js

@@ -62,9 +62,9 @@ export class Response {
     images() {
         return this._images;
     }
-    setIncludeSnapshot() {
-        // Disabled: Page state logging not needed
-        // this._includeSnapshot = true;
+    // NOTE Wordbricks Disabled: Page state logging not needed
+    setIncludeSnapshot(full) {
+        // this._includeSnapshot = full ?? 'incremental';
     }
     setIncludeTabs() {
         this._includeTabs = true;

package/lib/tab.js

@@ -203,7 +203,7 @@ export class Tab extends EventEmitter {
         // This avoids invalidating refs obtained from browser_get_snapshot while still
         // initializing the mapping when needed (e.g., after navigation).
         await this.page._snapshotForAI();
-        return params.map(param => this.page.locator(`aria-ref=${param.ref}`).describe(param.element));
+        return params.map(param => this.page.locator(`aria-ref=${param.ref}`));
     }
     async waitForTimeout(time) {
         if (this._javaScriptBlocked()) {

package/lib/tools/dialogs.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-const handleDialog = defineTabTool({
+export const handleDialog = defineTabTool({
     capability: 'core',
     schema: {
         name: 'browser_handle_dialog',
@@ -25,7 +25,7 @@ const handleDialog = defineTabTool({
             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',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/evaluate.js

@@ -29,7 +29,7 @@ const evaluate = defineTabTool({
         title: 'Evaluate JavaScript',
         description: 'Evaluate JavaScript expression on page or element',
         inputSchema: evaluateSchema,
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/files.js

@@ -15,16 +15,16 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-const uploadFile = defineTabTool({
+export const uploadFile = defineTabTool({
     capability: 'core',
     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.'),
+            paths: z.array(z.string()).optional().describe('The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled.'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -34,7 +34,8 @@ const uploadFile = defineTabTool({
         response.addCode(`await fileChooser.setFiles(${JSON.stringify(params.paths)})`);
         tab.clearModalState(modalState);
         await tab.waitForCompletion(async () => {
-            await modalState.fileChooser.setFiles(params.paths);
+            if (params.paths)
+                await modalState.fileChooser.setFiles(params.paths);
         });
     },
     clearsModalState: 'fileChooser',

package/lib/tools/form.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 { z } from 'zod';
+import { defineTabTool } from './tool.js';
+import * as codegen from '../utils/codegen.js';
+import { generateLocator } from './utils.js';
+const fillForm = defineTabTool({
+    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. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.'),
+            })).describe('Fields to fill in'),
+        }),
+        type: 'input',
+    },
+    handle: async (tab, params, response) => {
+        for (const field of params.fields) {
+            const locator = await tab.refLocator({ element: field.name, ref: field.ref });
+            if (field.type === 'textbox' || field.type === 'slider') {
+                const secret = tab.context.lookupSecret(field.value);
+                await locator.fill(secret.value);
+                response.addCode(`await page.${await generateLocator(locator)}.fill(${secret.code});`);
+            }
+            else if (field.type === 'checkbox' || field.type === 'radio') {
+                await locator.setChecked(field.value === 'true');
+                response.addCode(`await page.${await generateLocator(locator)}.setChecked(${field.value});`);
+            }
+            else if (field.type === 'combobox') {
+                await locator.selectOption({ label: field.value });
+                response.addCode(`await page.${await generateLocator(locator)}.selectOption(${codegen.quote(field.value)});`);
+            }
+        }
+    },
+});
+export default [
+    fillForm,
+];

package/lib/tools/install.js

@@ -15,7 +15,6 @@
  */
 import { fork } from 'child_process';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { z } from 'zod';
 import { defineTool } from './tool.js';
 const install = defineTool({
@@ -25,12 +24,11 @@ const install = defineTool({
         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',
+        type: 'action',
     },
     handle: async (context, params, response) => {
         const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.browserName ?? 'chrome';
-        const cliUrl = import.meta.resolve('playwright/package.json');
-        const cliPath = path.join(fileURLToPath(cliUrl), '..', 'cli.js');
+        const cliPath = path.join(require.resolve('playwright/package.json'), '../cli.js');
         const child = fork(cliPath, ['install', channel], {
             stdio: 'pipe',
         });

package/lib/tools/keyboard.js

@@ -27,7 +27,7 @@ const pressKey = defineTabTool({
         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',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -50,7 +50,7 @@ const type = defineTabTool({
         title: 'Type text',
         description: 'Type text into editable element',
         inputSchema: typeSchema,
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         const locator = await tab.refLocator(params);

package/lib/tools/mouse.js

@@ -48,7 +48,7 @@ const mouseClick = defineTabTool({
             x: z.number().describe('X coordinate'),
             y: z.number().describe('Y coordinate'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -75,7 +75,7 @@ const mouseDrag = defineTabTool({
             endX: z.number().describe('End X coordinate'),
             endY: z.number().describe('End Y coordinate'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/navigate.js

@@ -24,7 +24,7 @@ const navigate = defineTool({
         inputSchema: z.object({
             url: z.string().describe('The URL to navigate to'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (context, params, response) => {
         const tab = await context.ensureTab();

package/lib/tools/repl.js

@@ -220,7 +220,7 @@ const repl = defineTabTool({
         title: 'Browser REPL',
         description: 'DevTools-like browser REPL. Per-tab state persists across calls (const/let/functions); supports top-level await. Survives SPA nav; resets on full reload or when switching tabs. Helpers available via window.mcp: JSON5, JSONPath, _, GraphQLClient, gql, graphqlRequest. No need for wrapping in IIFE.',
         inputSchema: replSchema,
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         const page = tab.page;

package/lib/tools/scroll.js

@@ -56,7 +56,7 @@ const scrollWheel = defineTabTool({
         title: 'Scroll page',
         description: 'Scroll the page using mouse wheel with human-like behavior',
         inputSchema: scrollSchema,
-        type: 'destructive',
+        type: 'readOnly',
     },
     handle: async (tab, params, response) => {
         const requestedDeltaY = params.amount || 0;

package/lib/tools/snapshot.js

@@ -28,7 +28,7 @@ const snapshot = defineTool({
     },
     handle: async (context, params, response) => {
         await context.ensureTab();
-        response.setIncludeSnapshot();
+        response.setIncludeSnapshot('full');
     },
 });
 export const elementSchema = z.object({
@@ -38,6 +38,7 @@ export const elementSchema = z.object({
 const clickSchema = elementSchema.extend({
     doubleClick: z.boolean().optional().describe('Whether to perform a double click instead of a single click'),
     button: z.enum(['left', 'right', 'middle']).optional().describe('Button to click, defaults to left'),
+    modifiers: z.array(z.enum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift'])).optional().describe('Modifier keys to press'),
 });
 const click = defineTabTool({
     capability: 'core',
@@ -46,22 +47,26 @@ const click = defineTabTool({
         title: 'Click',
         description: 'Perform click on a web page',
         inputSchema: clickSchema,
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
         const locator = await tab.refLocator(params);
-        const button = params.button;
-        const buttonAttr = button ? `{ button: '${button}' }` : '';
+        const options = {
+            button: params.button,
+            modifiers: params.modifiers,
+        };
+        const formatted = javascript.formatObject(options, ' ', 'oneline');
+        const optionsAttr = formatted !== '{}' ? formatted : '';
         if (params.doubleClick)
-            response.addCode(`await page.${await generateLocator(locator)}.dblclick(${buttonAttr});`);
+            response.addCode(`await page.${await generateLocator(locator)}.dblclick(${optionsAttr});`);
         else
-            response.addCode(`await page.${await generateLocator(locator)}.click(${buttonAttr});`);
+            response.addCode(`await page.${await generateLocator(locator)}.click(${optionsAttr});`);
         await tab.waitForCompletion(async () => {
             if (params.doubleClick)
-                await locator.dblclick({ button });
+                await locator.dblclick(options);
             else
-                await locator.click({ button });
+                await locator.click(options);
         });
     },
 });
@@ -77,7 +82,7 @@ const drag = defineTabTool({
             endElement: z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
             endRef: z.string().describe('Exact target element reference from the page snapshot'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -119,7 +124,7 @@ const selectOption = defineTabTool({
         title: 'Select option',
         description: 'Select an option in a dropdown',
         inputSchema: selectOptionSchema,
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/tabs.js

@@ -15,73 +15,45 @@
  */
 import { z } from 'zod';
 import { defineTool } from './tool.js';
-const listTabs = defineTool({
+const browserTabs = defineTool({
     capability: 'core-tabs',
     schema: {
-        name: 'browser_tab_list',
-        title: 'List tabs',
-        description: 'List browser tabs',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.ensureTab();
-        response.setIncludeTabs();
-    },
-});
-const selectTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_select',
-        title: 'Select a tab',
-        description: 'Select a tab by index',
-        inputSchema: z.object({
-            index: z.number().describe('The index of the tab to select'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.selectTab(params.index);
-        response.setIncludeSnapshot();
-    },
-});
-const newTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_new',
-        title: 'Open a new tab',
-        description: 'Open a new tab',
-        inputSchema: z.object({
-            url: z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        const tab = await context.newTab();
-        if (params.url)
-            await tab.navigate(params.url);
-        response.setIncludeSnapshot();
-    },
-});
-const closeTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_close',
-        title: 'Close a tab',
-        description: 'Close a tab',
+        name: 'browser_tabs',
+        title: 'Manage tabs',
+        description: 'List, create, close, or select a browser tab.',
         inputSchema: z.object({
-            index: z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
+            action: z.enum(['list', 'new', 'close', 'select']).describe('Operation to perform'),
+            index: z.number().optional().describe('Tab index, used for close/select. If omitted for close, current tab is closed.'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (context, params, response) => {
-        await context.closeTab(params.index);
-        response.setIncludeSnapshot();
+        switch (params.action) {
+            case 'list': {
+                await context.ensureTab();
+                response.setIncludeTabs();
+                return;
+            }
+            case 'new': {
+                await context.newTab();
+                response.setIncludeTabs();
+                return;
+            }
+            case 'close': {
+                await context.closeTab(params.index);
+                response.setIncludeSnapshot('full');
+                return;
+            }
+            case 'select': {
+                if (params.index === undefined)
+                    throw new Error('Tab index is required');
+                await context.selectTab(params.index);
+                response.setIncludeSnapshot('full');
+                return;
+            }
+        }
     },
 });
 export default [
-    listTabs,
-    newTab,
-    selectTab,
-    closeTab,
+    browserTabs,
 ];

package/lib/tools/tool.js

@@ -20,7 +20,7 @@ export function defineTabTool(tool) {
     return {
         ...tool,
         handle: async (context, params, response) => {
-            const tab = context.currentTabOrDie();
+            const tab = await context.ensureTab();
             const modalStates = tab.modalStates().map(state => state.type);
             if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState))
                 response.addError(`Error: The tool "${tool.schema.name}" can only be used when there is related modal state present.\n` + tab.modalStatesMarkdown().join('\n'));

package/lib/utils/codegen.js

@@ -31,7 +31,7 @@ export function escapeWithQuotes(text, char = '\'') {
 export function quote(text) {
     return escapeWithQuotes(text, '\'');
 }
-export function formatObject(value, indent = '  ') {
+export function formatObject(value, indent = '  ', mode = 'multiline') {
     if (typeof value === 'string')
         return quote(value);
     if (Array.isArray(value))
@@ -43,7 +43,9 @@ export function formatObject(value, indent = '  ') {
         const tokens = [];
         for (const key of keys)
             tokens.push(`${key}: ${formatObject(value[key])}`);
-        return `{\n${indent}${tokens.join(`,\n${indent}`)}\n}`;
+        if (mode === 'multiline')
+            return `{\n${tokens.join(`,\n${indent}`)}\n}`;
+        return `{ ${tokens.join(', ')} }`;
     }
     return String(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordbricks/playwright-mcp",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Playwright Tools for MCP",
   "type": "module",
   "repository": {
@@ -60,8 +60,8 @@
     "lodash": "^4.17.21",
     "mime": "^4.0.7",
     "ms": "^2.1.3",
-    "playwright": "1.55.0-alpha-2025-08-12",
-    "playwright-core": "1.55.0-alpha-2025-08-12",
+    "playwright": "npm:rebrowser-playwright@1.52.0",
+    "playwright-core": "npm:rebrowser-playwright@1.52.0",
     "raw-body": "^3.0.0",
     "typescript-parsec": "0.3.4",
     "ws": "^8.18.1",
@@ -70,9 +70,10 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.57.0",
+    "@cfworker/json-schema": "^4.1.1",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
-    "@playwright/test": "1.55.0-alpha-2025-08-12",
+    "@playwright/test": "1.52.0",
     "@stylistic/eslint-plugin": "^3.0.1",
     "@tomjs/unzip-crx": "1.1.3",
     "@types/chrome": "^0.0.315",

package/lib/loop/loop.js

@@ -1,69 +0,0 @@
-/**
- * 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 debug from 'debug';
-export async function runTask(delegate, client, task, oneShot = false) {
-    const { tools } = await client.listTools();
-    const taskContent = oneShot ? `Perform following task: ${task}.` : `Perform following task: ${task}. Once the task is complete, call the "done" tool.`;
-    const conversation = delegate.createConversation(taskContent, tools, oneShot);
-    for (let iteration = 0; iteration < 5; ++iteration) {
-        debug('history')('Making API call for iteration', iteration);
-        const toolCalls = await delegate.makeApiCall(conversation);
-        if (toolCalls.length === 0)
-            throw new Error('Call the "done" tool when the task is complete.');
-        const toolResults = [];
-        for (const toolCall of toolCalls) {
-            const doneResult = delegate.checkDoneToolCall(toolCall);
-            if (doneResult !== null)
-                return conversation.messages;
-            const { name, arguments: args, id } = toolCall;
-            try {
-                debug('tool')(name, args);
-                const response = await client.callTool({
-                    name,
-                    arguments: args,
-                });
-                const responseContent = (response.content || []);
-                debug('tool')(responseContent);
-                const text = responseContent.filter(part => part.type === 'text').map(part => part.text).join('\n');
-                toolResults.push({
-                    toolCallId: id,
-                    content: text,
-                });
-            }
-            catch (error) {
-                debug('tool')(error);
-                toolResults.push({
-                    toolCallId: id,
-                    content: `Error while executing tool "${name}": ${error instanceof Error ? error.message : String(error)}\n\nPlease try to recover and complete the task.`,
-                    isError: true,
-                });
-                // Skip remaining tool calls for this iteration
-                for (const remainingToolCall of toolCalls.slice(toolCalls.indexOf(toolCall) + 1)) {
-                    toolResults.push({
-                        toolCallId: remainingToolCall.id,
-                        content: `This tool call is skipped due to previous error.`,
-                        isError: true,
-                    });
-                }
-                break;
-            }
-        }
-        delegate.addToolResults(conversation, toolResults);
-        if (oneShot)
-            return conversation.messages;
-    }
-    throw new Error('Failed to perform step, max attempts reached');
-}

package/lib/loop/loopClaude.js

@@ -1,152 +0,0 @@
-/**
- * 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.
- */
-const model = 'claude-sonnet-4-20250514';
-export class ClaudeDelegate {
-    _anthropic;
-    async anthropic() {
-        if (!this._anthropic) {
-            const anthropic = await import('@anthropic-ai/sdk');
-            this._anthropic = new anthropic.Anthropic();
-        }
-        return this._anthropic;
-    }
-    createConversation(task, tools, oneShot) {
-        const llmTools = tools.map(tool => ({
-            name: tool.name,
-            description: tool.description || '',
-            inputSchema: tool.inputSchema,
-        }));
-        if (!oneShot) {
-            llmTools.push({
-                name: 'done',
-                description: 'Call this tool when the task is complete.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            });
-        }
-        return {
-            messages: [{
-                    role: 'user',
-                    content: task
-                }],
-            tools: llmTools,
-        };
-    }
-    async makeApiCall(conversation) {
-        // Convert generic messages to Claude format
-        const claudeMessages = [];
-        for (const message of conversation.messages) {
-            if (message.role === 'user') {
-                claudeMessages.push({
-                    role: 'user',
-                    content: message.content
-                });
-            }
-            else if (message.role === 'assistant') {
-                const content = [];
-                // Add text content
-                if (message.content) {
-                    content.push({
-                        type: 'text',
-                        text: message.content,
-                        citations: []
-                    });
-                }
-                // Add tool calls
-                if (message.toolCalls) {
-                    for (const toolCall of message.toolCalls) {
-                        content.push({
-                            type: 'tool_use',
-                            id: toolCall.id,
-                            name: toolCall.name,
-                            input: toolCall.arguments
-                        });
-                    }
-                }
-                claudeMessages.push({
-                    role: 'assistant',
-                    content
-                });
-            }
-            else if (message.role === 'tool') {
-                // Tool results are added differently - we need to find if there's already a user message with tool results
-                const lastMessage = claudeMessages[claudeMessages.length - 1];
-                const toolResult = {
-                    type: 'tool_result',
-                    tool_use_id: message.toolCallId,
-                    content: message.content,
-                    is_error: message.isError,
-                };
-                if (lastMessage && lastMessage.role === 'user' && Array.isArray(lastMessage.content)) {
-                    // Add to existing tool results message
-                    lastMessage.content.push(toolResult);
-                }
-                else {
-                    // Create new tool results message
-                    claudeMessages.push({
-                        role: 'user',
-                        content: [toolResult]
-                    });
-                }
-            }
-        }
-        // Convert generic tools to Claude format
-        const claudeTools = conversation.tools.map(tool => ({
-            name: tool.name,
-            description: tool.description,
-            input_schema: tool.inputSchema,
-        }));
-        const anthropic = await this.anthropic();
-        const response = await anthropic.messages.create({
-            model,
-            max_tokens: 10000,
-            messages: claudeMessages,
-            tools: claudeTools,
-        });
-        // Extract tool calls and add assistant message to generic conversation
-        const toolCalls = response.content.filter(block => block.type === 'tool_use');
-        const textContent = response.content.filter(block => block.type === 'text').map(block => block.text).join('');
-        const llmToolCalls = toolCalls.map(toolCall => ({
-            name: toolCall.name,
-            arguments: toolCall.input,
-            id: toolCall.id,
-        }));
-        // Add assistant message to generic conversation
-        conversation.messages.push({
-            role: 'assistant',
-            content: textContent,
-            toolCalls: llmToolCalls.length > 0 ? llmToolCalls : undefined
-        });
-        return llmToolCalls;
-    }
-    addToolResults(conversation, results) {
-        for (const result of results) {
-            conversation.messages.push({
-                role: 'tool',
-                toolCallId: result.toolCallId,
-                content: result.content,
-                isError: result.isError,
-            });
-        }
-    }
-    checkDoneToolCall(toolCall) {
-        if (toolCall.name === 'done')
-            return toolCall.arguments.result;
-        return null;
-    }
-}

package/lib/loop/loopOpenAI.js

@@ -1,141 +0,0 @@
-/**
- * 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.
- */
-const model = 'gpt-4.1';
-export class OpenAIDelegate {
-    _openai;
-    async openai() {
-        if (!this._openai) {
-            const oai = await import('openai');
-            this._openai = new oai.OpenAI();
-        }
-        return this._openai;
-    }
-    createConversation(task, tools, oneShot) {
-        const genericTools = tools.map(tool => ({
-            name: tool.name,
-            description: tool.description || '',
-            inputSchema: tool.inputSchema,
-        }));
-        if (!oneShot) {
-            genericTools.push({
-                name: 'done',
-                description: 'Call this tool when the task is complete.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            });
-        }
-        return {
-            messages: [{
-                    role: 'user',
-                    content: task
-                }],
-            tools: genericTools,
-        };
-    }
-    async makeApiCall(conversation) {
-        // Convert generic messages to OpenAI format
-        const openaiMessages = [];
-        for (const message of conversation.messages) {
-            if (message.role === 'user') {
-                openaiMessages.push({
-                    role: 'user',
-                    content: message.content
-                });
-            }
-            else if (message.role === 'assistant') {
-                const toolCalls = [];
-                if (message.toolCalls) {
-                    for (const toolCall of message.toolCalls) {
-                        toolCalls.push({
-                            id: toolCall.id,
-                            type: 'function',
-                            function: {
-                                name: toolCall.name,
-                                arguments: JSON.stringify(toolCall.arguments)
-                            }
-                        });
-                    }
-                }
-                const assistantMessage = {
-                    role: 'assistant'
-                };
-                if (message.content)
-                    assistantMessage.content = message.content;
-                if (toolCalls.length > 0)
-                    assistantMessage.tool_calls = toolCalls;
-                openaiMessages.push(assistantMessage);
-            }
-            else if (message.role === 'tool') {
-                openaiMessages.push({
-                    role: 'tool',
-                    tool_call_id: message.toolCallId,
-                    content: message.content,
-                });
-            }
-        }
-        // Convert generic tools to OpenAI format
-        const openaiTools = conversation.tools.map(tool => ({
-            type: 'function',
-            function: {
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.inputSchema,
-            },
-        }));
-        const openai = await this.openai();
-        const response = await openai.chat.completions.create({
-            model,
-            messages: openaiMessages,
-            tools: openaiTools,
-            tool_choice: 'auto'
-        });
-        const message = response.choices[0].message;
-        // Extract tool calls and add assistant message to generic conversation
-        const toolCalls = message.tool_calls || [];
-        const genericToolCalls = toolCalls.map(toolCall => {
-            const functionCall = toolCall.function;
-            return {
-                name: functionCall.name,
-                arguments: JSON.parse(functionCall.arguments),
-                id: toolCall.id,
-            };
-        });
-        // Add assistant message to generic conversation
-        conversation.messages.push({
-            role: 'assistant',
-            content: message.content || '',
-            toolCalls: genericToolCalls.length > 0 ? genericToolCalls : undefined
-        });
-        return genericToolCalls;
-    }
-    addToolResults(conversation, results) {
-        for (const result of results) {
-            conversation.messages.push({
-                role: 'tool',
-                toolCallId: result.toolCallId,
-                content: result.content,
-                isError: result.isError,
-            });
-        }
-    }
-    checkDoneToolCall(toolCall) {
-        if (toolCall.name === 'done')
-            return toolCall.arguments.result;
-        return null;
-    }
-}

package/lib/loop/main.js

@@ -1,60 +0,0 @@
-/**
- * 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.
- */
-/* eslint-disable no-console */
-import path from 'path';
-import url from 'url';
-import dotenv from 'dotenv';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { program } from 'commander';
-import { OpenAIDelegate } from './loopOpenAI.js';
-import { ClaudeDelegate } from './loopClaude.js';
-import { runTask } from './loop.js';
-dotenv.config();
-const __filename = url.fileURLToPath(import.meta.url);
-async function run(delegate) {
-    const transport = new StdioClientTransport({
-        command: 'node',
-        args: [
-            path.resolve(__filename, '../../../cli.js'),
-            '--save-session',
-            '--output-dir', path.resolve(__filename, '../../../sessions')
-        ],
-        stderr: 'inherit',
-        env: process.env,
-    });
-    const client = new Client({ name: 'test', version: '1.0.0' });
-    await client.connect(transport);
-    await client.ping();
-    for (const task of tasks) {
-        const messages = await runTask(delegate, client, task);
-        for (const message of messages)
-            console.log(`${message.role}: ${message.content}`);
-    }
-    await client.close();
-}
-const tasks = [
-    'Open https://playwright.dev/',
-];
-program
-    .option('--model <model>', 'model to use')
-    .action(async (options) => {
-    if (options.model === 'claude')
-        await run(new ClaudeDelegate());
-    else
-        await run(new OpenAIDelegate());
-});
-void program.parseAsync(process.argv);

package/lib/loopTools/context.js

@@ -1,66 +0,0 @@
-/**
- * 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 { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { contextFactory } from '../browserContextFactory.js';
-import { BrowserServerBackend } from '../browserServerBackend.js';
-import { Context as BrowserContext } from '../context.js';
-import { runTask } from '../loop/loop.js';
-import { OpenAIDelegate } from '../loop/loopOpenAI.js';
-import { ClaudeDelegate } from '../loop/loopClaude.js';
-import { InProcessTransport } from '../mcp/inProcessTransport.js';
-import * as mcpServer from '../mcp/server.js';
-export class Context {
-    config;
-    _client;
-    _delegate;
-    constructor(config, client) {
-        this.config = config;
-        this._client = client;
-        if (process.env.OPENAI_API_KEY)
-            this._delegate = new OpenAIDelegate();
-        else if (process.env.ANTHROPIC_API_KEY)
-            this._delegate = new ClaudeDelegate();
-        else
-            throw new Error('No LLM API key found. Please set OPENAI_API_KEY or ANTHROPIC_API_KEY environment variable.');
-    }
-    static async create(config) {
-        const client = new Client({ name: 'Playwright Proxy', version: '1.0.0' });
-        const browserContextFactory = contextFactory(config);
-        const server = mcpServer.createServer(new BrowserServerBackend(config, browserContextFactory), false);
-        await client.connect(new InProcessTransport(server));
-        await client.ping();
-        return new Context(config, client);
-    }
-    async runTask(task, oneShot = false) {
-        const messages = await runTask(this._delegate, this._client, task, oneShot);
-        const lines = [];
-        // Skip the first message, which is the user's task.
-        for (const message of messages.slice(1)) {
-            // Trim out all page snapshots.
-            if (!message.content.trim())
-                continue;
-            const index = oneShot ? -1 : message.content.indexOf('### Page state');
-            const trimmedContent = index === -1 ? message.content : message.content.substring(0, index);
-            lines.push(`[${message.role}]:`, trimmedContent);
-        }
-        return {
-            content: [{ type: 'text', text: lines.join('\n') }],
-        };
-    }
-    async close() {
-        await BrowserContext.disposeAll();
-    }
-}

package/lib/loopTools/main.js

@@ -1,51 +0,0 @@
-/**
- * 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 dotenv from 'dotenv';
-import * as mcpTransport from '../mcp/transport.js';
-import { packageJSON } from '../utils/package.js';
-import { Context } from './context.js';
-import { perform } from './perform.js';
-import { snapshot } from './snapshot.js';
-import { toMcpTool } from '../mcp/tool.js';
-export async function runLoopTools(config) {
-    dotenv.config();
-    const serverBackendFactory = () => new LoopToolsServerBackend(config);
-    await mcpTransport.start(serverBackendFactory, config.server);
-}
-class LoopToolsServerBackend {
-    name = 'Playwright';
-    version = packageJSON.version;
-    _config;
-    _context;
-    _tools = [perform, snapshot];
-    constructor(config) {
-        this._config = config;
-    }
-    async initialize() {
-        this._context = await Context.create(this._config);
-    }
-    async listTools() {
-        return this._tools.map(tool => toMcpTool(tool.schema));
-    }
-    async callTool(name, args) {
-        const tool = this._tools.find(tool => tool.schema.name === name);
-        const parsedArguments = tool.schema.inputSchema.parse(args || {});
-        return await tool.handle(this._context, parsedArguments);
-    }
-    serverClosed() {
-        void this._context.close();
-    }
-}

package/lib/loopTools/perform.js

@@ -1,32 +0,0 @@
-/**
- * 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 performSchema = z.object({
-    task: z.string().describe('The task to perform with the browser'),
-});
-export const perform = defineTool({
-    schema: {
-        name: 'browser_perform',
-        title: 'Perform a task with the browser',
-        description: 'Perform a task with the browser. It can click, type, export, capture screenshot, drag, hover, select options, etc.',
-        inputSchema: performSchema,
-        type: 'destructive',
-    },
-    handle: async (context, params) => {
-        return await context.runTask(params.task);
-    },
-});

package/lib/loopTools/snapshot.js

@@ -1,29 +0,0 @@
-/**
- * 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';
-export const snapshot = defineTool({
-    schema: {
-        name: 'browser_snapshot',
-        title: 'Take a snapshot of the browser',
-        description: 'Take a snapshot of the browser to read what is on the page.',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (context, params) => {
-        return await context.runTask('Capture browser snapshot', true);
-    },
-});

package/lib/loopTools/tool.js

@@ -1,18 +0,0 @@
-/**
- * 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.
- */
-export function defineTool(tool) {
-    return tool;
-}