@cotestdev/mcp_playwright 0.0.15 → 0.0.17

package/lib/common/testType.js

@@ -0,0 +1,298 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var testType_exports = {};
+__export(testType_exports, {
+  TestTypeImpl: () => TestTypeImpl,
+  mergeTests: () => mergeTests,
+  rootTestType: () => rootTestType
+});
+module.exports = __toCommonJS(testType_exports);
+var import_playwright_core = require("playwright-core");
+var import_utils = require("playwright-core/lib/utils");
+var import_globals = require("./globals");
+var import_test = require("./test");
+var import_expect = require("../matchers/expect");
+var import_transform = require("../transform/transform");
+var import_validators = require("./validators");
+const testTypeSymbol = Symbol("testType");
+class TestTypeImpl {
+  constructor(fixtures) {
+    this.fixtures = fixtures;
+    const test = (0, import_transform.wrapFunctionWithLocation)(this._createTest.bind(this, "default"));
+    test[testTypeSymbol] = this;
+    test.expect = import_expect.expect;
+    test.only = (0, import_transform.wrapFunctionWithLocation)(this._createTest.bind(this, "only"));
+    test.describe = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "default"));
+    test.describe.only = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "only"));
+    test.describe.configure = (0, import_transform.wrapFunctionWithLocation)(this._configure.bind(this));
+    test.describe.fixme = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "fixme"));
+    test.describe.parallel = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "parallel"));
+    test.describe.parallel.only = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "parallel.only"));
+    test.describe.serial = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "serial"));
+    test.describe.serial.only = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "serial.only"));
+    test.describe.skip = (0, import_transform.wrapFunctionWithLocation)(this._describe.bind(this, "skip"));
+    test.beforeEach = (0, import_transform.wrapFunctionWithLocation)(this._hook.bind(this, "beforeEach"));
+    test.afterEach = (0, import_transform.wrapFunctionWithLocation)(this._hook.bind(this, "afterEach"));
+    test.beforeAll = (0, import_transform.wrapFunctionWithLocation)(this._hook.bind(this, "beforeAll"));
+    test.afterAll = (0, import_transform.wrapFunctionWithLocation)(this._hook.bind(this, "afterAll"));
+    test.skip = (0, import_transform.wrapFunctionWithLocation)(this._modifier.bind(this, "skip"));
+    test.fixme = (0, import_transform.wrapFunctionWithLocation)(this._modifier.bind(this, "fixme"));
+    test.fail = (0, import_transform.wrapFunctionWithLocation)(this._modifier.bind(this, "fail"));
+    test.fail.only = (0, import_transform.wrapFunctionWithLocation)(this._createTest.bind(this, "fail.only"));
+    test.slow = (0, import_transform.wrapFunctionWithLocation)(this._modifier.bind(this, "slow"));
+    test.setTimeout = (0, import_transform.wrapFunctionWithLocation)(this._setTimeout.bind(this));
+    test.step = this._step.bind(this, "pass");
+    test.step.skip = this._step.bind(this, "skip");
+    test.use = (0, import_transform.wrapFunctionWithLocation)(this._use.bind(this));
+    test.extend = (0, import_transform.wrapFunctionWithLocation)(this._extend.bind(this));
+    test.info = () => {
+      const result = (0, import_globals.currentTestInfo)();
+      if (!result)
+        throw new Error("test.info() can only be called while test is running");
+      return result;
+    };
+    this.test = test;
+  }
+  _currentSuite(location, title) {
+    const suite = (0, import_globals.currentlyLoadingFileSuite)();
+    if (!suite) {
+      throw new Error([
+        `Playwright Test did not expect ${title} to be called here.`,
+        `Most common reasons include:`,
+        `- You are calling ${title} in a configuration file.`,
+        `- You are calling ${title} in a file that is imported by the configuration file.`,
+        `- You have two different versions of @playwright/test. This usually happens`,
+        `  when one of the dependencies in your package.json depends on @playwright/test.`
+      ].join("\n"));
+    }
+    return suite;
+  }
+  _createTest(type, location, title, fnOrDetails, fn) {
+    throwIfRunningInsideJest();
+    const suite = this._currentSuite(location, "test()");
+    if (!suite)
+      return;
+    let details;
+    let body;
+    if (typeof fnOrDetails === "function") {
+      body = fnOrDetails;
+      details = {};
+    } else {
+      body = fn;
+      details = fnOrDetails;
+    }
+    const validatedDetails = (0, import_validators.validateTestDetails)(details, location);
+    const test = new import_test.TestCase(title, body, this, location);
+    test._requireFile = suite._requireFile;
+    test.annotations.push(...validatedDetails.annotations);
+    test._tags.push(...validatedDetails.tags);
+    suite._addTest(test);
+    if (type === "only" || type === "fail.only")
+      test._only = true;
+    if (type === "skip" || type === "fixme" || type === "fail")
+      test.annotations.push({ type, location });
+    else if (type === "fail.only")
+      test.annotations.push({ type: "fail", location });
+  }
+  _describe(type, location, titleOrFn, fnOrDetails, fn) {
+    throwIfRunningInsideJest();
+    const suite = this._currentSuite(location, "test.describe()");
+    if (!suite)
+      return;
+    let title;
+    let body;
+    let details;
+    if (typeof titleOrFn === "function") {
+      title = "";
+      details = {};
+      body = titleOrFn;
+    } else if (typeof fnOrDetails === "function") {
+      title = titleOrFn;
+      details = {};
+      body = fnOrDetails;
+    } else {
+      title = titleOrFn;
+      details = fnOrDetails;
+      body = fn;
+    }
+    const validatedDetails = (0, import_validators.validateTestDetails)(details, location);
+    const child = new import_test.Suite(title, "describe");
+    child._requireFile = suite._requireFile;
+    child.location = location;
+    child._staticAnnotations.push(...validatedDetails.annotations);
+    child._tags.push(...validatedDetails.tags);
+    suite._addSuite(child);
+    if (type === "only" || type === "serial.only" || type === "parallel.only")
+      child._only = true;
+    if (type === "serial" || type === "serial.only")
+      child._parallelMode = "serial";
+    if (type === "parallel" || type === "parallel.only")
+      child._parallelMode = "parallel";
+    if (type === "skip" || type === "fixme")
+      child._staticAnnotations.push({ type, location });
+    for (let parent = suite; parent; parent = parent.parent) {
+      if (parent._parallelMode === "serial" && child._parallelMode === "parallel")
+        throw new Error("describe.parallel cannot be nested inside describe.serial");
+      if (parent._parallelMode === "default" && child._parallelMode === "parallel")
+        throw new Error("describe.parallel cannot be nested inside describe with default mode");
+    }
+    (0, import_globals.setCurrentlyLoadingFileSuite)(child);
+    body();
+    (0, import_globals.setCurrentlyLoadingFileSuite)(suite);
+  }
+  _hook(name, location, title, fn) {
+    const suite = this._currentSuite(location, `test.${name}()`);
+    if (!suite)
+      return;
+    if (typeof title === "function") {
+      fn = title;
+      title = `${name} hook`;
+    }
+    suite._hooks.push({ type: name, fn, title, location });
+  }
+  _configure(location, options) {
+    throwIfRunningInsideJest();
+    const suite = this._currentSuite(location, `test.describe.configure()`);
+    if (!suite)
+      return;
+    if (options.timeout !== void 0)
+      suite._timeout = options.timeout;
+    if (options.retries !== void 0)
+      suite._retries = options.retries;
+    if (options.mode !== void 0) {
+      if (suite._parallelMode !== "none")
+        throw new Error(`"${suite._parallelMode}" mode is already assigned for the enclosing scope.`);
+      suite._parallelMode = options.mode;
+      for (let parent = suite.parent; parent; parent = parent.parent) {
+        if (parent._parallelMode === "serial" && suite._parallelMode === "parallel")
+          throw new Error("describe with parallel mode cannot be nested inside describe with serial mode");
+        if (parent._parallelMode === "default" && suite._parallelMode === "parallel")
+          throw new Error("describe with parallel mode cannot be nested inside describe with default mode");
+      }
+    }
+  }
+  _modifier(type, location, ...modifierArgs) {
+    const suite = (0, import_globals.currentlyLoadingFileSuite)();
+    if (suite) {
+      if (typeof modifierArgs[0] === "string" && typeof modifierArgs[1] === "function" && (type === "skip" || type === "fixme" || type === "fail")) {
+        this._createTest(type, location, modifierArgs[0], modifierArgs[1]);
+        return;
+      }
+      if (typeof modifierArgs[0] === "string" && typeof modifierArgs[1] === "object" && typeof modifierArgs[2] === "function" && (type === "skip" || type === "fixme" || type === "fail")) {
+        this._createTest(type, location, modifierArgs[0], modifierArgs[1], modifierArgs[2]);
+        return;
+      }
+      if (typeof modifierArgs[0] === "function") {
+        suite._modifiers.push({ type, fn: modifierArgs[0], location, description: modifierArgs[1] });
+      } else {
+        if (modifierArgs.length >= 1 && !modifierArgs[0])
+          return;
+        const description = modifierArgs[1];
+        suite._staticAnnotations.push({ type, description, location });
+      }
+      return;
+    }
+    const testInfo = (0, import_globals.currentTestInfo)();
+    if (!testInfo)
+      throw new Error(`test.${type}() can only be called inside test, describe block or fixture`);
+    if (typeof modifierArgs[0] === "function")
+      throw new Error(`test.${type}() with a function can only be called inside describe block`);
+    testInfo._modifier(type, location, modifierArgs);
+  }
+  _setTimeout(location, timeout) {
+    const suite = (0, import_globals.currentlyLoadingFileSuite)();
+    if (suite) {
+      suite._timeout = timeout;
+      return;
+    }
+    const testInfo = (0, import_globals.currentTestInfo)();
+    if (!testInfo)
+      throw new Error(`test.setTimeout() can only be called from a test`);
+    testInfo.setTimeout(timeout);
+  }
+  _use(location, fixtures) {
+    const suite = this._currentSuite(location, `test.use()`);
+    if (!suite)
+      return;
+    suite._use.push({ fixtures, location });
+  }
+  async _step(expectation, title, body, options = {}) {
+    const testInfo = (0, import_globals.currentTestInfo)();
+    if (!testInfo)
+      throw new Error(`test.step() can only be called from a test`);
+    const step = testInfo._addStep({ category: "test.step", title, location: options.location, box: options.box });
+    return await (0, import_utils.currentZone)().with("stepZone", step).run(async () => {
+      try {
+        let result = void 0;
+        result = await (0, import_utils.raceAgainstDeadline)(async () => {
+          try {
+            return await step.info._runStepBody(expectation === "skip", body, step.location);
+          } catch (e) {
+            if (result?.timedOut)
+              testInfo._failWithError(e);
+            throw e;
+          }
+        }, options.timeout ? (0, import_utils.monotonicTime)() + options.timeout : 0);
+        if (result.timedOut)
+          throw new import_playwright_core.errors.TimeoutError(`Step timeout of ${options.timeout}ms exceeded.`);
+        step.complete({});
+        return result.result;
+      } catch (error) {
+        step.complete({ error });
+        throw error;
+      }
+    });
+  }
+  _extend(location, fixtures) {
+    if (fixtures[testTypeSymbol])
+      throw new Error(`test.extend() accepts fixtures object, not a test object.
+Did you mean to call mergeTests()?`);
+    const fixturesWithLocation = { fixtures, location };
+    return new TestTypeImpl([...this.fixtures, fixturesWithLocation]).test;
+  }
+}
+function throwIfRunningInsideJest() {
+  if (process.env.JEST_WORKER_ID) {
+    const packageManagerCommand = (0, import_utils.getPackageManagerExecCommand)();
+    throw new Error(
+      `Playwright Test needs to be invoked via '${packageManagerCommand} playwright test' and excluded from Jest test runs.
+Creating one directory for Playwright tests and one for Jest is the recommended way of doing it.
+See https://playwright.dev/docs/intro for more information about Playwright Test.`
+    );
+  }
+}
+const rootTestType = new TestTypeImpl([]);
+function mergeTests(...tests) {
+  let result = rootTestType;
+  for (const t of tests) {
+    const testTypeImpl = t[testTypeSymbol];
+    if (!testTypeImpl)
+      throw new Error(`mergeTests() accepts "test" functions as parameters.
+Did you mean to call test.extend() with fixtures instead?`);
+    const newFixtures = testTypeImpl.fixtures.filter((theirs) => !result.fixtures.find((ours) => ours.fixtures === theirs.fixtures));
+    result = new TestTypeImpl([...result.fixtures, ...newFixtures]);
+  }
+  return result.test;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestTypeImpl,
+  mergeTests,
+  rootTestType
+});

package/lib/common/validators.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validators_exports = {};
+__export(validators_exports, {
+  validateTestAnnotation: () => validateTestAnnotation,
+  validateTestDetails: () => validateTestDetails
+});
+module.exports = __toCommonJS(validators_exports);
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+const testAnnotationSchema = import_utilsBundle.zod.object({
+  type: import_utilsBundle.zod.string(),
+  description: import_utilsBundle.zod.string().optional()
+});
+const testDetailsSchema = import_utilsBundle.zod.object({
+  tag: import_utilsBundle.zod.union([
+    import_utilsBundle.zod.string().optional(),
+    import_utilsBundle.zod.array(import_utilsBundle.zod.string())
+  ]).transform((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : []).refine((val) => val.every((v) => v.startsWith("@")), {
+    message: "Tag must start with '@'"
+  }),
+  annotation: import_utilsBundle.zod.union([
+    testAnnotationSchema,
+    import_utilsBundle.zod.array(testAnnotationSchema).optional()
+  ]).transform((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : [])
+});
+function validateTestAnnotation(annotation) {
+  try {
+    return testAnnotationSchema.parse(annotation);
+  } catch (error) {
+    throwZodError(error);
+  }
+}
+function validateTestDetails(details, location) {
+  try {
+    const parsedDetails = testDetailsSchema.parse(details);
+    return {
+      annotations: parsedDetails.annotation.map((a) => ({ ...a, location })),
+      tags: parsedDetails.tag,
+      location
+    };
+  } catch (error) {
+    throwZodError(error);
+  }
+}
+function throwZodError(error) {
+  throw new Error(error.issues.map((i) => i.message).join("\n"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateTestAnnotation,
+  validateTestDetails
+});

package/lib/mcp/browser/tools/script.js

@@ -21,7 +21,7 @@ __export(script_exports, {
   default: () => script_default
 });
 module.exports = __toCommonJS(script_exports);
-var import_bundle = require("../../sdk/bundle");
+var import_bundle = require("playwright-core/lib/sdk/bundle");
 var import_tool = require("./tool");
 var import_utils = require("./utils");
 const executeScript = (0, import_tool.defineTabTool)({

package/lib/mcp/index.js

@@ -35,7 +35,7 @@ var import_browserServerBackend = require("./browser/browserServerBackend");
 var import_config = require("./browser/config");
 var import_browserContextFactory = require("./browser/browserContextFactory");
 var mcpServer = __toESM(require("./sdk/server"));
-const packageJSON = require("../../package.json");
+const packageJSON = require("playwright-core/lib/package.json");
 async function createConnection(userConfig = {}, contextGetter) {
   const config = await (0, import_config.resolveConfig)(userConfig);
   const factory = contextGetter ? new SimpleBrowserContextFactory(contextGetter) : (0, import_browserContextFactory.contextFactory)(config);

package/lib/mcp/test/seed.js

@@ -38,7 +38,7 @@ module.exports = __toCommonJS(seed_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_utils = require("playwright-core/lib/utils");
-var import_projectUtils = require("../../runner/projectUtils");
+var import_projectUtils = require("playwright-core/lib/runner/projectUtils");
 function seedProject(config, projectName) {
   if (!projectName)
     return (0, import_projectUtils.findTopLevelProjects)(config)[0];

package/lib/mcp/test/testContext.js

@@ -37,14 +37,14 @@ var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
 var import_utils = require("playwright-core/lib/utils");
-var import_base = require("../../reporters/base");
-var import_list = __toESM(require("../../reporters/list"));
+var import_base = require("playwright-core/lib/reporters/base");
+var import_list = __toESM(require("playwright-core/lib/reporters/list"));
 var import_streams = require("./streams");
 var import_util = require("../../util");
-var import_testRunner = require("../../runner/testRunner");
+var import_testRunner = require("playwright-core/lib/runner/testRunner");
 var import_seed = require("./seed");
 var import_exports = require("../sdk/exports");
-var import_configLoader = require("../../common/configLoader");
+var import_configLoader = require("playwright-core/lib/common/configLoader");
 var import_response = require("../browser/response");
 var import_log = require("../log");
 class GeneratorJournal {

package/lib/mcp/test/testTools.js

@@ -34,7 +34,7 @@ __export(testTools_exports, {
 });
 module.exports = __toCommonJS(testTools_exports);
 var import_mcpBundle = require("playwright-core/lib/mcpBundle");
-var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
+var import_listModeReporter = __toESM(require("playwright-core/lib/reporters/listModeReporter"));
 var import_testTool = require("./testTool");
 const listTests = (0, import_testTool.defineTestTool)({
   schema: {

package/lib/mcp/vscode/host.js

@@ -37,7 +37,7 @@ var mcpServer = __toESM(require("../sdk/server"));
 var import_log = require("../log");
 var import_browserServerBackend = require("../browser/browserServerBackend");
 var import_browserContextFactory = require("../browser/browserContextFactory");
-const packageJSON = require("../../../package.json");
+const packageJSON = require("playwright-core/lib/../package.json");
 const { z, zodToJsonSchema } = mcpBundle;
 const contextSwitchOptions = z.object({
   connectionString: z.string().optional().describe("The connection string to use to connect to the browser"),

package/lib/mcpBundle.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcpBundle_exports = {};
+__export(mcpBundle_exports, {
+  CallToolRequestSchema: () => CallToolRequestSchema,
+  Client: () => Client,
+  ListRootsRequestSchema: () => ListRootsRequestSchema,
+  ListToolsRequestSchema: () => ListToolsRequestSchema,
+  Loop: () => Loop,
+  PingRequestSchema: () => PingRequestSchema,
+  ProgressNotificationSchema: () => ProgressNotificationSchema,
+  SSEClientTransport: () => SSEClientTransport,
+  SSEServerTransport: () => SSEServerTransport,
+  Server: () => Server,
+  StdioClientTransport: () => StdioClientTransport,
+  StdioServerTransport: () => StdioServerTransport,
+  StreamableHTTPClientTransport: () => StreamableHTTPClientTransport,
+  StreamableHTTPServerTransport: () => StreamableHTTPServerTransport,
+  z: () => z,
+  zodToJsonSchema: () => zodToJsonSchema
+});
+module.exports = __toCommonJS(mcpBundle_exports);
+var bundle = __toESM(require("./mcpBundleImpl"));
+const zodToJsonSchema = bundle.zodToJsonSchema;
+const Client = bundle.Client;
+const Server = bundle.Server;
+const SSEClientTransport = bundle.SSEClientTransport;
+const SSEServerTransport = bundle.SSEServerTransport;
+const StdioClientTransport = bundle.StdioClientTransport;
+const StdioServerTransport = bundle.StdioServerTransport;
+const StreamableHTTPServerTransport = bundle.StreamableHTTPServerTransport;
+const StreamableHTTPClientTransport = bundle.StreamableHTTPClientTransport;
+const CallToolRequestSchema = bundle.CallToolRequestSchema;
+const ListRootsRequestSchema = bundle.ListRootsRequestSchema;
+const ProgressNotificationSchema = bundle.ProgressNotificationSchema;
+const ListToolsRequestSchema = bundle.ListToolsRequestSchema;
+const PingRequestSchema = bundle.PingRequestSchema;
+const Loop = bundle.Loop;
+const z = bundle.z;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallToolRequestSchema,
+  Client,
+  ListRootsRequestSchema,
+  ListToolsRequestSchema,
+  Loop,
+  PingRequestSchema,
+  ProgressNotificationSchema,
+  SSEClientTransport,
+  SSEServerTransport,
+  Server,
+  StdioClientTransport,
+  StdioServerTransport,
+  StreamableHTTPClientTransport,
+  StreamableHTTPServerTransport,
+  z,
+  zodToJsonSchema
+});