@wordbricks/playwright-mcp 0.1.7 → 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/program.js

@@ -39,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.')

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordbricks/playwright-mcp",
-  "version": "0.1.7",
+  "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": "npm:rebrowser-playwright@1.56.1",
-    "playwright-core": "npm:rebrowser-playwright@1.56.1",
+    "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.56.1",
+    "@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);