@smoothdeploy/playwright 1.57.1 → 1.58.1-beta-1770383926000

package/lib/mcp/sdk/exports.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/exports.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\nexport * from './inProcessTransport';\nexport * from './proxyBackend';\nexport * from './server';\nexport * from './tool';\nexport * from './http';\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAgBA,4BAAc,iCAhBd;AAiBA,4BAAc,2BAjBd;AAkBA,4BAAc,qBAlBd;AAmBA,4BAAc,mBAnBd;AAoBA,4BAAc,mBApBd;",
+  "names": []
+}

package/lib/mcp/sdk/http.js

@@ -28,51 +28,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var http_exports = {};
 __export(http_exports, {
-  httpAddressToString: () => httpAddressToString,
-  installHttpTransport: () => installHttpTransport,
-  startHttpServer: () => startHttpServer
+  addressToString: () => addressToString,
+  startMcpHttpServer: () => startMcpHttpServer
 });
 module.exports = __toCommonJS(http_exports);
 var import_assert = __toESM(require("assert"));
-var import_http = __toESM(require("http"));
 var import_crypto = __toESM(require("crypto"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var mcpBundle = __toESM(require("./bundle"));
+var mcpBundle = __toESM(require("playwright-core/lib/mcpBundle"));
+var import_utils = require("playwright-core/lib/utils");
 var mcpServer = __toESM(require("./server"));
 const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
-async function startHttpServer(config, abortSignal) {
-  const { host, port } = config;
-  const httpServer = import_http.default.createServer();
-  decorateServer(httpServer);
-  await new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    abortSignal?.addEventListener("abort", () => {
-      httpServer.close();
-      reject(new Error("Aborted"));
-    });
-    httpServer.listen(port, host, () => {
-      resolve();
-      httpServer.removeListener("error", reject);
-    });
-  });
-  return httpServer;
+async function startMcpHttpServer(config, serverBackendFactory, allowedHosts) {
+  const httpServer = (0, import_utils.createHttpServer)();
+  await (0, import_utils.startHttpServer)(httpServer, config);
+  return await installHttpTransport(httpServer, serverBackendFactory, allowedHosts);
 }
-function httpAddressToString(address) {
+function addressToString(address, options) {
   (0, import_assert.default)(address, "Could not bind server socket");
   if (typeof address === "string")
-    return address;
-  const resolvedPort = address.port;
-  let resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
-  if (resolvedHost === "0.0.0.0" || resolvedHost === "[::]")
-    resolvedHost = "localhost";
-  return `http://${resolvedHost}:${resolvedPort}`;
+    throw new Error("Unexpected address type: " + address);
+  let host = address.family === "IPv4" ? address.address : `[${address.address}]`;
+  if (options.normalizeLoopback && (host === "0.0.0.0" || host === "[::]" || host === "[::1]" || host === "127.0.0.1"))
+    host = "localhost";
+  return `${options.protocol}://${host}:${address.port}`;
 }
-async function installHttpTransport(httpServer, serverBackendFactory, unguessableUrl, allowedHosts) {
-  const url = httpAddressToString(httpServer.address());
+async function installHttpTransport(httpServer, serverBackendFactory, allowedHosts) {
+  const url = addressToString(httpServer.address(), { protocol: "http", normalizeLoopback: true });
   const host = new URL(url).host;
   allowedHosts = (allowedHosts || [host]).map((h) => h.toLowerCase());
   const allowAnyHost = allowedHosts.includes("*");
-  const pathPrefix = unguessableUrl ? `/${import_crypto.default.randomUUID()}` : "";
   const sseSessions = /* @__PURE__ */ new Map();
   const streamableSessions = /* @__PURE__ */ new Map();
   httpServer.on("request", async (req, res) => {
@@ -87,12 +72,7 @@ async function installHttpTransport(httpServer, serverBackendFactory, unguessabl
         return res.end("Access is only allowed at " + allowedHosts.join(", "));
       }
     }
-    if (!req.url?.startsWith(pathPrefix)) {
-      res.statusCode = 404;
-      return res.end("Not found");
-    }
-    const path = req.url?.slice(pathPrefix.length);
-    const url2 = new URL(`http://localhost${path}`);
+    const url2 = new URL(`http://localhost${req.url}`);
     if (url2.pathname === "/killkillkill" && req.method === "GET") {
       res.statusCode = 200;
       res.end("Killing process");
@@ -104,7 +84,7 @@ async function installHttpTransport(httpServer, serverBackendFactory, unguessabl
     else
       await handleStreamable(serverBackendFactory, req, res, streamableSessions);
   });
-  return `${url}${pathPrefix}`;
+  return url;
 }
 async function handleSSE(serverBackendFactory, req, res, url, sessions) {
   if (req.method === "POST") {
@@ -165,23 +145,8 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
   res.statusCode = 400;
   res.end("Invalid request");
 }
-function decorateServer(server) {
-  const sockets = /* @__PURE__ */ new Set();
-  server.on("connection", (socket) => {
-    sockets.add(socket);
-    socket.once("close", () => sockets.delete(socket));
-  });
-  const close = server.close;
-  server.close = (callback) => {
-    for (const socket of sockets)
-      socket.destroy();
-    sockets.clear();
-    return close.call(server, callback);
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  httpAddressToString,
-  installHttpTransport,
-  startHttpServer
+  addressToString,
+  startMcpHttpServer
 });

package/lib/mcp/sdk/http.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/http.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 assert from 'assert';\nimport net from 'net';\nimport http from 'http';\nimport crypto from 'crypto';\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\n\nimport * as mcpBundle from './bundle';\nimport * as mcpServer from './server';\n\nimport type { ServerBackendFactory } from './server';\nimport type { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';\nimport type { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';\n\nconst testDebug = debug('pw:mcp:test');\n\nexport async function startHttpServer(config: { host?: string, port?: number }, abortSignal?: AbortSignal): Promise<http.Server> {\n  const { host, port } = config;\n  const httpServer = http.createServer();\n  decorateServer(httpServer);\n  await new Promise<void>((resolve, reject) => {\n    httpServer.on('error', reject);\n    abortSignal?.addEventListener('abort', () => {\n      httpServer.close();\n      reject(new Error('Aborted'));\n    });\n    httpServer.listen(port, host, () => {\n      resolve();\n      httpServer.removeListener('error', reject);\n    });\n  });\n  return httpServer;\n}\n\nexport function httpAddressToString(address: string | net.AddressInfo | null): string {\n  assert(address, 'Could not bind server socket');\n  if (typeof address === 'string')\n    return address;\n  const resolvedPort = address.port;\n  let resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;\n  if (resolvedHost === '0.0.0.0' || resolvedHost === '[::]')\n    resolvedHost = 'localhost';\n  return `http://${resolvedHost}:${resolvedPort}`;\n}\n\nexport async function installHttpTransport(httpServer: http.Server, serverBackendFactory: ServerBackendFactory, unguessableUrl: boolean, allowedHosts?: string[]) {\n  const url = httpAddressToString(httpServer.address());\n  const host = new URL(url).host;\n  allowedHosts = (allowedHosts || [host]).map(h => h.toLowerCase());\n  const allowAnyHost = allowedHosts.includes('*');\n  const pathPrefix = unguessableUrl ? `/${crypto.randomUUID()}` : '';\n\n  const sseSessions = new Map();\n  const streamableSessions = new Map();\n  httpServer.on('request', async (req, res) => {\n    if (!allowAnyHost) {\n      const host = req.headers.host?.toLowerCase();\n      if (!host) {\n        res.statusCode = 400;\n        return res.end('Missing host');\n      }\n\n      // Prevent DNS evil.com -> localhost rebind.\n      if (!allowedHosts.includes(host)) {\n        // Access from the browser is forbidden.\n        res.statusCode = 403;\n        return res.end('Access is only allowed at ' + allowedHosts.join(', '));\n      }\n    }\n\n    if (!req.url?.startsWith(pathPrefix)) {\n      res.statusCode = 404;\n      return res.end('Not found');\n    }\n\n    const path = req.url?.slice(pathPrefix.length);\n    const url = new URL(`http://localhost${path}`);\n    if (url.pathname === '/killkillkill' && req.method === 'GET') {\n      res.statusCode = 200;\n      res.end('Killing process');\n      // Simulate Ctrl+C in a way that works on Windows too.\n      process.emit('SIGINT');\n      return;\n    }\n    if (url.pathname.startsWith('/sse'))\n      await handleSSE(serverBackendFactory, req, res, url, sseSessions);\n    else\n      await handleStreamable(serverBackendFactory, req, res, streamableSessions);\n  });\n\n  return `${url}${pathPrefix}`;\n}\n\nasync function handleSSE(serverBackendFactory: ServerBackendFactory, req: http.IncomingMessage, res: http.ServerResponse, url: URL, sessions: Map<string, SSEServerTransport>) {\n  if (req.method === 'POST') {\n    const sessionId = url.searchParams.get('sessionId');\n    if (!sessionId) {\n      res.statusCode = 400;\n      return res.end('Missing sessionId');\n    }\n\n    const transport = sessions.get(sessionId);\n    if (!transport) {\n      res.statusCode = 404;\n      return res.end('Session not found');\n    }\n\n    return await transport.handlePostMessage(req, res);\n  } else if (req.method === 'GET') {\n    const transport = new mcpBundle.SSEServerTransport('/sse', res);\n    sessions.set(transport.sessionId, transport);\n    testDebug(`create SSE session: ${transport.sessionId}`);\n    await mcpServer.connect(serverBackendFactory, transport, false);\n    res.on('close', () => {\n      testDebug(`delete SSE session: ${transport.sessionId}`);\n      sessions.delete(transport.sessionId);\n    });\n    return;\n  }\n\n  res.statusCode = 405;\n  res.end('Method not allowed');\n}\n\nasync function handleStreamable(serverBackendFactory: ServerBackendFactory, req: http.IncomingMessage, res: http.ServerResponse, sessions: Map<string, StreamableHTTPServerTransport>) {\n  const sessionId = req.headers['mcp-session-id'] as string | undefined;\n  if (sessionId) {\n    const transport = sessions.get(sessionId);\n    if (!transport) {\n      res.statusCode = 404;\n      res.end('Session not found');\n      return;\n    }\n    return await transport.handleRequest(req, res);\n  }\n\n  if (req.method === 'POST') {\n    const transport = new mcpBundle.StreamableHTTPServerTransport({\n      sessionIdGenerator: () => crypto.randomUUID(),\n      onsessioninitialized: async sessionId => {\n        testDebug(`create http session: ${transport.sessionId}`);\n        await mcpServer.connect(serverBackendFactory, transport, true);\n        sessions.set(sessionId, transport);\n      }\n    });\n\n    transport.onclose = () => {\n      if (!transport.sessionId)\n        return;\n      sessions.delete(transport.sessionId);\n      testDebug(`delete http session: ${transport.sessionId}`);\n    };\n\n    await transport.handleRequest(req, res);\n    return;\n  }\n\n  res.statusCode = 400;\n  res.end('Invalid request');\n}\n\nfunction decorateServer(server: net.Server) {\n  const sockets = new Set<net.Socket>();\n  server.on('connection', socket => {\n    sockets.add(socket);\n    socket.once('close', () => sockets.delete(socket));\n  });\n\n  const close = server.close;\n  server.close = (callback?: (err?: Error) => void) => {\n    for (const socket of sockets)\n      socket.destroy();\n    sockets.clear();\n    return close.call(server, callback);\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["http", "assert", "crypto", "host", "url", "sessionId"]
+}

package/lib/mcp/sdk/inProcessTransport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/inProcessTransport.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 type { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { JSONRPCMessage, MessageExtraInfo } from '@modelcontextprotocol/sdk/types.js';\n\nexport class InProcessTransport implements Transport {\n  private _server: Server;\n  private _serverTransport: InProcessServerTransport;\n  private _connected: boolean = false;\n\n  constructor(server: Server) {\n    this._server = server;\n    this._serverTransport = new InProcessServerTransport(this);\n  }\n\n  async start(): Promise<void> {\n    if (this._connected)\n      throw new Error('InprocessTransport already started!');\n\n    await this._server.connect(this._serverTransport);\n    this._connected = true;\n  }\n\n  async send(message: JSONRPCMessage, options?: TransportSendOptions): Promise<void> {\n    if (!this._connected)\n      throw new Error('Transport not connected');\n\n\n    this._serverTransport._receiveFromClient(message);\n  }\n\n  async close(): Promise<void> {\n    if (this._connected) {\n      this._connected = false;\n      this.onclose?.();\n      this._serverTransport.onclose?.();\n    }\n  }\n\n  onclose?: (() => void) | undefined;\n  onerror?: ((error: Error) => void) | undefined;\n  onmessage?: ((message: JSONRPCMessage, extra?: MessageExtraInfo) => void) | undefined;\n  sessionId?: string | undefined;\n  setProtocolVersion?: ((version: string) => void) | undefined;\n\n  _receiveFromServer(message: JSONRPCMessage, extra?: MessageExtraInfo): void {\n    this.onmessage?.(message, extra);\n  }\n}\n\nclass InProcessServerTransport implements Transport {\n  private _clientTransport: InProcessTransport;\n\n  constructor(clientTransport: InProcessTransport) {\n    this._clientTransport = clientTransport;\n  }\n\n  async start(): Promise<void> {\n  }\n\n  async send(message: JSONRPCMessage, options?: TransportSendOptions): Promise<void> {\n    this._clientTransport._receiveFromServer(message);\n  }\n\n  async close(): Promise<void> {\n    this.onclose?.();\n  }\n\n  onclose?: (() => void) | undefined;\n  onerror?: ((error: Error) => void) | undefined;\n  onmessage?: ((message: JSONRPCMessage, extra?: MessageExtraInfo) => void) | undefined;\n  sessionId?: string | undefined;\n  setProtocolVersion?: ((version: string) => void) | undefined;\n  _receiveFromClient(message: JSONRPCMessage): void {\n    this.onmessage?.(message);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,MAAM,mBAAwC;AAAA,EAKnD,YAAY,QAAgB;AAF5B,SAAQ,aAAsB;AAG5B,SAAK,UAAU;AACf,SAAK,mBAAmB,IAAI,yBAAyB,IAAI;AAAA,EAC3D;AAAA,EAEA,MAAM,QAAuB;AAC3B,QAAI,KAAK;AACP,YAAM,IAAI,MAAM,qCAAqC;AAEvD,UAAM,KAAK,QAAQ,QAAQ,KAAK,gBAAgB;AAChD,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,MAAM,KAAK,SAAyB,SAA+C;AACjF,QAAI,CAAC,KAAK;AACR,YAAM,IAAI,MAAM,yBAAyB;AAG3C,SAAK,iBAAiB,mBAAmB,OAAO;AAAA,EAClD;AAAA,EAEA,MAAM,QAAuB;AAC3B,QAAI,KAAK,YAAY;AACnB,WAAK,aAAa;AAClB,WAAK,UAAU;AACf,WAAK,iBAAiB,UAAU;AAAA,IAClC;AAAA,EACF;AAAA,EAQA,mBAAmB,SAAyB,OAAgC;AAC1E,SAAK,YAAY,SAAS,KAAK;AAAA,EACjC;AACF;AAEA,MAAM,yBAA8C;AAAA,EAGlD,YAAY,iBAAqC;AAC/C,SAAK,mBAAmB;AAAA,EAC1B;AAAA,EAEA,MAAM,QAAuB;AAAA,EAC7B;AAAA,EAEA,MAAM,KAAK,SAAyB,SAA+C;AACjF,SAAK,iBAAiB,mBAAmB,OAAO;AAAA,EAClD;AAAA,EAEA,MAAM,QAAuB;AAC3B,SAAK,UAAU;AAAA,EACjB;AAAA,EAOA,mBAAmB,SAA+B;AAChD,SAAK,YAAY,OAAO;AAAA,EAC1B;AACF;",
+  "names": []
+}

package/lib/mcp/sdk/proxyBackend.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/proxyBackend.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 { debug } from 'playwright-core/lib/utilsBundle';\n\nimport * as mcpBundle from './bundle';\n\nimport type { ServerBackend, ClientInfo } from './server';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { Tool, CallToolResult, CallToolRequest } from '@modelcontextprotocol/sdk/types.js';\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js';\n\nexport type MCPProvider = {\n  name: string;\n  description: string;\n  connect(): Promise<Transport>;\n};\n\nconst errorsDebug = debug('pw:mcp:errors');\nconst { z, zodToJsonSchema } = mcpBundle;\n\nexport class ProxyBackend implements ServerBackend {\n  private _mcpProviders: MCPProvider[];\n  private _currentClient: Client | undefined;\n  private _contextSwitchTool: Tool;\n  private _clientInfo: ClientInfo | undefined;\n\n  constructor(mcpProviders: MCPProvider[]) {\n    this._mcpProviders = mcpProviders;\n    this._contextSwitchTool = this._defineContextSwitchTool();\n  }\n\n  async initialize(clientInfo: ClientInfo): Promise<void> {\n    this._clientInfo = clientInfo;\n  }\n\n  async listTools(): Promise<Tool[]> {\n    const currentClient = await this._ensureCurrentClient();\n    const response = await currentClient.listTools();\n    if (this._mcpProviders.length === 1)\n      return response.tools;\n    return [\n      ...response.tools,\n      this._contextSwitchTool,\n    ];\n  }\n\n  async callTool(name: string, args: CallToolRequest['params']['arguments']): Promise<CallToolResult> {\n    if (name === this._contextSwitchTool.name)\n      return this._callContextSwitchTool(args);\n    const currentClient = await this._ensureCurrentClient();\n    return await currentClient.callTool({\n      name,\n      arguments: args,\n    }) as CallToolResult;\n  }\n\n  serverClosed?(): void {\n    void this._currentClient?.close().catch(errorsDebug);\n  }\n\n  private async _callContextSwitchTool(params: any): Promise<CallToolResult> {\n    try {\n      const factory = this._mcpProviders.find(factory => factory.name === params.name);\n      if (!factory)\n        throw new Error('Unknown connection method: ' + params.name);\n\n      await this._setCurrentClient(factory);\n      return {\n        content: [{ type: 'text', text: '### Result\\nSuccessfully changed connection method.\\n' }],\n      };\n    } catch (error) {\n      return {\n        content: [{ type: 'text', text: `### Result\\nError: ${error}\\n` }],\n        isError: true,\n      };\n    }\n  }\n\n  private _defineContextSwitchTool(): Tool {\n    return {\n      name: 'browser_connect',\n      description: [\n        'Connect to a browser using one of the available methods:',\n        ...this._mcpProviders.map(factory => `- \"${factory.name}\": ${factory.description}`),\n      ].join('\\n'),\n      inputSchema: zodToJsonSchema(z.object({\n        name: z.enum(this._mcpProviders.map(factory => factory.name) as [string, ...string[]]).default(this._mcpProviders[0].name).describe('The method to use to connect to the browser'),\n      }), { strictUnions: true }) as Tool['inputSchema'],\n      annotations: {\n        title: 'Connect to a browser context',\n        readOnlyHint: true,\n        openWorldHint: false,\n      },\n    };\n  }\n\n  private async _ensureCurrentClient(): Promise<Client> {\n    if (this._currentClient)\n      return this._currentClient;\n    return await this._setCurrentClient(this._mcpProviders[0]);\n  }\n\n  private async _setCurrentClient(factory: MCPProvider) {\n    await this._currentClient?.close();\n    this._currentClient = undefined;\n\n    const client = new mcpBundle.Client({ name: 'Playwright MCP Proxy', version: '0.0.0' });\n    client.registerCapabilities({\n      roots: {\n        listRoots: true,\n      },\n    });\n    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));\n    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));\n\n    const transport = await factory.connect();\n    await client.connect(transport);\n    this._currentClient = client;\n    return client;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,yBAAsB;AAEtB,gBAA2B;AAa3B,MAAM,kBAAc,0BAAM,eAAe;AACzC,MAAM,EAAE,GAAG,gBAAgB,IAAI;AAExB,MAAM,aAAsC;AAAA,EAMjD,YAAY,cAA6B;AACvC,SAAK,gBAAgB;AACrB,SAAK,qBAAqB,KAAK,yBAAyB;AAAA,EAC1D;AAAA,EAEA,MAAM,WAAW,YAAuC;AACtD,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,MAAM,YAA6B;AACjC,UAAM,gBAAgB,MAAM,KAAK,qBAAqB;AACtD,UAAM,WAAW,MAAM,cAAc,UAAU;AAC/C,QAAI,KAAK,cAAc,WAAW;AAChC,aAAO,SAAS;AAClB,WAAO;AAAA,MACL,GAAG,SAAS;AAAA,MACZ,KAAK;AAAA,IACP;AAAA,EACF;AAAA,EAEA,MAAM,SAAS,MAAc,MAAuE;AAClG,QAAI,SAAS,KAAK,mBAAmB;AACnC,aAAO,KAAK,uBAAuB,IAAI;AACzC,UAAM,gBAAgB,MAAM,KAAK,qBAAqB;AACtD,WAAO,MAAM,cAAc,SAAS;AAAA,MAClC;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AAAA,EAEA,eAAsB;AACpB,SAAK,KAAK,gBAAgB,MAAM,EAAE,MAAM,WAAW;AAAA,EACrD;AAAA,EAEA,MAAc,uBAAuB,QAAsC;AACzE,QAAI;AACF,YAAM,UAAU,KAAK,cAAc,KAAK,CAAAA,aAAWA,SAAQ,SAAS,OAAO,IAAI;AAC/E,UAAI,CAAC;AACH,cAAM,IAAI,MAAM,gCAAgC,OAAO,IAAI;AAE7D,YAAM,KAAK,kBAAkB,OAAO;AACpC,aAAO;AAAA,QACL,SAAS,CAAC,EAAE,MAAM,QAAQ,MAAM,wDAAwD,CAAC;AAAA,MAC3F;AAAA,IACF,SAAS,OAAO;AACd,aAAO;AAAA,QACL,SAAS,CAAC,EAAE,MAAM,QAAQ,MAAM;AAAA,SAAsB,KAAK;AAAA,EAAK,CAAC;AAAA,QACjE,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,2BAAiC;AACvC,WAAO;AAAA,MACL,MAAM;AAAA,MACN,aAAa;AAAA,QACX;AAAA,QACA,GAAG,KAAK,cAAc,IAAI,aAAW,MAAM,QAAQ,IAAI,MAAM,QAAQ,WAAW,EAAE;AAAA,MACpF,EAAE,KAAK,IAAI;AAAA,MACX,aAAa,gBAAgB,EAAE,OAAO;AAAA,QACpC,MAAM,EAAE,KAAK,KAAK,cAAc,IAAI,aAAW,QAAQ,IAAI,CAA0B,EAAE,QAAQ,KAAK,cAAc,CAAC,EAAE,IAAI,EAAE,SAAS,6CAA6C;AAAA,MACnL,CAAC,GAAG,EAAE,cAAc,KAAK,CAAC;AAAA,MAC1B,aAAa;AAAA,QACX,OAAO;AAAA,QACP,cAAc;AAAA,QACd,eAAe;AAAA,MACjB;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAc,uBAAwC;AACpD,QAAI,KAAK;AACP,aAAO,KAAK;AACd,WAAO,MAAM,KAAK,kBAAkB,KAAK,cAAc,CAAC,CAAC;AAAA,EAC3D;AAAA,EAEA,MAAc,kBAAkB,SAAsB;AACpD,UAAM,KAAK,gBAAgB,MAAM;AACjC,SAAK,iBAAiB;AAEtB,UAAM,SAAS,IAAI,UAAU,OAAO,EAAE,MAAM,wBAAwB,SAAS,QAAQ,CAAC;AACtF,WAAO,qBAAqB;AAAA,MAC1B,OAAO;AAAA,QACL,WAAW;AAAA,MACb;AAAA,IACF,CAAC;AACD,WAAO,kBAAkB,UAAU,wBAAwB,OAAO,EAAE,OAAO,KAAK,aAAa,SAAS,CAAC,EAAE,EAAE;AAC3G,WAAO,kBAAkB,UAAU,mBAAmB,OAAO,CAAC,EAAE;AAEhE,UAAM,YAAY,MAAM,QAAQ,QAAQ;AACxC,UAAM,OAAO,QAAQ,SAAS;AAC9B,SAAK,iBAAiB;AACtB,WAAO;AAAA,EACT;AACF;",
+  "names": ["factory"]
+}

package/lib/mcp/sdk/server.js

@@ -28,16 +28,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
+  allRootPaths: () => allRootPaths,
   connect: () => connect,
   createServer: () => createServer,
   firstRootPath: () => firstRootPath,
   start: () => start,
+  wrapInClient: () => wrapInClient,
   wrapInProcess: () => wrapInProcess
 });
 module.exports = __toCommonJS(server_exports);
 var import_url = require("url");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var mcpBundle = __toESM(require("./bundle"));
+var mcpBundle = __toESM(require("playwright-core/lib/mcpBundle"));
 var import_http = require("./http");
 var import_inProcessTransport = require("./inProcessTransport");
 const serverDebug = (0, import_utilsBundle.debug)("pw:mcp:server");
@@ -46,10 +48,18 @@ async function connect(factory, transport, runHeartbeat) {
   const server = createServer(factory.name, factory.version, factory.create(), runHeartbeat);
   await server.connect(transport);
 }
-async function wrapInProcess(backend) {
+function wrapInProcess(backend) {
   const server = createServer("Internal", "0.0.0", backend, false);
   return new import_inProcessTransport.InProcessTransport(server);
 }
+async function wrapInClient(backend, options) {
+  const server = createServer("Internal", "0.0.0", backend, false);
+  const transport = new import_inProcessTransport.InProcessTransport(server);
+  const client = new mcpBundle.Client({ name: options.name, version: options.version });
+  await client.connect(transport);
+  await client.ping();
+  return client;
+}
 function createServer(name, version, backend, runHeartbeat) {
   const server = new mcpBundle.Server({ name, version }, {
     capabilities: {
@@ -141,8 +151,7 @@ async function start(serverBackendFactory, options) {
     await connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
     return;
   }
-  const httpServer = await (0, import_http.startHttpServer)(options);
-  const url = await (0, import_http.installHttpTransport)(httpServer, serverBackendFactory, false, options.allowedHosts);
+  const url = await (0, import_http.startMcpHttpServer)(options, serverBackendFactory, options.allowedHosts);
   const mcpConfig = { mcpServers: {} };
   mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {
     url: `${url}/mcp`
@@ -167,6 +176,20 @@ function firstRootPath(clientInfo) {
     return void 0;
   }
 }
+function allRootPaths(clientInfo) {
+  const paths = [];
+  for (const root of clientInfo.roots) {
+    try {
+      const url = new URL(root.uri);
+      const path = (0, import_url.fileURLToPath)(url);
+      if (path)
+        paths.push(path);
+    } catch (error) {
+      serverDebug(error);
+    }
+  }
+  return paths;
+}
 function mergeTextParts(result) {
   const content = [];
   const testParts = [];
@@ -190,9 +213,11 @@ function mergeTextParts(result) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  allRootPaths,
   connect,
   createServer,
   firstRootPath,
   start,
+  wrapInClient,
   wrapInProcess
 });

package/lib/mcp/sdk/server.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/server.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 { fileURLToPath } from 'url';\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\n\nimport * as mcpBundle from './bundle';\nimport { installHttpTransport, startHttpServer } from './http';\nimport { InProcessTransport } from './inProcessTransport';\n\nimport type { Tool, CallToolResult, CallToolRequest, Root } from '@modelcontextprotocol/sdk/types.js';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nexport type { Server } from '@modelcontextprotocol/sdk/server/index.js';\nexport type { Tool, CallToolResult, CallToolRequest, Root } from '@modelcontextprotocol/sdk/types.js';\nimport type { Server } from '@modelcontextprotocol/sdk/server/index.js';\n\nconst serverDebug = debug('pw:mcp:server');\nconst serverDebugResponse = debug('pw:mcp:server:response');\n\nexport type ClientInfo = {\n  name: string;\n  version: string;\n  roots: Root[];\n  timestamp: number;\n};\n\nexport type ProgressParams = { message?: string, progress?: number, total?: number };\nexport type ProgressCallback = (params: ProgressParams) => void;\n\nexport interface ServerBackend {\n  initialize?(clientInfo: ClientInfo): Promise<void>;\n  listTools(): Promise<Tool[]>;\n  callTool(name: string, args: CallToolRequest['params']['arguments'], progress: ProgressCallback): Promise<CallToolResult>;\n  serverClosed?(server: Server): void;\n}\n\nexport type ServerBackendFactory = {\n  name: string;\n  nameInConfig: string;\n  version: string;\n  create: () => ServerBackend;\n};\n\nexport async function connect(factory: ServerBackendFactory, transport: Transport, runHeartbeat: boolean) {\n  const server = createServer(factory.name, factory.version, factory.create(), runHeartbeat);\n  await server.connect(transport);\n}\n\nexport async function wrapInProcess(backend: ServerBackend): Promise<Transport> {\n  const server = createServer('Internal', '0.0.0', backend, false);\n  return new InProcessTransport(server);\n}\n\nexport function createServer(name: string, version: string, backend: ServerBackend, runHeartbeat: boolean): Server {\n  const server = new mcpBundle.Server({ name, version }, {\n    capabilities: {\n      tools: {},\n    }\n  });\n\n  server.setRequestHandler(mcpBundle.ListToolsRequestSchema, async () => {\n    serverDebug('listTools');\n    const tools = await backend.listTools();\n    return { tools };\n  });\n\n  let initializePromise: Promise<void> | undefined;\n  server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request, extra) => {\n    serverDebug('callTool', request);\n\n    const progressToken = request.params._meta?.progressToken;\n    let progressCounter = 0;\n\n    const progress = progressToken ? (params: ProgressParams) => {\n      extra.sendNotification({\n        method: 'notifications/progress',\n        params: {\n          progressToken,\n          progress: params.progress ?? ++progressCounter,\n          total: params.total,\n          message: params.message,\n        },\n      }).catch(serverDebug);\n    } : () => {};\n\n    try {\n      if (!initializePromise)\n        initializePromise = initializeServer(server, backend, runHeartbeat);\n      await initializePromise;\n      const toolResult = await backend.callTool(request.params.name, request.params.arguments || {}, progress);\n      const mergedResult = mergeTextParts(toolResult);\n      serverDebugResponse('callResult', mergedResult);\n      return mergedResult;\n    } catch (error) {\n      return {\n        content: [{ type: 'text', text: '### Result\\n' + String(error) }],\n        isError: true,\n      };\n    }\n  });\n  addServerListener(server, 'close', () => backend.serverClosed?.(server));\n  return server;\n}\n\nconst initializeServer = async (server: Server, backend: ServerBackend, runHeartbeat: boolean) => {\n  const capabilities = server.getClientCapabilities();\n  let clientRoots: Root[] = [];\n  if (capabilities?.roots) {\n    const { roots } = await server.listRoots().catch(e => {\n      serverDebug(e);\n      return { roots: [] };\n    });\n    clientRoots = roots;\n  }\n\n  const clientInfo: ClientInfo = {\n    name: server.getClientVersion()?.name ?? 'unknown',\n    version: server.getClientVersion()?.version ?? 'unknown',\n    roots: clientRoots,\n    timestamp: Date.now(),\n  };\n\n  await backend.initialize?.(clientInfo);\n  if (runHeartbeat)\n    startHeartbeat(server);\n};\n\nconst startHeartbeat = (server: Server) => {\n  const beat = () => {\n    Promise.race([\n      server.ping(),\n      new Promise((_, reject) => setTimeout(() => reject(new Error('ping timeout')), 5000)),\n    ]).then(() => {\n      setTimeout(beat, 3000);\n    }).catch(() => {\n      void server.close();\n    });\n  };\n\n  beat();\n};\n\nfunction addServerListener(server: Server, event: 'close' | 'initialized', listener: () => void) {\n  const oldListener = server[`on${event}`];\n  server[`on${event}`] = () => {\n    oldListener?.();\n    listener();\n  };\n}\n\nexport async function start(serverBackendFactory: ServerBackendFactory, options: { host?: string; port?: number, allowedHosts?: string[] }) {\n  if (options.port === undefined) {\n    await connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);\n    return;\n  }\n\n  const httpServer = await startHttpServer(options);\n  const url = await installHttpTransport(httpServer, serverBackendFactory, false, options.allowedHosts);\n\n  const mcpConfig: any = { mcpServers: { } };\n  mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {\n    url: `${url}/mcp`\n  };\n  const message = [\n    `Listening on ${url}`,\n    'Put this in your client config:',\n    JSON.stringify(mcpConfig, undefined, 2),\n    'For legacy SSE transport support, you can use the /sse endpoint instead.',\n  ].join('\\n');\n    // eslint-disable-next-line no-console\n  console.error(message);\n}\n\nexport function firstRootPath(clientInfo: ClientInfo): string | undefined {\n  if (clientInfo.roots.length === 0)\n    return undefined;\n  const firstRootUri = clientInfo.roots[0]?.uri;\n  const url = firstRootUri ? new URL(firstRootUri) : undefined;\n  try {\n    return url ? fileURLToPath(url) : undefined;\n  } catch (error) {\n    serverDebug(error);\n    return undefined;\n  }\n}\n\nfunction mergeTextParts(result: CallToolResult): CallToolResult {\n  const content: CallToolResult['content'] = [];\n  const testParts: string[] = [];\n  for (const part of result.content) {\n    if (part.type === 'text') {\n      testParts.push(part.text);\n      continue;\n    }\n    if (testParts.length > 0) {\n      content.push({ type: 'text', text: testParts.join('\\n') });\n      testParts.length = 0;\n    }\n    content.push(part);\n  }\n  if (testParts.length > 0)\n    content.push({ type: 'text', text: testParts.join('\\n') });\n  return {\n    ...result,\n    content,\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/mcp/sdk/tool.js

@@ -22,13 +22,13 @@ __export(tool_exports, {
   toMcpTool: () => toMcpTool
 });
 module.exports = __toCommonJS(tool_exports);
-var import_bundle = require("../sdk/bundle");
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
 function toMcpTool(tool) {
   const readOnly = tool.type === "readOnly" || tool.type === "assertion";
   return {
     name: tool.name,
     description: tool.description,
-    inputSchema: (0, import_bundle.zodToJsonSchema)(tool.inputSchema, { strictUnions: true }),
+    inputSchema: import_mcpBundle.z.toJSONSchema(tool.inputSchema),
     annotations: {
       title: tool.title,
       readOnlyHint: readOnly,

package/lib/mcp/sdk/tool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/tool.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 { zodToJsonSchema } from  '../sdk/bundle';\n\nimport type { z } from 'zod';\nimport type * as mcpServer from './server';\n\nexport type ToolSchema<Input extends z.Schema> = {\n  name: string;\n  title: string;\n  description: string;\n  inputSchema: Input;\n  type: 'input' | 'assertion' | 'action' | 'readOnly';\n};\n\nexport function toMcpTool(tool: ToolSchema<any>): mcpServer.Tool {\n  const readOnly = tool.type === 'readOnly' || tool.type === 'assertion';\n  return {\n    name: tool.name,\n    description: tool.description,\n    inputSchema: zodToJsonSchema(tool.inputSchema, { strictUnions: true }) as mcpServer.Tool['inputSchema'],\n    annotations: {\n      title: tool.title,\n      readOnlyHint: readOnly,\n      destructiveHint: !readOnly,\n      openWorldHint: true,\n    },\n  };\n}\n\nexport function defineToolSchema<Input extends z.Schema>(tool: ToolSchema<Input>): ToolSchema<Input> {\n  return tool;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,oBAAiC;AAa1B,SAAS,UAAU,MAAuC;AAC/D,QAAM,WAAW,KAAK,SAAS,cAAc,KAAK,SAAS;AAC3D,SAAO;AAAA,IACL,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,iBAAa,+BAAgB,KAAK,aAAa,EAAE,cAAc,KAAK,CAAC;AAAA,IACrE,aAAa;AAAA,MACX,OAAO,KAAK;AAAA,MACZ,cAAc;AAAA,MACd,iBAAiB,CAAC;AAAA,MAClB,eAAe;AAAA,IACjB;AAAA,EACF;AACF;AAEO,SAAS,iBAAyC,MAA4C;AACnG,SAAO;AACT;",
+  "names": []
+}

package/lib/mcp/terminal/cli.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 __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 import_child_process = require("child_process");
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_socketConnection = require("./socketConnection");
+const debugCli = (0, import_utilsBundle.debug)("pw:cli");
+const packageJSON = require("../../../package.json");
+async function runCliCommand(sessionName, args) {
+  const session = await connectToDaemon(sessionName);
+  const result = await session.runCliCommand(args);
+  console.log(result);
+  session.dispose();
+}
+async function socketExists(socketPath) {
+  try {
+    const stat = await import_fs.default.promises.stat(socketPath);
+    if (stat?.isSocket())
+      return true;
+  } catch (e) {
+  }
+  return false;
+}
+class SocketSession {
+  constructor(connection) {
+    this._nextMessageId = 1;
+    this._callbacks = /* @__PURE__ */ new Map();
+    this._connection = connection;
+    this._connection.onmessage = (message) => this._onMessage(message);
+    this._connection.onclose = () => this.dispose();
+  }
+  async callTool(name, args) {
+    return this._send(name, args);
+  }
+  async runCliCommand(args) {
+    return await this._send("runCliCommand", { args });
+  }
+  async _send(method, params = {}) {
+    const messageId = this._nextMessageId++;
+    const message = {
+      id: messageId,
+      method,
+      params
+    };
+    await this._connection.send(message);
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(messageId, { resolve, reject });
+    });
+  }
+  dispose() {
+    for (const callback of this._callbacks.values())
+      callback.reject(new Error("Disposed"));
+    this._callbacks.clear();
+    this._connection.close();
+  }
+  _onMessage(object) {
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.error)
+        callback.reject(new Error(object.error));
+      else
+        callback.resolve(object.result);
+    } else if (object.id) {
+      throw new Error(`Unexpected message id: ${object.id}`);
+    } else {
+      throw new Error(`Unexpected message without id: ${JSON.stringify(object)}`);
+    }
+  }
+}
+function localCacheDir() {
+  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);
+}
+function playwrightCacheDir() {
+  return import_path.default.join(localCacheDir(), "ms-playwright");
+}
+function calculateSha1(buffer) {
+  const hash = import_crypto.default.createHash("sha1");
+  hash.update(buffer);
+  return hash.digest("hex");
+}
+function socketDirHash() {
+  return calculateSha1(__dirname);
+}
+function daemonSocketDir() {
+  return import_path.default.resolve(playwrightCacheDir(), "daemon", socketDirHash());
+}
+function daemonSocketPath(sessionName) {
+  const socketName = `${sessionName}.sock`;
+  if (import_os.default.platform() === "win32")
+    return `\\\\.\\pipe\\${socketDirHash()}-${socketName}`;
+  return import_path.default.resolve(daemonSocketDir(), socketName);
+}
+async function connectToDaemon(sessionName) {
+  const socketPath = daemonSocketPath(sessionName);
+  debugCli(`Connecting to daemon at ${socketPath}`);
+  if (await socketExists(socketPath)) {
+    debugCli(`Socket file exists, attempting to connect...`);
+    try {
+      return await connectToSocket(socketPath);
+    } catch (e) {
+      if (import_os.default.platform() !== "win32")
+        await import_fs.default.promises.unlink(socketPath).catch(() => {
+        });
+    }
+  }
+  const cliPath = import_path.default.join(__dirname, "../../../cli.js");
+  debugCli(`Will launch daemon process: ${cliPath}`);
+  const userDataDir = import_path.default.resolve(daemonSocketDir(), `${sessionName}-user-data`);
+  const child = (0, import_child_process.spawn)(process.execPath, [cliPath, "run-mcp-server", `--daemon=${socketPath}`, `--user-data-dir=${userDataDir}`], {
+    detached: true,
+    stdio: "ignore",
+    cwd: process.cwd()
+    // Will be used as root.
+  });
+  child.unref();
+  const maxRetries = 50;
+  const retryDelay = 100;
+  for (let i = 0; i < maxRetries; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try {
+      return await connectToSocket(socketPath);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      debugCli(`Retrying to connect to daemon at ${socketPath} (${i + 1}/${maxRetries})`);
+    }
+  }
+  throw new Error(`Failed to connect to daemon at ${socketPath} after ${maxRetries * retryDelay}ms`);
+}
+async function connectToSocket(socketPath) {
+  const socket = await new Promise((resolve, reject) => {
+    const socket2 = import_net.default.createConnection(socketPath, () => {
+      debugCli(`Connected to daemon at ${socketPath}`);
+      resolve(socket2);
+    });
+    socket2.on("error", reject);
+  });
+  return new SocketSession(new import_socketConnection.SocketConnection(socket));
+}
+function currentSessionPath() {
+  return import_path.default.resolve(daemonSocketDir(), "current-session");
+}
+async function getCurrentSession() {
+  try {
+    const session = await import_fs.default.promises.readFile(currentSessionPath(), "utf-8");
+    return session.trim() || "default";
+  } catch {
+    return "default";
+  }
+}
+async function setCurrentSession(sessionName) {
+  await import_fs.default.promises.mkdir(daemonSocketDir(), { recursive: true });
+  await import_fs.default.promises.writeFile(currentSessionPath(), sessionName);
+}
+async function canConnectToSocket(socketPath) {
+  return new Promise((resolve) => {
+    const socket = import_net.default.createConnection(socketPath, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function listSessions() {
+  const dir = daemonSocketDir();
+  try {
+    const files = await import_fs.default.promises.readdir(dir);
+    const sessions = [];
+    for (const file of files) {
+      if (file.endsWith("-user-data")) {
+        const sessionName = file.slice(0, -"-user-data".length);
+        const socketPath = daemonSocketPath(sessionName);
+        const live = await canConnectToSocket(socketPath);
+        sessions.push({ name: sessionName, live });
+      }
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function resolveSessionName(args) {
+  if (args.session)
+    return args.session;
+  if (process.env.PLAYWRIGHT_CLI_SESSION)
+    return process.env.PLAYWRIGHT_CLI_SESSION;
+  return "default";
+}
+async function handleSessionCommand(args) {
+  const subcommand = args._[1];
+  if (!subcommand) {
+    const current = await getCurrentSession();
+    console.log(current);
+    return;
+  }
+  if (subcommand === "list") {
+    const sessions = await listSessions();
+    const current = await getCurrentSession();
+    console.log("Sessions:");
+    for (const session of sessions) {
+      const marker = session.name === current ? "->" : "  ";
+      const liveMarker = session.live ? " (live)" : "";
+      console.log(`${marker} ${session.name}${liveMarker}`);
+    }
+    if (sessions.length === 0)
+      console.log("   (no sessions)");
+    return;
+  }
+  if (subcommand === "set") {
+    const sessionName = args._[2];
+    if (!sessionName) {
+      console.error("Usage: playwright-cli session set <session-name>");
+      process.exit(1);
+    }
+    await setCurrentSession(sessionName);
+    console.log(`Current session set to: ${sessionName}`);
+    return;
+  }
+  console.error(`Unknown session subcommand: ${subcommand}`);
+  process.exit(1);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const args = require("minimist")(argv);
+  const help = require("./help.json");
+  const commandName = args._[0];
+  if (args.version || args.v) {
+    console.log(packageJSON.version);
+    process.exit(0);
+  }
+  if (commandName === "session") {
+    await handleSessionCommand(args);
+    return;
+  }
+  const command = help.commands[commandName];
+  if (args.help || args.h) {
+    if (command) {
+      console.log(command);
+    } else {
+      console.log("playwright-cli - run playwright mcp commands from terminal\n");
+      console.log(help.global);
+    }
+    process.exit(0);
+  }
+  if (!command) {
+    console.error(`Unknown command: ${commandName}
+`);
+    console.log(help.global);
+    process.exit(1);
+  }
+  let sessionName = resolveSessionName(args);
+  if (sessionName === "default" && !args.session && !process.env.PLAYWRIGHT_CLI_SESSION)
+    sessionName = await getCurrentSession();
+  runCliCommand(sessionName, args).catch((e) => {
+    console.error(e.message);
+    process.exit(1);
+  });
+}
+main().catch((e) => {
+  console.error(e.message);
+  process.exit(1);
+});