@stablyai/internal-playwright 0.1.0

package/lib/mcp/browser/backend.js

@@ -0,0 +1,93 @@
+"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 backend_exports = {};
+__export(backend_exports, {
+  BrowserBackend: () => BrowserBackend,
+  runBrowserBackendOnError: () => runBrowserBackendOnError
+});
+module.exports = __toCommonJS(backend_exports);
+var mcp = __toESM(require("../sdk/exports"));
+var mcpBundle = __toESM(require("../sdk/bundle"));
+var import_tools = require("./tools");
+var import_exports = require("../sdk/exports");
+var import_mdb = require("../sdk/mdb");
+var import_util = require("../../util");
+const tools = [import_tools.snapshot, import_tools.pickLocator, import_tools.evaluate];
+class BrowserBackend {
+  constructor(page) {
+    this.name = "Playwright";
+    this.version = "0.0.1";
+    this._tools = tools;
+    this._page = page;
+  }
+  async initialize() {
+  }
+  async listTools() {
+    return [...this._tools.map((tool) => mcp.toMcpTool(tool.schema)), mcp.toMcpTool(doneToolSchema)];
+  }
+  async callTool(name, args) {
+    if (name === "done") {
+      this.requestSelfDestruct?.();
+      return {
+        content: [{ type: "text", text: "Done" }]
+      };
+    }
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool)
+      throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map((tool2) => tool2.schema.name).join(", ")}`);
+    const parsedArguments = tool.schema.inputSchema.parse(args || {});
+    return await tool.handle(this._page, parsedArguments);
+  }
+}
+const doneToolSchema = (0, import_exports.defineToolSchema)({
+  name: "done",
+  title: "Done",
+  description: "Done",
+  inputSchema: mcpBundle.z.object({}),
+  type: "destructive"
+});
+async function runBrowserBackendOnError(page, message) {
+  if (!process.env.PLAYWRIGHT_DEBUGGER_ENABLED)
+    return;
+  const snapshot2 = await page._snapshotForAI();
+  const introMessage = `### Paused on error:
+${(0, import_util.stripAnsiEscapes)(message())}
+
+### Current page snapshot:
+${snapshot2}
+
+### Task
+Try recovering from the error prior to continuing, use following tools to recover: ${tools.map((tool) => tool.schema.name).join(", ")}`;
+  await (0, import_mdb.runOnPauseBackendLoop)(process.env.PLAYWRIGHT_MDB_URL, new BrowserBackend(page), introMessage);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBackend,
+  runBrowserBackendOnError
+});

package/lib/mcp/browser/backend.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/browser/backend.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as mcp from '../sdk/exports';\nimport * as mcpBundle from '../sdk/bundle';\nimport { snapshot, pickLocator, evaluate } from './tools';\nimport { defineToolSchema } from '../sdk/exports';\nimport { runOnPauseBackendLoop } from '../sdk/mdb';\nimport { stripAnsiEscapes } from '../../util';\n\nimport type { Tool } from './tool';\nimport type * as playwright from '../../../index';\nimport type { ServerBackendOnPause } from '../sdk/mdb';\n\ntype PageEx = playwright.Page & {\n  _snapshotForAI: () => Promise<string>;\n};\n\nconst tools = [snapshot, pickLocator, evaluate];\n\nexport class BrowserBackend implements ServerBackendOnPause {\n  readonly name = 'Playwright';\n  readonly version = '0.0.1';\n  private _tools: Tool<any>[] = tools;\n  private _page: playwright.Page;\n\n  constructor(page: playwright.Page) {\n    this._page = page;\n  }\n\n  async initialize() {\n  }\n\n  async listTools(): Promise<mcp.Tool[]> {\n    return [...this._tools.map(tool => mcp.toMcpTool(tool.schema)), mcp.toMcpTool(doneToolSchema)];\n  }\n\n  async callTool(name: string, args: mcp.CallToolRequest['params']['arguments']): Promise<mcp.CallToolResult> {\n    if (name === 'done') {\n      (this as ServerBackendOnPause).requestSelfDestruct?.();\n      return {\n        content: [{ type: 'text', text: 'Done' }],\n      };\n    }\n\n    const tool = this._tools.find(tool => tool.schema.name === name);\n    if (!tool)\n      throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map(tool => tool.schema.name).join(', ')}`);\n    const parsedArguments = tool.schema.inputSchema.parse(args || {});\n    return await tool.handle(this._page, parsedArguments);\n  }\n}\n\nconst doneToolSchema = defineToolSchema({\n  name: 'done',\n  title: 'Done',\n  description: 'Done',\n  inputSchema: mcpBundle.z.object({}),\n  type: 'destructive',\n});\n\nexport async function runBrowserBackendOnError(page: playwright.Page, message: () => string) {\n  if (!process.env.PLAYWRIGHT_DEBUGGER_ENABLED)\n    return;\n  const snapshot = await (page as PageEx)._snapshotForAI();\n  const introMessage = `### Paused on error:\n${stripAnsiEscapes(message())}\n\n### Current page snapshot:\n${snapshot}\n\n### Task\nTry recovering from the error prior to continuing, use following tools to recover: ${tools.map(tool => tool.schema.name).join(', ')}`;\n  await runOnPauseBackendLoop(process.env.PLAYWRIGHT_MDB_URL!, new BrowserBackend(page), introMessage);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,UAAqB;AACrB,gBAA2B;AAC3B,mBAAgD;AAChD,qBAAiC;AACjC,iBAAsC;AACtC,kBAAiC;AAUjC,MAAM,QAAQ,CAAC,uBAAU,0BAAa,qBAAQ;AAEvC,MAAM,eAA+C;AAAA,EAM1D,YAAY,MAAuB;AALnC,SAAS,OAAO;AAChB,SAAS,UAAU;AACnB,SAAQ,SAAsB;AAI5B,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,MAAM,aAAa;AAAA,EACnB;AAAA,EAEA,MAAM,YAAiC;AACrC,WAAO,CAAC,GAAG,KAAK,OAAO,IAAI,UAAQ,IAAI,UAAU,KAAK,MAAM,CAAC,GAAG,IAAI,UAAU,cAAc,CAAC;AAAA,EAC/F;AAAA,EAEA,MAAM,SAAS,MAAc,MAA+E;AAC1G,QAAI,SAAS,QAAQ;AACnB,MAAC,KAA8B,sBAAsB;AACrD,aAAO;AAAA,QACL,SAAS,CAAC,EAAE,MAAM,QAAQ,MAAM,OAAO,CAAC;AAAA,MAC1C;AAAA,IACF;AAEA,UAAM,OAAO,KAAK,OAAO,KAAK,CAAAA,UAAQA,MAAK,OAAO,SAAS,IAAI;AAC/D,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,mBAAmB,IAAI,sBAAsB,KAAK,OAAO,IAAI,CAAAA,UAAQA,MAAK,OAAO,IAAI,EAAE,KAAK,IAAI,CAAC,EAAE;AACrH,UAAM,kBAAkB,KAAK,OAAO,YAAY,MAAM,QAAQ,CAAC,CAAC;AAChE,WAAO,MAAM,KAAK,OAAO,KAAK,OAAO,eAAe;AAAA,EACtD;AACF;AAEA,MAAM,qBAAiB,iCAAiB;AAAA,EACtC,MAAM;AAAA,EACN,OAAO;AAAA,EACP,aAAa;AAAA,EACb,aAAa,UAAU,EAAE,OAAO,CAAC,CAAC;AAAA,EAClC,MAAM;AACR,CAAC;AAED,eAAsB,yBAAyB,MAAuB,SAAuB;AAC3F,MAAI,CAAC,QAAQ,IAAI;AACf;AACF,QAAMC,YAAW,MAAO,KAAgB,eAAe;AACvD,QAAM,eAAe;AAAA,MACrB,8BAAiB,QAAQ,CAAC,CAAC;AAAA;AAAA;AAAA,EAG3BA,SAAQ;AAAA;AAAA;AAAA,qFAG2E,MAAM,IAAI,UAAQ,KAAK,OAAO,IAAI,EAAE,KAAK,IAAI,CAAC;AACjI,YAAM,kCAAsB,QAAQ,IAAI,oBAAqB,IAAI,eAAe,IAAI,GAAG,YAAY;AACrG;",
+  "names": ["tool", "snapshot"]
+}

package/lib/mcp/browser/browserContextFactory.js

@@ -0,0 +1,296 @@
+"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 browserContextFactory_exports = {};
+__export(browserContextFactory_exports, {
+  SharedContextFactory: () => SharedContextFactory,
+  contextFactory: () => contextFactory
+});
+module.exports = __toCommonJS(browserContextFactory_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var playwright = __toESM(require("playwright-core"));
+var import_registry = require("playwright-core/lib/server/registry/index");
+var import_server = require("playwright-core/lib/server");
+var import_log = require("../log");
+var import_config = require("./config");
+var import_server2 = require("../sdk/server");
+function contextFactory(config) {
+  if (config.sharedBrowserContext)
+    return SharedContextFactory.create(config);
+  if (config.browser.remoteEndpoint)
+    return new RemoteContextFactory(config);
+  if (config.browser.cdpEndpoint)
+    return new CdpContextFactory(config);
+  if (config.browser.isolated)
+    return new IsolatedContextFactory(config);
+  return new PersistentContextFactory(config);
+}
+class BaseContextFactory {
+  constructor(name, config) {
+    this._logName = name;
+    this.config = config;
+  }
+  async _obtainBrowser(clientInfo) {
+    if (this._browserPromise)
+      return this._browserPromise;
+    (0, import_log.testDebug)(`obtain browser (${this._logName})`);
+    this._browserPromise = this._doObtainBrowser(clientInfo);
+    void this._browserPromise.then((browser) => {
+      browser.on("disconnected", () => {
+        this._browserPromise = void 0;
+      });
+    }).catch(() => {
+      this._browserPromise = void 0;
+    });
+    return this._browserPromise;
+  }
+  async _doObtainBrowser(clientInfo) {
+    throw new Error("Not implemented");
+  }
+  async createContext(clientInfo) {
+    (0, import_log.testDebug)(`create browser context (${this._logName})`);
+    const browser = await this._obtainBrowser(clientInfo);
+    const browserContext = await this._doCreateContext(browser);
+    await addInitScript(browserContext, this.config.browser.initScript);
+    return {
+      browserContext,
+      close: (afterClose) => this._closeBrowserContext(browserContext, browser, afterClose)
+    };
+  }
+  async _doCreateContext(browser) {
+    throw new Error("Not implemented");
+  }
+  async _closeBrowserContext(browserContext, browser, afterClose) {
+    (0, import_log.testDebug)(`close browser context (${this._logName})`);
+    if (browser.contexts().length === 1)
+      this._browserPromise = void 0;
+    await browserContext.close().catch(import_log.logUnhandledError);
+    await afterClose();
+    if (browser.contexts().length === 0) {
+      (0, import_log.testDebug)(`close browser (${this._logName})`);
+      await browser.close().catch(import_log.logUnhandledError);
+    }
+  }
+}
+class IsolatedContextFactory extends BaseContextFactory {
+  constructor(config) {
+    super("isolated", config);
+  }
+  async _doObtainBrowser(clientInfo) {
+    await injectCdpPort(this.config.browser);
+    const browserType = playwright[this.config.browser.browserName];
+    const tracesDir = await computeTracesDir(this.config, clientInfo);
+    if (tracesDir && this.config.saveTrace)
+      await startTraceServer(this.config, tracesDir);
+    return browserType.launch({
+      tracesDir,
+      ...this.config.browser.launchOptions,
+      handleSIGINT: false,
+      handleSIGTERM: false
+    }).catch((error) => {
+      if (error.message.includes("Executable doesn't exist"))
+        throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+      throw error;
+    });
+  }
+  async _doCreateContext(browser) {
+    return browser.newContext(this.config.browser.contextOptions);
+  }
+}
+class CdpContextFactory extends BaseContextFactory {
+  constructor(config) {
+    super("cdp", config);
+  }
+  async _doObtainBrowser() {
+    return playwright.chromium.connectOverCDP(this.config.browser.cdpEndpoint, { headers: this.config.browser.cdpHeaders });
+  }
+  async _doCreateContext(browser) {
+    return this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
+  }
+}
+class RemoteContextFactory extends BaseContextFactory {
+  constructor(config) {
+    super("remote", config);
+  }
+  async _doObtainBrowser() {
+    const url = new URL(this.config.browser.remoteEndpoint);
+    url.searchParams.set("browser", this.config.browser.browserName);
+    if (this.config.browser.launchOptions)
+      url.searchParams.set("launch-options", JSON.stringify(this.config.browser.launchOptions));
+    return playwright[this.config.browser.browserName].connect(String(url));
+  }
+  async _doCreateContext(browser) {
+    return browser.newContext();
+  }
+}
+class PersistentContextFactory {
+  constructor(config) {
+    this.name = "persistent";
+    this.description = "Create a new persistent browser context";
+    this._userDataDirs = /* @__PURE__ */ new Set();
+    this.config = config;
+  }
+  async createContext(clientInfo) {
+    await injectCdpPort(this.config.browser);
+    (0, import_log.testDebug)("create browser context (persistent)");
+    const userDataDir = this.config.browser.userDataDir ?? await this._createUserDataDir(clientInfo);
+    const tracesDir = await computeTracesDir(this.config, clientInfo);
+    if (tracesDir && this.config.saveTrace)
+      await startTraceServer(this.config, tracesDir);
+    this._userDataDirs.add(userDataDir);
+    (0, import_log.testDebug)("lock user data dir", userDataDir);
+    const browserType = playwright[this.config.browser.browserName];
+    for (let i = 0; i < 5; i++) {
+      const launchOptions = {
+        tracesDir,
+        ...this.config.browser.launchOptions,
+        ...this.config.browser.contextOptions,
+        handleSIGINT: false,
+        handleSIGTERM: false,
+        ignoreDefaultArgs: [
+          "--disable-extensions"
+        ],
+        assistantMode: true
+      };
+      try {
+        const browserContext = await browserType.launchPersistentContext(userDataDir, launchOptions);
+        await addInitScript(browserContext, this.config.browser.initScript);
+        const close = (afterClose) => this._closeBrowserContext(browserContext, userDataDir, afterClose);
+        return { browserContext, close };
+      } catch (error) {
+        if (error.message.includes("Executable doesn't exist"))
+          throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+        if (error.message.includes("ProcessSingleton") || error.message.includes("Invalid URL")) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Browser is already in use for ${userDataDir}, use --isolated to run multiple instances of the same browser`);
+  }
+  async _closeBrowserContext(browserContext, userDataDir, afterClose) {
+    (0, import_log.testDebug)("close browser context (persistent)");
+    (0, import_log.testDebug)("release user data dir", userDataDir);
+    await browserContext.close().catch(() => {
+    });
+    await afterClose();
+    this._userDataDirs.delete(userDataDir);
+    (0, import_log.testDebug)("close browser context complete (persistent)");
+  }
+  async _createUserDataDir(clientInfo) {
+    const dir = process.env.PWMCP_PROFILES_DIR_FOR_TEST ?? import_registry.registryDirectory;
+    const browserToken = this.config.browser.launchOptions?.channel ?? this.config.browser?.browserName;
+    const rootPath = (0, import_server2.firstRootPath)(clientInfo);
+    const rootPathToken = rootPath ? `-${createHash(rootPath)}` : "";
+    const result = import_path.default.join(dir, `mcp-${browserToken}${rootPathToken}`);
+    await import_fs.default.promises.mkdir(result, { recursive: true });
+    return result;
+  }
+}
+async function injectCdpPort(browserConfig) {
+  if (browserConfig.browserName === "chromium")
+    browserConfig.launchOptions.cdpPort = await findFreePort();
+}
+async function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = import_net.default.createServer();
+    server.listen(0, () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+async function startTraceServer(config, tracesDir) {
+  if (!config.saveTrace)
+    return;
+  const server = await (0, import_server.startTraceViewerServer)();
+  const urlPrefix = server.urlPrefix("human-readable");
+  const url = urlPrefix + "/trace/index.html?trace=" + tracesDir + "/trace.json";
+  console.error("\nTrace viewer listening on " + url);
+}
+function createHash(data) {
+  return import_crypto.default.createHash("sha256").update(data).digest("hex").slice(0, 7);
+}
+async function addInitScript(browserContext, initScript) {
+  for (const scriptPath of initScript ?? [])
+    await browserContext.addInitScript({ path: import_path.default.resolve(scriptPath) });
+}
+class SharedContextFactory {
+  static create(config) {
+    if (SharedContextFactory._instance)
+      throw new Error("SharedContextFactory already exists");
+    const baseConfig = { ...config, sharedBrowserContext: false };
+    const baseFactory = contextFactory(baseConfig);
+    SharedContextFactory._instance = new SharedContextFactory(baseFactory);
+    return SharedContextFactory._instance;
+  }
+  constructor(baseFactory) {
+    this._baseFactory = baseFactory;
+  }
+  async createContext(clientInfo, abortSignal, toolName) {
+    if (!this._contextPromise) {
+      (0, import_log.testDebug)("create shared browser context");
+      this._contextPromise = this._baseFactory.createContext(clientInfo, abortSignal, toolName);
+    }
+    const { browserContext } = await this._contextPromise;
+    (0, import_log.testDebug)(`shared context client connected`);
+    return {
+      browserContext,
+      close: async () => {
+        (0, import_log.testDebug)(`shared context client disconnected`);
+      }
+    };
+  }
+  static async dispose() {
+    await SharedContextFactory._instance?._dispose();
+  }
+  async _dispose() {
+    const contextPromise = this._contextPromise;
+    this._contextPromise = void 0;
+    if (!contextPromise)
+      return;
+    const { close } = await contextPromise;
+    await close(async () => {
+    });
+  }
+}
+async function computeTracesDir(config, clientInfo) {
+  if (!config.saveTrace && !config.capabilities?.includes("tracing"))
+    return;
+  return await (0, import_config.outputFile)(config, clientInfo, `traces`, { origin: "code", reason: "Collecting trace" });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SharedContextFactory,
+  contextFactory
+});

package/lib/mcp/browser/browserServerBackend.js

@@ -0,0 +1,76 @@
+"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 browserServerBackend_exports = {};
+__export(browserServerBackend_exports, {
+  BrowserServerBackend: () => BrowserServerBackend
+});
+module.exports = __toCommonJS(browserServerBackend_exports);
+var import_context = require("./context");
+var import_log = require("../log");
+var import_response = require("./response");
+var import_sessionLog = require("./sessionLog");
+var import_tools = require("./tools");
+var import_tool = require("../sdk/tool");
+class BrowserServerBackend {
+  constructor(config, factory) {
+    this._config = config;
+    this._browserContextFactory = factory;
+    this._tools = (0, import_tools.filteredTools)(config);
+  }
+  async initialize(server, clientInfo) {
+    this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, clientInfo) : void 0;
+    this._context = new import_context.Context({
+      config: this._config,
+      browserContextFactory: this._browserContextFactory,
+      sessionLog: this._sessionLog,
+      clientInfo
+    });
+  }
+  async listTools() {
+    return this._tools.map((tool) => (0, import_tool.toMcpTool)(tool.schema));
+  }
+  async callTool(name, rawArguments) {
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool)
+      throw new Error(`Tool "${name}" not found`);
+    const parsedArguments = tool.schema.inputSchema.parse(rawArguments || {});
+    const context = this._context;
+    const response = new import_response.Response(context, name, parsedArguments);
+    response.logBegin();
+    context.setRunningTool(name);
+    try {
+      await tool.handle(context, parsedArguments, response);
+      await response.finish();
+      this._sessionLog?.logResponse(response);
+    } catch (error) {
+      response.addError(String(error));
+    } finally {
+      context.setRunningTool(void 0);
+    }
+    response.logEnd();
+    return response.serialize();
+  }
+  serverClosed() {
+    void this._context?.dispose().catch(import_log.logUnhandledError);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserServerBackend
+});

package/lib/mcp/browser/codegen.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 codegen_exports = {};
+__export(codegen_exports, {
+  escapeWithQuotes: () => escapeWithQuotes,
+  formatObject: () => formatObject,
+  quote: () => quote
+});
+module.exports = __toCommonJS(codegen_exports);
+function escapeWithQuotes(text, char = "'") {
+  const stringified = JSON.stringify(text);
+  const escapedText = stringified.substring(1, stringified.length - 1).replace(/\\"/g, '"');
+  if (char === "'")
+    return char + escapedText.replace(/[']/g, "\\'") + char;
+  if (char === '"')
+    return char + escapedText.replace(/["]/g, '\\"') + char;
+  if (char === "`")
+    return char + escapedText.replace(/[`]/g, "\\`") + char;
+  throw new Error("Invalid escape char");
+}
+function quote(text) {
+  return escapeWithQuotes(text, "'");
+}
+function formatObject(value, indent = "  ", mode = "multiline") {
+  if (typeof value === "string")
+    return quote(value);
+  if (Array.isArray(value))
+    return `[${value.map((o) => formatObject(o)).join(", ")}]`;
+  if (typeof value === "object") {
+    const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
+    if (!keys.length)
+      return "{}";
+    const tokens = [];
+    for (const key of keys)
+      tokens.push(`${key}: ${formatObject(value[key])}`);
+    if (mode === "multiline")
+      return `{
+${tokens.join(`,
+${indent}`)}
+}`;
+    return `{ ${tokens.join(", ")} }`;
+  }
+  return String(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeWithQuotes,
+  formatObject,
+  quote
+});