@cotestdev/mcp_playwright 0.0.48 → 0.0.49

package/lib/mcp/terminal/program.js

@@ -28,7 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var program_exports = {};
 __export(program_exports, {
-  printResponse: () => printResponse,
   program: () => program
 });
 module.exports = __toCommonJS(program_exports);
@@ -40,102 +39,66 @@ var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
 var import_socketConnection = require("./socketConnection");
 class Session {
-  constructor(name, connection) {
+  constructor(name, options) {
     this._nextMessageId = 1;
     this._callbacks = /* @__PURE__ */ new Map();
     this.name = name;
-    this._connection = connection;
-    this._connection.onmessage = (message) => this._onMessage(message);
-    this._connection.onclose = () => this.close();
+    this._socketPath = this._daemonSocketPath();
+    this._options = options;
   }
   async run(args) {
-    return await this._send("run", { args });
+    return await this._send("run", { args, cwd: process.cwd() });
   }
   async stop() {
-    await this._send("stop");
+    if (!await this.canConnect()) {
+      console.log(`Session '${this.name}' is not running.`);
+      return;
+    }
+    await this._send("stop").catch((e) => {
+      if (e.message !== "Session closed")
+        throw e;
+    });
     this.close();
+    if (import_os.default.platform() !== "win32")
+      await import_fs.default.promises.unlink(this._socketPath).catch(() => {
+      });
+    console.log(`Session '${this.name}' stopped.`);
+  }
+  async restart(options) {
+    await this.stop();
+    this._options = options;
+    await this._startDaemonIfNeeded();
   }
   async _send(method, params = {}) {
+    const connection = await this._startDaemonIfNeeded();
     const messageId = this._nextMessageId++;
     const message = {
       id: messageId,
       method,
-      params
+      params,
+      version: this._options.daemonVersion
     };
-    await this._connection.send(message);
-    return new Promise((resolve, reject) => {
-      this._callbacks.set(messageId, { resolve, reject });
+    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;
   }
   close() {
+    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;
   }
-  _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)}`);
-    }
-  }
-}
-class SessionManager {
-  constructor(options) {
-    this._options = options;
-  }
-  async list() {
-    const dir = daemonProfilesDir;
-    try {
-      const files = await import_fs.default.promises.readdir(dir);
-      const sessions = /* @__PURE__ */ new Map();
-      for (const file of files) {
-        if (file.startsWith("ud-")) {
-          const sessionName = file.split("-")[1];
-          const live = await this._canConnect(sessionName);
-          sessions.set(sessionName, live);
-        }
-      }
-      return sessions;
-    } catch {
-      return /* @__PURE__ */ new Map();
-    }
-  }
-  async run(args) {
-    const sessionName = this._resolveSessionName(args.session);
-    const session = await this._connect(sessionName);
-    const result = await session.run(args);
-    await printResponse(result);
-    session.close();
-  }
-  async stop(sessionName) {
-    sessionName = this._resolveSessionName(sessionName);
-    if (!await this._canConnect(sessionName)) {
-      console.log(`Session '${sessionName}' is not running.`);
-      return;
-    }
-    const session = await this._connect(sessionName);
-    await session.stop();
-    console.log(`Session '${sessionName}' stopped.`);
-  }
-  async delete(sessionName) {
-    sessionName = this._resolveSessionName(sessionName);
-    if (await this._canConnect(sessionName)) {
-      const session = await this._connect(sessionName);
-      await session.stop();
-    }
+  async delete() {
+    await this.stop();
     const dataDirs = await import_fs.default.promises.readdir(daemonProfilesDir).catch(() => []);
-    const matchingDirs = dataDirs.filter((dir) => dir.startsWith(`ud-${sessionName}-`));
+    const matchingDirs = dataDirs.filter((dir) => dir.startsWith(`ud-${this.name}-`));
     if (matchingDirs.length === 0) {
-      console.log(`No user data found for session '${sessionName}'.`);
+      console.log(`No user data found for session '${this.name}'.`);
       return;
     }
     for (const dir of matchingDirs) {
@@ -143,11 +106,11 @@ class SessionManager {
       for (let i = 0; i < 5; i++) {
         try {
           await import_fs.default.promises.rm(userDataDir, { recursive: true });
-          console.log(`Deleted user data for session '${sessionName}'.`);
+          console.log(`Deleted user data for session '${this.name}'.`);
           break;
         } catch (e) {
           if (e.code === "ENOENT") {
-            console.log(`No user data found for session '${sessionName}'.`);
+            console.log(`No user data found for session '${this.name}'.`);
             break;
           }
           await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -156,39 +119,70 @@ class SessionManager {
         }
       }
     }
-    if (import_os.default.platform() !== "win32") {
-      const socketPath = this._daemonSocketPath(sessionName);
-      await import_fs.default.promises.unlink(socketPath).catch(() => {
+  }
+  async _connect() {
+    return await new Promise((resolve) => {
+      const socket = import_net.default.createConnection(this._socketPath, () => {
+        resolve({ socket });
       });
-    }
+      socket.on("error", (error) => {
+        if (import_os.default.platform() !== "win32")
+          void import_fs.default.promises.unlink(this._socketPath).catch(() => {
+          }).then(() => resolve({ error }));
+        else
+          resolve({ error });
+      });
+    });
   }
-  async configure(args) {
-    const sessionName = this._resolveSessionName(args.session);
-    if (await this._canConnect(sessionName)) {
-      const session2 = await this._connect(sessionName);
-      await session2.stop();
+  async canConnect() {
+    const { socket } = await this._connect();
+    if (socket) {
+      socket.destroy();
+      return true;
     }
-    this._options.config = args._[1];
-    const session = await this._connect(sessionName);
-    session.close();
-  }
-  async _connect(sessionName) {
-    const socketPath = this._daemonSocketPath(sessionName);
-    if (await this._canConnect(sessionName)) {
-      try {
-        return await this._connectToSocket(sessionName, socketPath);
-      } catch (e) {
-        if (import_os.default.platform() !== "win32")
-          await import_fs.default.promises.unlink(socketPath).catch(() => {
-          });
+    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._options.daemonVersion);
+    this._connection.onmessage = (message) => this._onMessage(message);
+    this._connection.onversionerror = (id, e) => {
+      if (e.received && e.received !== "undefined-for-test") {
+        return false;
       }
+      console.error(`Daemon is older than client, killing it.`);
+      this.stop().then(() => process.exit(1)).catch(() => process.exit(1));
+      return true;
+    };
+    this._connection.onclose = () => this.close();
+    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)}`);
     }
+  }
+  async _startDaemon() {
     await import_fs.default.promises.mkdir(daemonProfilesDir, { recursive: true });
-    const userDataDir = import_path.default.resolve(daemonProfilesDir, `ud-${sessionName}`);
+    const userDataDir = import_path.default.resolve(daemonProfilesDir, `ud-${this.name}`);
     const cliPath = import_path.default.join(__dirname, "../../../cli.js");
     const configFile = resolveConfigFile(this._options.config);
     const configArg = configFile !== void 0 ? [`--config=${configFile}`] : [];
     const headedArg = this._options.headed ? [`--daemon-headed`] : [];
+    const extensionArg = this._options.extension ? [`--extension`] : [];
     const outLog = import_path.default.join(daemonProfilesDir, "out.log");
     const errLog = import_path.default.join(daemonProfilesDir, "err.log");
     const out = import_fs.default.openSync(outLog, "w");
@@ -196,10 +190,13 @@ class SessionManager {
     const child = (0, import_child_process.spawn)(process.execPath, [
       cliPath,
       "run-mcp-server",
-      `--daemon=${socketPath}`,
+      `--output-dir=${outputDir}`,
+      `--daemon=${this._socketPath}`,
       `--daemon-data-dir=${userDataDir}`,
+      `--daemon-version=${this._options.daemonVersion}`,
       ...configArg,
-      ...headedArg
+      ...headedArg,
+      ...extensionArg
     ], {
       detached: true,
       stdio: ["ignore", out, err],
@@ -207,53 +204,104 @@ class SessionManager {
       // Will be used as root.
     });
     child.unref();
-    console.log(`<!-- Daemon for \`${sessionName}\` session started with pid ${child.pid}.`);
+    console.log(`<!-- Daemon for \`${this.name}\` session started with pid ${child.pid}.`);
     if (configFile)
       console.log(`- Using config file at \`${import_path.default.relative(process.cwd(), configFile)}\`.`);
-    const sessionSuffix = sessionName !== "default" ? ` "${sessionName}"` : "";
+    const sessionSuffix = this.name !== "default" ? ` "${this.name}"` : "";
     console.log(`- You can stop the session daemon with \`playwright-cli session-stop${sessionSuffix}\` when done.`);
     console.log(`- You can delete the session data with \`playwright-cli session-delete${sessionSuffix}\` when done.`);
     console.log("-->");
     const maxRetries = 50;
     const retryDelay = 100;
     for (let i = 0; i < maxRetries; i++) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
       try {
-        return await this._connectToSocket(sessionName, socketPath);
+        const { socket } = await this._connect();
+        if (socket)
+          return socket;
       } catch (e) {
-        if (e.code !== "ENOENT")
+        if (e.code !== "ENOENT" && e.code !== "ECONNREFUSED")
           throw e;
       }
     }
     const outData = await import_fs.default.promises.readFile(outLog, "utf-8").catch(() => "");
     const errData = await import_fs.default.promises.readFile(errLog, "utf-8").catch(() => "");
-    console.error(`Failed to connect to daemon at ${socketPath} after ${maxRetries * retryDelay}ms`);
+    console.error(`Failed to connect to daemon at ${this._socketPath} after ${maxRetries * retryDelay}ms`);
     if (outData.length)
       console.log(outData);
     if (errData.length)
       console.error(errData);
     process.exit(1);
   }
-  async _connectToSocket(sessionName, socketPath) {
-    const socket = await new Promise((resolve, reject) => {
-      const socket2 = import_net.default.createConnection(socketPath, () => {
-        resolve(socket2);
-      });
-      socket2.on("error", reject);
-    });
-    return new Session(sessionName, new import_socketConnection.SocketConnection(socket));
-  }
-  async _canConnect(sessionName) {
-    const socketPath = this._daemonSocketPath(sessionName);
-    return new Promise((resolve) => {
-      const socket = import_net.default.createConnection(socketPath, () => {
-        socket.destroy();
-        resolve(true);
-      });
-      socket.on("error", () => {
-        resolve(false);
-      });
-    });
+  _daemonSocketPath() {
+    const socketName = `${this.name}.sock`;
+    if (import_os.default.platform() === "win32")
+      return `\\\\.\\pipe\\${installationDirHash}-${socketName}`;
+    const socketsDir = process.env.PLAYWRIGHT_DAEMON_SOCKETS_DIR || import_path.default.join(import_os.default.tmpdir(), "playwright-cli");
+    return import_path.default.join(socketsDir, installationDirHash, socketName);
+  }
+}
+class SessionManager {
+  constructor(sessions, options) {
+    this.sessions = sessions;
+    this.options = options;
+  }
+  static async create(options) {
+    const dir = daemonProfilesDir;
+    const sessions = /* @__PURE__ */ new Map([
+      ["default", new Session("default", options)]
+    ]);
+    try {
+      const files = await import_fs.default.promises.readdir(dir);
+      for (const file of files) {
+        if (file.startsWith("ud-")) {
+          const sessionName = file.split("-")[1];
+          sessions.set(sessionName, new Session(sessionName, options));
+        }
+      }
+    } catch {
+    }
+    return new SessionManager(sessions, options);
+  }
+  async run(args) {
+    const sessionName = this._resolveSessionName(args.session);
+    let session = this.sessions.get(sessionName);
+    if (!session) {
+      session = new Session(sessionName, { ...this.options, ...args });
+      this.sessions.set(sessionName, session);
+    }
+    const result = await session.run({ ...args, outputDir });
+    console.log(result.text);
+    session.close();
+  }
+  async stop(sessionName) {
+    sessionName = this._resolveSessionName(sessionName);
+    const session = this.sessions.get(sessionName);
+    if (!session || !await session.canConnect()) {
+      console.log(`Session '${sessionName}' is not running.`);
+      return;
+    }
+    await session.stop();
+  }
+  async delete(sessionName) {
+    sessionName = this._resolveSessionName(sessionName);
+    const session = this.sessions.get(sessionName);
+    if (!session) {
+      console.log(`No user data found for session '${sessionName}'.`);
+      return;
+    }
+    await session.delete();
+    this.sessions.delete(sessionName);
+  }
+  async configure(args) {
+    const sessionName = this._resolveSessionName(args.session);
+    let session = this.sessions.get(sessionName);
+    if (!session) {
+      session = new Session(sessionName, this.options);
+      this.sessions.set(sessionName, session);
+    }
+    await session.restart({ ...this.options, ...args, config: args._[1] });
+    session.close();
   }
   _resolveSessionName(sessionName) {
     if (sessionName)
@@ -262,21 +310,14 @@ class SessionManager {
       return process.env.PLAYWRIGHT_CLI_SESSION;
     return "default";
   }
-  _daemonSocketPath(sessionName) {
-    const socketName = `${sessionName}.sock`;
-    if (import_os.default.platform() === "win32")
-      return `\\\\.\\pipe\\${installationDirHash}-${socketName}`;
-    const socketsDir = process.env.PLAYWRIGHT_DAEMON_SOCKETS_DIR || import_path.default.join(import_os.default.tmpdir(), "playwright-cli");
-    return import_path.default.join(socketsDir, installationDirHash, socketName);
-  }
 }
 async function handleSessionCommand(sessionManager, subcommand, args) {
   if (subcommand === "list") {
-    const sessions = await sessionManager.list();
+    const sessions = sessionManager.sessions;
     console.log("Sessions:");
-    for (const [sessionName, live] of sessions.entries()) {
-      const liveMarker = live ? " (live)" : "";
-      console.log(`  ${sessionName}${liveMarker}`);
+    for (const session of sessions.values()) {
+      const liveMarker = await session.canConnect() ? " (live)" : "";
+      console.log(`  ${session.name}${liveMarker}`);
     }
     if (sessions.size === 0)
       console.log("  (no sessions)");
@@ -287,9 +328,9 @@ async function handleSessionCommand(sessionManager, subcommand, args) {
     return;
   }
   if (subcommand === "stop-all") {
-    const sessions = await sessionManager.list();
-    for (const sessionName of sessions.keys())
-      await sessionManager.stop(sessionName);
+    const sessions = sessionManager.sessions;
+    for (const session of sessions.values())
+      await session.stop();
     return;
   }
   if (subcommand === "delete") {
@@ -325,10 +366,12 @@ const daemonProfilesDir = (() => {
 async function program(options) {
   const argv = process.argv.slice(2);
   const args = require("minimist")(argv, {
-    boolean: ["help", "version", "headed"]
+    boolean: ["help", "version", "headed", "extension"]
   });
   if (!argv.includes("--headed") && !argv.includes("--no-headed"))
     delete args.headed;
+  if (!argv.includes("--extension"))
+    delete args.extension;
   const help = require("./help.json");
   const commandName = args._[0];
   if (args.version || args.v) {
@@ -351,7 +394,7 @@ async function program(options) {
     console.log(help.global);
     process.exit(1);
   }
-  const sessionManager = new SessionManager(args);
+  const sessionManager = await SessionManager.create({ daemonVersion: options.version, ...args });
   if (commandName.startsWith("session")) {
     const subcommand = args._[0].split("-").slice(1).join("-");
     await handleSessionCommand(sessionManager, subcommand, args);
@@ -361,61 +404,13 @@ async function program(options) {
     await handleSessionCommand(sessionManager, "config", args);
     return;
   }
-  await sessionManager.run(args);
-}
-async function printResponse(response) {
-  const { sections } = response;
-  if (!sections) {
-    console.log("### Error\n" + response.text);
+  if (commandName === "close") {
+    await handleSessionCommand(sessionManager, "stop", args);
     return;
   }
-  const text = [];
-  for (const section of sections) {
-    text.push(`### ${section.title}`);
-    for (const result of section.content) {
-      if (!result.file) {
-        if (result.text !== void 0)
-          text.push(result.text);
-        continue;
-      }
-      const generatedFileName = await outputFile(dateAsFileName(result.file.prefix, result.file.ext), { origin: "code" });
-      const fileName = result.file.suggestedFilename ? await outputFile(result.file.suggestedFilename, { origin: "llm" }) : generatedFileName;
-      text.push(`- [${result.title}](${import_path.default.relative(process.cwd(), fileName)})`);
-      if (result.data)
-        await import_fs.default.promises.writeFile(fileName, result.data);
-      else if (result.isBase64)
-        await import_fs.default.promises.writeFile(fileName, Buffer.from(result.text, "base64"));
-      else
-        await import_fs.default.promises.writeFile(fileName, result.text);
-    }
-  }
-  console.log(text.join("\n"));
-}
-function dateAsFileName(prefix, extension) {
-  const date = /* @__PURE__ */ new Date();
-  return `${prefix}-${date.toISOString().replace(/[:.]/g, "-")}.${extension}`;
+  await sessionManager.run(args);
 }
 const outputDir = import_path.default.join(process.cwd(), ".playwright-cli");
-async function outputFile(fileName, options) {
-  await import_fs.default.promises.mkdir(outputDir, { recursive: true });
-  if (options.origin === "code")
-    return import_path.default.resolve(outputDir, fileName);
-  if (options.origin === "llm") {
-    fileName = fileName.split("\\").join("/");
-    const resolvedFile = import_path.default.resolve(outputDir, fileName);
-    if (!resolvedFile.startsWith(import_path.default.resolve(outputDir) + import_path.default.sep))
-      throw new Error(`Resolved file path ${resolvedFile} is outside of the output directory ${outputDir}. Use relative file names to stay within the output directory.`);
-    return resolvedFile;
-  }
-  return import_path.default.join(outputDir, sanitizeForFilePath(fileName));
-}
-function sanitizeForFilePath(s) {
-  const sanitize = (s2) => s2.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, "-");
-  const separator = s.lastIndexOf(".");
-  if (separator === -1)
-    return sanitize(s);
-  return sanitize(s.substring(0, separator)) + "." + sanitize(s.substring(separator + 1));
-}
 function resolveConfigFile(configParam) {
   const configFile = configParam || process.env.PLAYWRIGHT_CLI_CONFIG;
   if (configFile)
@@ -429,6 +424,5 @@ function resolveConfigFile(configParam) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  printResponse,
   program
 });

package/lib/mcp/terminal/socketConnection.js

@@ -22,9 +22,10 @@ __export(socketConnection_exports, {
 });
 module.exports = __toCommonJS(socketConnection_exports);
 class SocketConnection {
-  constructor(socket) {
+  constructor(socket, version) {
     this._pendingBuffers = [];
     this._socket = socket;
+    this._version = version;
     socket.on("data", (buffer) => this._onData(buffer));
     socket.on("close", () => {
       this.onclose?.();
@@ -33,7 +34,7 @@ class SocketConnection {
   }
   async send(message) {
     await new Promise((resolve, reject) => {
-      this._socket.write(`${JSON.stringify(message)}
+      this._socket.write(`${JSON.stringify({ ...message, version: this._version })}
 `, (error) => {
         if (error)
           reject(error);
@@ -66,7 +67,12 @@ class SocketConnection {
   }
   _dispatchMessage(message) {
     try {
-      this.onmessage?.(JSON.parse(message));
+      const parsedMessage = JSON.parse(message);
+      if (parsedMessage.version !== this._version) {
+        if (this.onversionerror?.(parsedMessage.id, { expected: this._version, received: parsedMessage.version }))
+          return;
+      }
+      this.onmessage?.(parsedMessage);
     } catch (e) {
       console.error("failed to dispatch message", e);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cotestdev/mcp_playwright",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "description": "Playwright MCP (Model Context Protocol) tools for browser automation",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
   "author": "",
   "license": "Apache-2.0",
   "dependencies": {
-    "@cotestdev/ai-runner-fake": "^0.0.7",
+    "@cotestdev/ai-runner-fake": "^0.0.9",
     "playwright": "^1.40.0",
     "playwright-core": "^1.40.0"
   },