patchright-bun-core 1.58.2 → 1.59.0

package/lib/serverRegistry.js

@@ -0,0 +1,156 @@
+"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 serverRegistry_exports = {};
+__export(serverRegistry_exports, {
+  serverRegistry: () => serverRegistry
+});
+module.exports = __toCommonJS(serverRegistry_exports);
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+const packageVersion = require("../package.json").version;
+class ServerRegistry {
+  async list() {
+    const files = await import_fs.default.promises.readdir(this._browsersDir()).catch(() => []);
+    const result = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const filePath = import_path.default.join(this._browsersDir(), file);
+        const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+        const descriptor = JSON.parse(content);
+        const key = descriptor.workspaceDir ?? "";
+        let list = result.get(key);
+        if (!list) {
+          list = [];
+          result.set(key, list);
+        }
+        list.push(canConnect(descriptor).then((connectable) => ({ ...descriptor, canConnect: connectable, file: filePath })));
+      } catch {
+      }
+    }
+    const resolvedResult = /* @__PURE__ */ new Map();
+    for (const [key, promises] of result) {
+      const entries = await Promise.all(promises);
+      const descriptors = [];
+      for (const entry of entries) {
+        if (!entry.canConnect && !entry.browser.userDataDir) {
+          await import_fs.default.promises.unlink(entry.file).catch(() => {
+          });
+          continue;
+        }
+        descriptors.push(entry);
+      }
+      if (descriptors.length)
+        resolvedResult.set(key, descriptors);
+    }
+    return resolvedResult;
+  }
+  async create(browser, endpoint) {
+    const file = import_path.default.join(this._browsersDir(), browser.guid);
+    await import_fs.default.promises.mkdir(this._browsersDir(), { recursive: true });
+    const descriptor = {
+      playwrightVersion: packageVersion,
+      playwrightLib: require.resolve(".."),
+      title: endpoint.title,
+      browser,
+      endpoint: endpoint.endpoint,
+      workspaceDir: endpoint.workspaceDir
+    };
+    await import_fs.default.promises.writeFile(file, JSON.stringify(descriptor), "utf-8");
+  }
+  async delete(guid) {
+    const file = import_path.default.join(this._browsersDir(), guid);
+    await import_fs.default.promises.unlink(file).catch(() => {
+    });
+  }
+  async deleteUserData(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    if (descriptor.browser.userDataDir)
+      await import_fs.default.promises.rm(descriptor.browser.userDataDir, { recursive: true, force: true });
+    await import_fs.default.promises.unlink(filePath);
+  }
+  readDescriptor(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    return descriptor;
+  }
+  async find(name) {
+    const entries = await this.list();
+    for (const [, browsers] of entries) {
+      for (const browser of browsers) {
+        if (browser.title === name)
+          return browser;
+      }
+    }
+    return null;
+  }
+  _browsersDir() {
+    return process.env.PLAYWRIGHT_SERVER_REGISTRY || registryDirectory;
+  }
+}
+async function canConnect(descriptor) {
+  if (!descriptor.endpoint)
+    return false;
+  if (descriptor.endpoint.startsWith("ws://") || descriptor.endpoint.startsWith("wss://")) {
+    return await new Promise((resolve) => {
+      const url = new URL(descriptor.endpoint);
+      const socket = import_net.default.createConnection(Number(url.port), url.hostname, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("error", () => resolve(false));
+    });
+  }
+  return await new Promise((resolve) => {
+    const socket = import_net.default.createConnection(descriptor.endpoint ?? descriptor.pipeName, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+  });
+}
+const defaultCacheDirectory = (() => {
+  if (process.platform === "linux")
+    return process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    return import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    return process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  throw new Error("Unsupported platform: " + process.platform);
+})();
+const registryDirectory = import_path.default.join(defaultCacheDirectory, "ms-playwright", "b");
+const serverRegistry = new ServerRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serverRegistry
+});

package/lib/tools/backend/browserBackend.js

@@ -0,0 +1,79 @@
+"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 browserBackend_exports = {};
+__export(browserBackend_exports, {
+  BrowserBackend: () => BrowserBackend
+});
+module.exports = __toCommonJS(browserBackend_exports);
+var import_context = require("./context");
+var import_response = require("./response");
+var import_sessionLog = require("./sessionLog");
+var import_utilsBundle = require("../../utilsBundle");
+class BrowserBackend {
+  constructor(config, browserContext, tools) {
+    this._config = config;
+    this._tools = tools;
+    this.browserContext = browserContext;
+  }
+  async initialize(clientInfo) {
+    this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, clientInfo.cwd) : void 0;
+    this._context = new import_context.Context(this.browserContext, {
+      config: this._config,
+      sessionLog: this._sessionLog,
+      cwd: clientInfo.cwd
+    });
+  }
+  async dispose() {
+    await this._context?.dispose().catch((e) => (0, import_utilsBundle.debug)("pw:tools:error")(e));
+  }
+  async callTool(name, rawArguments = {}) {
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `### Error
+Tool "${name}" not found` }],
+        isError: true
+      };
+    }
+    const parsedArguments = tool.schema.inputSchema.parse(rawArguments);
+    const cwd = rawArguments._meta?.cwd;
+    const context = this._context;
+    const response = new import_response.Response(context, name, parsedArguments, cwd);
+    context.setRunningTool(name);
+    let responseObject;
+    try {
+      await tool.handle(context, parsedArguments, response);
+      responseObject = await response.serialize();
+      this._sessionLog?.logResponse(name, parsedArguments, responseObject);
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `### Error
+${String(error)}` }],
+        isError: true
+      };
+    } finally {
+      context.setRunningTool(void 0);
+    }
+    return responseObject;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBackend
+});

package/lib/tools/backend/common.js

@@ -0,0 +1,63 @@
+"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 common_exports = {};
+__export(common_exports, {
+  default: () => common_default
+});
+module.exports = __toCommonJS(common_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+var import_response = require("./response");
+const close = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_close",
+    title: "Close browser",
+    description: "Close the page",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    const result = (0, import_response.renderTabsMarkdown)([]);
+    response.addTextResult(result.join("\n"));
+    response.addCode(`await page.close()`);
+    response.setClose();
+  }
+});
+const resize = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_resize",
+    title: "Resize browser window",
+    description: "Resize the browser window",
+    inputSchema: import_zodBundle.z.object({
+      width: import_zodBundle.z.number().describe("Width of the browser window"),
+      height: import_zodBundle.z.number().describe("Height of the browser window")
+    }),
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`);
+    await tab.page.setViewportSize({ width: params.width, height: params.height });
+  }
+});
+var common_default = [
+  close,
+  resize
+];

package/lib/tools/backend/config.js

@@ -0,0 +1,41 @@
+"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 config_exports = {};
+__export(config_exports, {
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+const configShow = (0, import_tool.defineTool)({
+  capability: "config",
+  schema: {
+    name: "browser_get_config",
+    title: "Get config",
+    description: "Get the final resolved config after merging CLI options, environment variables and config file.",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    response.addTextResult(JSON.stringify(context.config, null, 2));
+  }
+});
+var config_default = [
+  configShow
+];

package/lib/tools/backend/console.js

@@ -0,0 +1,66 @@
+"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 console_exports = {};
+__export(console_exports, {
+  default: () => console_default
+});
+module.exports = __toCommonJS(console_exports);
+var import_zodBundle = require("../../zodBundle");
+var import_tool = require("./tool");
+const console = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_console_messages",
+    title: "Get console messages",
+    description: "Returns all console messages",
+    inputSchema: import_zodBundle.z.object({
+      level: import_zodBundle.z.enum(["error", "warning", "info", "debug"]).default("info").describe('Level of the console messages to return. Each level includes the messages of more severe levels. Defaults to "info".'),
+      all: import_zodBundle.z.boolean().optional().describe("Return all console messages since the beginning of the session, not just since the last navigation. Defaults to false."),
+      filename: import_zodBundle.z.string().optional().describe("Filename to save the console messages to. If not provided, messages are returned as text.")
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const count = await tab.consoleMessageCount();
+    const header = [`Total messages: ${count.total} (Errors: ${count.errors}, Warnings: ${count.warnings})`];
+    const messages = await tab.consoleMessages(params.level, params.all);
+    if (messages.length !== count.total)
+      header.push(`Returning ${messages.length} messages for level "${params.level}"`);
+    const text = [...header, "", ...messages.map((message) => message.toString())].join("\n");
+    await response.addResult("Console", text, { prefix: "console", ext: "log", suggestedFilename: params.filename });
+  }
+});
+const consoleClear = (0, import_tool.defineTabTool)({
+  capability: "core",
+  skillOnly: true,
+  schema: {
+    name: "browser_console_clear",
+    title: "Clear console messages",
+    description: "Clear all console messages",
+    inputSchema: import_zodBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab) => {
+    await tab.clearConsoleMessages();
+  }
+});
+var console_default = [
+  console,
+  consoleClear
+];