patch

Author: riywo

package-lock.json

@@ -1,17 +1,16 @@
 {
-  "name": "@playwright/mcp",
+  "name": "@aethr/playwright-mcp",
   "version": "0.0.13",
   "description": "Playwright Tools for MCP",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/microsoft/playwright-mcp.git"
+    "url": "git+https://github.com/autifyhq/aethr-playwright-mcp.git"
   },
-  "homepage": "https://playwright.dev",
   "engines": {
     "node": ">=18"
   },
   "author": {
-    "name": "Microsoft Corporation"
+    "name": "Autify Inc."
   },
   "license": "Apache-2.0",
   "scripts": {
@@ -32,6 +31,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.1",
+    "@playwright/test": "^1.52.0-alpha-1743163434000",
     "commander": "^13.1.0",
     "playwright": "^1.52.0-alpha-1743163434000",
     "yaml": "^2.7.1",
@@ -40,7 +40,6 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
-    "@playwright/test": "^1.52.0-alpha-1743163434000",
     "@stylistic/eslint-plugin": "^3.0.1",
     "@types/node": "^22.13.10",
     "@typescript-eslint/eslint-plugin": "^8.26.1",

package.json

@@ -122,6 +122,8 @@ export class Context {
   async close() {
     if (!this._browserContext)
       return;
+    if (process.env.TRACE)
+      await this._browserContext.tracing.stop({ path: process.env.TRACE });
     await this._browserContext.close();
   }
 
@@ -133,6 +135,8 @@ export class Context {
       for (const page of this._browserContext.pages())
         this._onPageCreated(page);
       this._browserContext.on('page', page => this._onPageCreated(page));
+      if (process.env.TRACE)
+        await this._browserContext.tracing.start({ screenshots: true, snapshots: true, sources: true });
     }
     return this._browserContext;
   }

src/context.ts

@@ -30,6 +30,7 @@ import type { Tool, ToolCapability } from './tools/tool';
 import type { Resource } from './resources/resource';
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { LaunchOptions } from 'playwright';
+import assert from './tools/assert';
 
 const snapshotTools: Tool[] = [
   ...common(true),
@@ -40,6 +41,7 @@ const snapshotTools: Tool[] = [
   ...pdf,
   ...snapshot,
   ...tabs(true),
+  ...assert,
 ];
 
 const screenshotTools: Tool[] = [

src/index.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Autify Inc.
+ *
+ * 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 { Tool } from './tool';
+import zodToJsonSchema from 'zod-to-json-schema';
+import { expect } from '@playwright/test';
+import { replaceEnvVar } from './utils';
+
+const elementSchema = z.object({
+  element: z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
+  ref: z.string().describe('Exact target element reference from the page snapshot'),
+});
+
+const assertContainTextSchema = elementSchema.partial().extend({
+  against: z.enum(['element', 'page']).describe('Assert against the specified element or the whole page. If page, element and ref are not needed.'),
+  expected: z.string().describe('Expected text to be contained in the specified element or the whole page'),
+});
+
+const assertContainText: Tool = {
+  capability: 'core',
+  schema: {
+    name: 'browser_assert_contain_text',
+    description: 'Assert that the element or the whole page contains the expected text. It returns JSON having "result" (PASS or FAIL), "against" (assert against element or page) and "error" (details if result is FAIL).',
+    inputSchema: zodToJsonSchema(assertContainTextSchema),
+  },
+
+  handle: async (context, params) => {
+    const validatedParams = assertContainTextSchema.parse(params);
+    try {
+      if (validatedParams.against === 'element') {
+        if (validatedParams.ref === undefined)
+          throw new Error('ref is required when asserting against an element');
+        const locator = context.currentTab().lastSnapshot().refLocator(validatedParams.ref);
+        await expect(locator).toContainText(replaceEnvVar(validatedParams.expected));
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ result: 'PASS', against: 'element' }),
+          }],
+        };
+      } else {
+        const locator = context.currentTab().page.locator('body');
+        await expect(locator).toContainText(replaceEnvVar(validatedParams.expected));
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ result: 'PASS', against: 'page' }),
+          }],
+        };
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({ result: 'FAIL', error, against: validatedParams.against }),
+        }],
+      };
+    }
+  },
+};
+
+export default [assertContainText];

src/tools/assert.ts

@@ -18,6 +18,7 @@ import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
 import type { ToolFactory } from './tool';
+import { replaceEnvVar } from './utils';
 
 const navigateSchema = z.object({
   url: z.string().describe('The URL to navigate to'),
@@ -34,7 +35,7 @@ const navigate: ToolFactory = captureSnapshot => ({
     const validatedParams = navigateSchema.parse(params);
     const currentTab = await context.ensureTab();
     return await currentTab.run(async tab => {
-      await tab.navigate(validatedParams.url);
+      await tab.navigate(replaceEnvVar(validatedParams.url));
       const code = [
         `// Navigate to ${validatedParams.url}`,
         `await page.goto('${validatedParams.url}');`,

src/tools/navigate.ts

@@ -21,6 +21,7 @@ import type * as playwright from 'playwright';
 import type { Tool } from './tool';
 import { generateLocator } from '../context';
 import * as javascript from '../javascript';
+import { replaceEnvVar } from './utils';
 
 const snapshot: Tool = {
   capability: 'core',
@@ -141,11 +142,11 @@ const type: Tool = {
       if (validatedParams.slowly) {
         code.push(`// Press "${validatedParams.text}" sequentially into "${validatedParams.element}"`);
         code.push(`await page.${await generateLocator(locator)}.pressSequentially(${javascript.quote(validatedParams.text)});`);
-        await locator.pressSequentially(validatedParams.text);
+        await locator.pressSequentially(replaceEnvVar(validatedParams.text));
       } else {
         code.push(`// Fill "${validatedParams.text}" into "${validatedParams.element}"`);
         code.push(`await page.${await generateLocator(locator)}.fill(${javascript.quote(validatedParams.text)});`);
-        await locator.fill(validatedParams.text);
+        await locator.fill(replaceEnvVar(validatedParams.text));
       }
       if (validatedParams.submit) {
         code.push(`// Submit text`);

src/tools/snapshot.ts

@@ -72,3 +72,16 @@ export async function waitForCompletion<R>(page: playwright.Page, callback: () =
 export function sanitizeForFilePath(s: string) {
   return s.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, '-');
 }
+
+export function replaceEnvVar(input: string): string {
+  if (input.startsWith('${') && input.endsWith('}')) {
+    const variable = input.slice(2, -1);
+    const envValue = process.env[variable];
+    if (envValue)
+      return envValue;
+    else
+      return input;
+  } else {
+    return input;
+  }
+}

src/tools/utils.ts

@@ -19,6 +19,7 @@ import { test, expect } from './fixtures';
 test('test snapshot tool list', async ({ client }) => {
   const { tools } = await client.listTools();
   expect(new Set(tools.map(t => t.name))).toEqual(new Set([
+    'browser_assert_contain_text',
     'browser_click',
     'browser_drag',
     'browser_file_upload',