@cotestdev/mcp_playwright 0.0.58 → 0.0.59

package/lib/mcp/terminal/program.js

@@ -32,358 +32,18 @@ __export(program_exports, {
 });
 module.exports = __toCommonJS(program_exports);
 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_socketConnection = require("./socketConnection");
-class Session {
-  constructor(clientInfo, name, options) {
-    this._nextMessageId = 1;
-    this._callbacks = /* @__PURE__ */ new Map();
-    this.name = name;
-    this._clientInfo = clientInfo;
-    this._config = options;
-  }
-  config() {
-    return this._config;
-  }
-  isCompatible() {
-    return this._clientInfo.version === this._config.version;
-  }
-  checkCompatible() {
-    if (!this.isCompatible()) {
-      throw new Error(`Client is v${this._clientInfo.version}, session '${this.name}' is v${this._config.version}. Run
-
-  playwright-cli${this.name !== "default" ? ` -s=${this.name}` : ""} open
-
-to restart the browser session.`);
-    }
-  }
-  async run(args) {
-    this.checkCompatible();
-    return await this._send("run", { args, cwd: process.cwd() });
-  }
-  async stop(quiet = false) {
-    if (!await this.canConnect()) {
-      if (!quiet)
-        console.log(`Browser '${this.name}' is not open.`);
-      return;
-    }
-    await this._stopDaemon();
-    if (!quiet)
-      console.log(`Browser '${this.name}' closed
-`);
-  }
-  async _send(method, params = {}) {
-    const connection = await this._startDaemonIfNeeded();
-    const messageId = this._nextMessageId++;
-    const message = {
-      id: messageId,
-      method,
-      params,
-      version: this._config.version
-    };
-    const responsePromise = new Promise((resolve, reject) => {
-      this._callbacks.set(messageId, { resolve, reject, method, params });
-    });
-    const [result] = await Promise.all([responsePromise, connection.send(message)]);
-    return result;
-  }
-  disconnect() {
-    if (!this._connection)
-      return;
-    for (const callback of this._callbacks.values())
-      callback.reject(new Error("Session closed"));
-    this._callbacks.clear();
-    this._connection.close();
-    this._connection = void 0;
-  }
-  async deleteData() {
-    await this.stop();
-    const dataDirs = await import_fs.default.promises.readdir(this._clientInfo.daemonProfilesDir).catch(() => []);
-    const matchingEntries = dataDirs.filter((file) => file === `${this.name}.session` || file.startsWith(`ud-${this.name}-`));
-    if (matchingEntries.length === 0) {
-      console.log(`No user data found for browser '${this.name}'.`);
-      return;
-    }
-    for (const entry of matchingEntries) {
-      const userDataDir = import_path.default.resolve(this._clientInfo.daemonProfilesDir, entry);
-      for (let i = 0; i < 5; i++) {
-        try {
-          await import_fs.default.promises.rm(userDataDir, { recursive: true });
-          if (entry.startsWith("ud-"))
-            console.log(`Deleted user data for browser '${this.name}'.`);
-          break;
-        } catch (e) {
-          if (e.code === "ENOENT") {
-            console.log(`No user data found for browser '${this.name}'.`);
-            break;
-          }
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
-          if (i === 4)
-            throw e;
-        }
-      }
-    }
-  }
-  async _connect() {
-    return await new Promise((resolve) => {
-      const socket = import_net.default.createConnection(this._config.socketPath, () => {
-        resolve({ socket });
-      });
-      socket.on("error", (error) => {
-        if (import_os.default.platform() !== "win32")
-          void import_fs.default.promises.unlink(this._config.socketPath).catch(() => {
-          }).then(() => resolve({ error }));
-        else
-          resolve({ error });
-      });
-    });
-  }
-  async canConnect() {
-    const { socket } = await this._connect();
-    if (socket) {
-      socket.destroy();
-      return true;
-    }
-    return false;
-  }
-  async _startDaemonIfNeeded() {
-    if (this._connection)
-      return this._connection;
-    let { socket } = await this._connect();
-    if (!socket)
-      socket = await this._startDaemon();
-    this._connection = new import_socketConnection.SocketConnection(socket, this._config.version);
-    this._connection.onmessage = (message) => this._onMessage(message);
-    this._connection.onclose = () => this.disconnect();
-    return this._connection;
-  }
-  _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)}`);
-    }
-  }
-  _sessionFile(suffix) {
-    return import_path.default.resolve(this._clientInfo.daemonProfilesDir, `${this.name}${suffix}`);
-  }
-  async _startDaemon() {
-    await import_fs.default.promises.mkdir(this._clientInfo.daemonProfilesDir, { recursive: true });
-    const cliPath = import_path.default.join(__dirname, "../../../cli.js");
-    const sessionConfigFile = this._sessionFile(".session");
-    this._config.version = this._clientInfo.version;
-    await import_fs.default.promises.writeFile(sessionConfigFile, JSON.stringify(this._config, null, 2));
-    const errLog = this._sessionFile(".err");
-    const err = import_fs.default.openSync(errLog, "w");
-    const args = [
-      cliPath,
-      "run-mcp-server",
-      `--daemon-session=${sessionConfigFile}`
-    ];
-    const child = (0, import_child_process.spawn)(process.execPath, args, {
-      detached: true,
-      stdio: ["ignore", "pipe", err],
-      cwd: process.cwd()
-      // Will be used as root.
-    });
-    let signalled = false;
-    const sigintHandler = () => {
-      signalled = true;
-      child.kill("SIGINT");
-    };
-    const sigtermHandler = () => {
-      signalled = true;
-      child.kill("SIGTERM");
-    };
-    process.on("SIGINT", sigintHandler);
-    process.on("SIGTERM", sigtermHandler);
-    let outLog = "";
-    await new Promise((resolve, reject) => {
-      child.stdout.on("data", (data) => {
-        outLog += data.toString();
-        if (!outLog.includes("<EOF>"))
-          return;
-        const errorMatch = outLog.match(/### Error\n([\s\S]*)<EOF>/);
-        const error = errorMatch ? errorMatch[1].trim() : void 0;
-        if (error) {
-          const errLogContent = import_fs.default.readFileSync(errLog, "utf-8");
-          const message = error + (errLogContent ? "\n" + errLogContent : "");
-          reject(new Error(message));
-        }
-        const successMatch = outLog.match(/### Success\nDaemon listening on (.*)\n<EOF>/);
-        if (successMatch)
-          resolve();
-      });
-      child.on("close", (code) => {
-        if (!signalled)
-          reject(new Error(`Daemon process exited with code ${code}`));
-      });
-    });
-    process.off("SIGINT", sigintHandler);
-    process.off("SIGTERM", sigtermHandler);
-    child.stdout.destroy();
-    child.unref();
-    const { socket } = await this._connect();
-    if (socket) {
-      console.log(`### Browser \`${this.name}\` opened with pid ${child.pid}.`);
-      const resolvedConfig = await parseResolvedConfig(outLog);
-      if (resolvedConfig) {
-        this._config.resolvedConfig = resolvedConfig;
-        console.log(`- ${this.name}:`);
-        console.log(renderResolvedConfig(resolvedConfig).join("\n"));
-      }
-      console.log(`---`);
-      await import_fs.default.promises.writeFile(sessionConfigFile, JSON.stringify(this._config, null, 2));
-      return socket;
-    }
-    console.error(`Failed to connect to daemon at ${this._config.socketPath}`);
-    process.exit(1);
-  }
-  async _stopDaemon() {
-    let error;
-    await this._send("stop").catch((e) => {
-      error = e;
-    });
-    if (import_os.default.platform() !== "win32")
-      await import_fs.default.promises.unlink(this._config.socketPath).catch(() => {
-      });
-    this.disconnect();
-    if (!this._config.cli.persistent)
-      await this.deleteSessionConfig();
-    if (error && !error?.message?.includes("Session closed"))
-      throw error;
-  }
-  async deleteSessionConfig() {
-    await import_fs.default.promises.rm(this._sessionFile(".session")).catch(() => {
-    });
-  }
-}
-class SessionManager {
-  constructor(clientInfo, sessions) {
-    this.clientInfo = clientInfo;
-    this.sessions = sessions;
-  }
-  static async create(clientInfo) {
-    const dir = clientInfo.daemonProfilesDir;
-    const sessions = /* @__PURE__ */ new Map();
-    const files = await import_fs.default.promises.readdir(dir).catch(() => []);
-    for (const file of files) {
-      if (!file.endsWith(".session"))
-        continue;
-      try {
-        const sessionName = import_path.default.basename(file, ".session");
-        const sessionConfig = await import_fs.default.promises.readFile(import_path.default.join(dir, file), "utf-8").then((data) => JSON.parse(data));
-        sessions.set(sessionName, new Session(clientInfo, sessionName, sessionConfig));
-      } catch {
-      }
-    }
-    return new SessionManager(clientInfo, sessions);
-  }
-  async open(args) {
-    const sessionName = this._resolveSessionName(args.session);
-    let session = this.sessions.get(sessionName);
-    if (session)
-      await session.stop(true);
-    session = new Session(this.clientInfo, sessionName, sessionConfigFromArgs(this.clientInfo, sessionName, args));
-    this.sessions.set(sessionName, session);
-    await this.run(args);
-  }
-  async run(args) {
-    const sessionName = this._resolveSessionName(args.session);
-    const session = this.sessions.get(sessionName);
-    if (!session) {
-      console.log(`The browser '${sessionName}' is not open, please run open first`);
-      console.log("");
-      console.log(`  playwright-cli${sessionName !== "default" ? ` -s=${sessionName}` : ""} open [params]`);
-      process.exit(1);
-    }
-    for (const globalOption of globalOptions)
-      delete args[globalOption];
-    const result = await session.run(args);
-    console.log(result.text);
-    session.disconnect();
-  }
-  async close(options) {
-    const sessionName = this._resolveSessionName(options.session);
-    const session = this.sessions.get(sessionName);
-    if (!session || !await session.canConnect()) {
-      console.log(`Browser '${sessionName}' is not open.`);
-      return;
-    }
-    await session.stop();
-  }
-  async deleteData(options) {
-    const sessionName = this._resolveSessionName(options.session);
-    const session = this.sessions.get(sessionName);
-    if (!session) {
-      console.log(`No user data found for browser '${sessionName}'.`);
-      return;
-    }
-    await session.deleteData();
-    this.sessions.delete(sessionName);
-  }
-  _resolveSessionName(sessionName) {
-    if (sessionName)
-      return sessionName;
-    if (process.env.PLAYWRIGHT_CLI_SESSION)
-      return process.env.PLAYWRIGHT_CLI_SESSION;
-    return "default";
-  }
-}
-function createClientInfo(packageLocation) {
-  const packageJSON = require(packageLocation);
-  const workspaceDir = findWorkspaceDir(process.cwd());
-  const version = process.env.PLAYWRIGHT_CLI_VERSION_FOR_TEST || packageJSON.version;
-  const hash = import_crypto.default.createHash("sha1");
-  hash.update(workspaceDir || packageLocation);
-  const workspaceDirHash = hash.digest("hex").substring(0, 16);
-  return {
-    version,
-    workspaceDir,
-    workspaceDirHash,
-    daemonProfilesDir: daemonProfilesDir(workspaceDirHash)
-  };
+var import_registry = require("./registry");
+var import_session = require("./session");
+function resolveSessionName(sessionName) {
+  if (sessionName)
+    return sessionName;
+  if (process.env.PLAYWRIGHT_CLI_SESSION)
+    return process.env.PLAYWRIGHT_CLI_SESSION;
+  return "default";
 }
-function findWorkspaceDir(startDir) {
-  let dir = startDir;
-  for (let i = 0; i < 10; i++) {
-    if (import_fs.default.existsSync(import_path.default.join(dir, ".playwright")))
-      return dir;
-    const parentDir = import_path.default.dirname(dir);
-    if (parentDir === dir)
-      break;
-    dir = parentDir;
-  }
-  return void 0;
-}
-const baseDaemonDir = (() => {
-  if (process.env.PLAYWRIGHT_DAEMON_SESSION_DIR)
-    return process.env.PLAYWRIGHT_DAEMON_SESSION_DIR;
-  let localCacheDir;
-  if (process.platform === "linux")
-    localCacheDir = process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
-  if (process.platform === "darwin")
-    localCacheDir = import_path.default.join(import_os.default.homedir(), "Library", "Caches");
-  if (process.platform === "win32")
-    localCacheDir = process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
-  if (!localCacheDir)
-    throw new Error("Unsupported platform: " + process.platform);
-  return import_path.default.join(localCacheDir, "ms-playwright", "daemon");
-})();
-const daemonProfilesDir = (workspaceDirHash) => {
-  return import_path.default.join(baseDaemonDir, workspaceDirHash);
-};
 const globalOptions = [
   "browser",
   "config",
@@ -400,12 +60,12 @@ const booleanOptions = [
   "help",
   "version"
 ];
-async function program(packageLocation) {
-  const clientInfo = createClientInfo(packageLocation);
+async function program() {
+  const clientInfo = (0, import_registry.createClientInfo)();
   const help = require("./help.json");
   const argv = process.argv.slice(2);
   const boolean = [...help.booleanOptions, ...booleanOptions];
-  const args = require("minimist")(argv, { boolean });
+  const args = require("minimist")(argv, { boolean, string: ["_"] });
   for (const [key, value] of Object.entries(args)) {
     if (key !== "_" && typeof value !== "boolean")
       args[key] = String(value);
@@ -445,38 +105,77 @@ async function program(packageLocation) {
     console.log(help.global);
     process.exit(1);
   }
-  const sessionManager = await SessionManager.create(clientInfo);
+  const registry = await import_registry.Registry.load();
+  const sessionName = resolveSessionName(args.session);
   switch (commandName) {
     case "list": {
-      if (args.all)
-        await listAllSessions(clientInfo);
-      else
-        await listSessions(sessionManager);
+      await listSessions(registry, clientInfo, args.all);
       return;
     }
     case "close-all": {
-      const sessions = sessionManager.sessions;
-      for (const session of sessions.values())
-        await session.stop(true);
+      const entries = registry.entries(clientInfo);
+      for (const entry of entries)
+        await new import_session.Session(clientInfo, entry.config).stop(true);
       return;
     }
-    case "delete-data":
-      await sessionManager.deleteData(args);
+    case "delete-data": {
+      const entry = registry.entry(clientInfo, sessionName);
+      if (!entry) {
+        console.log(`No user data found for browser '${sessionName}'.`);
+        return;
+      }
+      await new import_session.Session(clientInfo, entry.config).deleteData();
       return;
-    case "kill-all":
+    }
+    case "kill-all": {
       await killAllDaemons();
       return;
-    case "open":
-      await sessionManager.open(args);
+    }
+    case "open": {
+      const entry = registry.entry(clientInfo, sessionName);
+      if (entry)
+        await new import_session.Session(clientInfo, entry.config).stop(true);
+      const session2 = new import_session.Session(clientInfo, sessionConfigFromArgs(clientInfo, sessionName, args));
+      for (const globalOption of globalOptions)
+        delete args[globalOption];
+      const result = await session2.run(args);
+      console.log(result.text);
       return;
+    }
     case "close":
-      await sessionManager.close(args);
+      const closeEntry = registry.entry(clientInfo, sessionName);
+      const session = closeEntry ? new import_session.Session(clientInfo, closeEntry.config) : void 0;
+      if (!session || !await session.canConnect()) {
+        console.log(`Browser '${sessionName}' is not open.`);
+        return;
+      }
+      await session.stop();
       return;
     case "install":
       await install(args);
       return;
-    default:
-      await sessionManager.run(args);
+    case "show": {
+      const daemonScript = import_path.default.join(__dirname, "devtoolsApp.js");
+      const child = (0, import_child_process.spawn)(process.execPath, [daemonScript], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      return;
+    }
+    default: {
+      const defaultEntry = registry.entry(clientInfo, sessionName);
+      if (!defaultEntry) {
+        console.log(`The browser '${sessionName}' is not open, please run open first`);
+        console.log("");
+        console.log(`  playwright-cli${sessionName !== "default" ? ` -s=${sessionName}` : ""} open [params]`);
+        process.exit(1);
+      }
+      for (const globalOption of globalOptions)
+        delete args[globalOption];
+      const result = await new import_session.Session(clientInfo, defaultEntry.config).run(args);
+      console.log(result.text);
+    }
   }
 }
 async function install(args) {
@@ -561,7 +260,9 @@ function sessionConfigFromArgs(clientInfo, sessionName, args) {
   if (!args.persistent && args.profile)
     args.persistent = true;
   return {
+    name: sessionName,
     version: clientInfo.version,
+    timestamp: 0,
     socketPath: daemonSocketPath(clientInfo, sessionName),
     cli: {
       headed: args.headed,
@@ -613,55 +314,34 @@ async function killAllDaemons() {
   else if (killed > 0)
     console.log(`Killed ${killed} daemon process${killed === 1 ? "" : "es"}.`);
 }
-async function listSessions(sessionManager) {
-  const sessions = sessionManager.sessions;
-  console.log("### Browsers");
-  await gcAndPrintSessions([...sessions.values()]);
-}
-async function listAllSessions(clientInfo) {
-  const hashes = await import_fs.default.promises.readdir(baseDaemonDir).catch(() => []);
-  const sessionsByWorkspace = /* @__PURE__ */ new Map();
-  for (const hash of hashes) {
-    const hashDir = import_path.default.join(baseDaemonDir, hash);
-    const stat = await import_fs.default.promises.stat(hashDir).catch(() => null);
-    if (!stat?.isDirectory())
-      continue;
-    const files = await import_fs.default.promises.readdir(hashDir).catch(() => []);
-    for (const file of files) {
-      if (!file.endsWith(".session"))
+async function listSessions(registry, clientInfo, all) {
+  if (all) {
+    const entries = registry.entryMap();
+    if (entries.size === 0) {
+      console.log("No browsers found.");
+      return;
+    }
+    for (const [workspace, list] of entries) {
+      if (!list.length)
         continue;
-      try {
-        const sessionName = import_path.default.basename(file, ".session");
-        const sessionConfig = await import_fs.default.promises.readFile(import_path.default.join(hashDir, file), "utf-8").then((data) => JSON.parse(data));
-        const session = new Session(clientInfo, sessionName, sessionConfig);
-        const workspaceKey = sessionConfig.workspaceDir || "<global>";
-        if (!sessionsByWorkspace.has(workspaceKey))
-          sessionsByWorkspace.set(workspaceKey, []);
-        sessionsByWorkspace.get(workspaceKey).push(session);
-      } catch {
-      }
+      console.log(`${workspace}:`);
+      await gcAndPrintSessions(list.map((entry) => new import_session.Session(clientInfo, entry.config)));
     }
-  }
-  if (sessionsByWorkspace.size === 0) {
-    console.log("No browsers found.");
-    return;
-  }
-  const sortedWorkspaces = [...sessionsByWorkspace.keys()].sort();
-  for (const workspace of sortedWorkspaces) {
-    const sessions = sessionsByWorkspace.get(workspace);
-    console.log(`${workspace}:`);
-    await gcAndPrintSessions(sessions);
+  } else {
+    console.log("### Browsers");
+    const entries = registry.entries(clientInfo);
+    await gcAndPrintSessions(entries.map((entry) => new import_session.Session(clientInfo, entry.config)));
   }
 }
 async function gcAndPrintSessions(sessions) {
   const running = [];
   const stopped = [];
-  for (const session of sessions.values()) {
+  for (const session of sessions) {
     const canConnect = await session.canConnect();
     if (canConnect) {
       running.push(session);
     } else {
-      if (session.config().cli.persistent)
+      if (session.config.cli.persistent)
         stopped.push(session);
       else
         await session.deleteSessionConfig();
@@ -676,44 +356,16 @@ async function gcAndPrintSessions(sessions) {
 }
 async function renderSessionStatus(session) {
   const text = [];
-  const config = session.config();
+  const config = session.config;
   const canConnect = await session.canConnect();
   text.push(`- ${session.name}:`);
   text.push(`  - status: ${canConnect ? "open" : "closed"}`);
   if (canConnect && !session.isCompatible())
     text.push(`  - version: v${config.version} [incompatible please re-open]`);
   if (config.resolvedConfig)
-    text.push(...renderResolvedConfig(config.resolvedConfig));
+    text.push(...(0, import_session.renderResolvedConfig)(config.resolvedConfig));
   return text.join("\n");
 }
-function renderResolvedConfig(resolvedConfig) {
-  const channel = resolvedConfig.browser.launchOptions.channel ?? resolvedConfig.browser.browserName;
-  const lines = [];
-  if (channel)
-    lines.push(`  - browser-type: ${channel}`);
-  if (resolvedConfig.browser.isolated)
-    lines.push(`  - user-data-dir: <in-memory>`);
-  else
-    lines.push(`  - user-data-dir: ${resolvedConfig.browser.userDataDir}`);
-  lines.push(`  - headed: ${!resolvedConfig.browser.launchOptions.headless}`);
-  return lines;
-}
-async function parseResolvedConfig(errLog) {
-  const marker = "### Config\n```json\n";
-  const markerIndex = errLog.indexOf(marker);
-  if (markerIndex === -1)
-    return null;
-  const jsonStart = markerIndex + marker.length;
-  const jsonEnd = errLog.indexOf("\n```", jsonStart);
-  if (jsonEnd === -1)
-    throw null;
-  const jsonString = errLog.substring(jsonStart, jsonEnd).trim();
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return null;
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   program