@cotestdev/mcp_playwright 0.0.35 → 0.0.37

package/lib/mcp/browser/response.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,290 +17,152 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var response_exports = {};
 __export(response_exports, {
-  RenderedResponse: () => RenderedResponse,
   Response: () => Response,
   parseResponse: () => parseResponse,
-  requestDebug: () => requestDebug
+  renderTabMarkdown: () => renderTabMarkdown,
+  renderTabsMarkdown: () => renderTabsMarkdown,
+  requestDebug: () => requestDebug,
+  serializeResponse: () => serializeResponse,
+  serializeStructuredResponse: () => serializeStructuredResponse
 });
 module.exports = __toCommonJS(response_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_tab = require("./tab");
+var import_utils = require("./tools/utils");
+var import_screenshot = require("./tools/screenshot");
 const requestDebug = (0, import_utilsBundle.debug)("pw:mcp:request");
 class Response {
-  constructor(context, toolName, toolArgs) {
-    this._result = [];
+  constructor(ordinal, context, toolName, toolArgs) {
+    this._results = [];
+    this._errors = [];
     this._code = [];
-    this._images = [];
-    this._files = [];
     this._includeSnapshot = "none";
-    this._includeTabs = false;
-    this._includeMetaOnly = false;
     this._context = context;
     this.toolName = toolName;
     this.toolArgs = toolArgs;
   }
-  addResult(result) {
-    this._result.push(result);
+  static {
+    this._ordinal = 0;
   }
-  addError(error) {
-    this._result.push(error);
-    this._isError = true;
+  static create(context, toolName, toolArgs) {
+    return new Response(++Response._ordinal, context, toolName, toolArgs);
+  }
+  addTextResult(text) {
+    this._results.push({ title: "", text });
   }
-  isError() {
-    return this._isError;
+  async addResult(title, data, file) {
+    this._results.push({
+      text: typeof data === "string" ? data : void 0,
+      data: typeof data === "string" ? void 0 : data,
+      title,
+      file
+    });
   }
-  result() {
-    return this._result.join("\n");
+  addError(error) {
+    this._errors.push(error);
   }
   addCode(code) {
     this._code.push(code);
   }
-  code() {
-    return this._code.join("\n");
-  }
-  addImage(image) {
-    this._images.push(image);
-  }
-  images() {
-    return this._images;
-  }
-  async addFile(fileName, options) {
-    const resolvedFile = await this._context.outputFile(fileName, options);
-    this._files.push({ fileName: resolvedFile, title: options.reason });
-    return resolvedFile;
-  }
   setIncludeSnapshot() {
     this._includeSnapshot = this._context.config.snapshot.mode;
   }
-  setIncludeFullSnapshot() {
+  setIncludeFullSnapshot(includeSnapshotFileName) {
     this._includeSnapshot = "full";
-  }
-  setIncludeTabs() {
-    this._includeTabs = true;
-  }
-  setIncludeModalStates(modalStates) {
-    this._includeModalStates = modalStates;
-  }
-  setIncludeMetaOnly() {
-    this._includeMetaOnly = true;
-  }
-  async finish() {
-    if (this._tabSnapshot)
-      return;
-    if (this._includeSnapshot !== "none" && this._context.currentTab())
-      this._tabSnapshot = await this._context.currentTabOrDie().captureSnapshot();
-    for (const tab of this._context.tabs())
-      await tab.updateTitle();
-  }
-  tabSnapshot() {
-    return this._tabSnapshot;
-  }
-  logBegin() {
-    if (requestDebug.enabled)
-      requestDebug(this.toolName, this.toolArgs);
-  }
-  logEnd() {
-    if (requestDebug.enabled)
-      requestDebug(this.serialize());
-  }
-  render() {
-    const renderedResponse = new RenderedResponse();
-    if (this._result.length)
-      renderedResponse.results.push(...this._result);
-    if (this._code.length)
-      renderedResponse.code.push(...this._code);
-    if (this._includeSnapshot !== "none" || this._includeTabs) {
-      const tabsMarkdown = renderTabsMarkdown(this._context.tabs(), this._includeTabs);
-      if (tabsMarkdown.length)
-        renderedResponse.states.tabs = tabsMarkdown.join("\n");
+    this._includeSnapshotFileName = includeSnapshotFileName;
+  }
+  async build() {
+    const rootPath = this._context.firstRootPath();
+    const sections = [];
+    const addSection = (title) => {
+      const section = { title, content: [], isError: title === "Error" };
+      sections.push(section);
+      return section.content;
+    };
+    if (this._errors.length) {
+      const content = addSection("Error");
+      content.push({ text: this._errors.join("\n"), title: "error" });
     }
-    if (this._tabSnapshot?.modalStates.length) {
-      const modalStatesMarkdown = (0, import_tab.renderModalStates)(this._tabSnapshot.modalStates);
-      renderedResponse.states.modal = modalStatesMarkdown.join("\n");
-    } else if (this._tabSnapshot) {
-      renderTabSnapshot(this._tabSnapshot, this._includeSnapshot, renderedResponse);
-    } else if (this._includeModalStates) {
-      const modalStatesMarkdown = (0, import_tab.renderModalStates)(this._includeModalStates);
-      renderedResponse.states.modal = modalStatesMarkdown.join("\n");
+    if (this._results.length) {
+      const content = addSection("Result");
+      content.push(...this._results);
     }
-    if (this._files.length) {
-      const lines = [];
-      for (const file of this._files)
-        lines.push(`- [${file.title}](${file.fileName})`);
-      renderedResponse.updates.push({ category: "files", content: lines.join("\n") });
+    if (this._context.config.codegen !== "none" && this._code.length) {
+      const content = addSection("Ran Playwright code");
+      for (const code of this._code)
+        content.push({ text: code, title: "code" });
     }
-    return this._context.config.secrets ? renderedResponse.redact(this._context.config.secrets) : renderedResponse;
-  }
-  serialize(options = {}) {
-    const renderedResponse = this.render();
-    const includeMeta = options._meta && "dev.lowire/history" in options._meta && "dev.lowire/state" in options._meta;
-    const _meta = includeMeta ? renderedResponse.asMeta() : void 0;
-    const content = [
-      {
-        type: "text",
-        text: renderedResponse.asText(this._includeMetaOnly ? { categories: ["files"] } : void 0)
+    const tabSnapshot = this._context.currentTab() ? await this._context.currentTabOrDie().captureSnapshot() : void 0;
+    const tabHeaders = await Promise.all(this._context.tabs().map((tab) => tab.headerSnapshot()));
+    if (this._includeSnapshot !== "none" || tabHeaders.some((header) => header.changed)) {
+      if (tabHeaders.length !== 1) {
+        const content2 = addSection("Open tabs");
+        content2.push({ text: renderTabsMarkdown(tabHeaders).join("\n"), title: "Open tabs" });
       }
-    ];
-    if (this._includeMetaOnly)
-      return { _meta, content, isError: this._isError };
-    if (this._context.config.imageResponses !== "omit") {
-      for (const image of this._images)
-        content.push({ type: "image", data: image.data.toString("base64"), mimeType: image.contentType });
+      const content = addSection("Page");
+      content.push({ text: renderTabMarkdown(tabHeaders[0]).join("\n"), title: "Page" });
     }
-    return {
-      _meta,
-      content,
-      isError: this._isError
-    };
-  }
-}
-function renderTabSnapshot(tabSnapshot, includeSnapshot, response) {
-  if (tabSnapshot.consoleMessages.length) {
-    const lines2 = [];
-    for (const message of tabSnapshot.consoleMessages)
-      lines2.push(`- ${trim(message.toString(), 100)}`);
-    response.updates.push({ category: "console", content: lines2.join("\n") });
-  }
-  if (tabSnapshot.downloads.length) {
-    const lines2 = [];
-    for (const entry of tabSnapshot.downloads) {
-      if (entry.finished)
-        lines2.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
-      else
-        lines2.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
+    if (tabSnapshot?.modalStates.length) {
+      const content = addSection("Modal state");
+      content.push({ text: (0, import_tab.renderModalStates)(this._context.config, tabSnapshot.modalStates).join("\n"), title: "Modal state" });
     }
-    response.updates.push({ category: "downloads", content: lines2.join("\n") });
-  }
-  if (includeSnapshot === "incremental" && tabSnapshot.ariaSnapshotDiff === "") {
-    return;
-  }
-  const lines = [];
-  lines.push(`- Page URL: ${tabSnapshot.url}`);
-  lines.push(`- Page Title: ${tabSnapshot.title}`);
-  if (includeSnapshot !== "none") {
-    lines.push(`- Page Snapshot:`);
-    lines.push("```yaml");
-    if (includeSnapshot === "incremental" && tabSnapshot.ariaSnapshotDiff !== void 0)
-      lines.push(tabSnapshot.ariaSnapshotDiff);
-    else
-      lines.push(tabSnapshot.ariaSnapshot);
-    lines.push("```");
+    if (tabSnapshot && this._includeSnapshot !== "none") {
+      const content = addSection("Snapshot");
+      const snapshot = this._includeSnapshot === "full" ? tabSnapshot.ariaSnapshot : tabSnapshot.ariaSnapshotDiff ?? tabSnapshot.ariaSnapshot;
+      content.push({ text: snapshot, title: "snapshot", file: { prefix: "page", ext: "yml", suggestedFilename: this._includeSnapshotFileName } });
+    }
+    if (tabSnapshot?.events.filter((event) => event.type !== "request").length) {
+      const content = addSection("Events");
+      const text = [];
+      for (const event of tabSnapshot.events) {
+        if (event.type === "console") {
+          if ((0, import_tab.shouldIncludeMessage)(this._context.config.console.level, event.message.type))
+            text.push(`- ${trimMiddle(event.message.toString(), 100)}`);
+        } else if (event.type === "download-start") {
+          text.push(`- Downloading file ${event.download.download.suggestedFilename()} ...`);
+        } else if (event.type === "download-finish") {
+          text.push(`- Downloaded file ${event.download.download.suggestedFilename()} to "${rootPath ? import_path.default.relative(rootPath, event.download.outputFile) : event.download.outputFile}"`);
+        }
+      }
+      content.push({ text: text.join("\n"), title: "events" });
+    }
+    return sections;
   }
-  response.states.page = lines.join("\n");
 }
-function renderTabsMarkdown(tabs, force = false) {
-  if (tabs.length === 1 && !force)
-    return [];
+function renderTabMarkdown(tab) {
+  const lines = [`- Page URL: ${tab.url}`];
+  if (tab.title)
+    lines.push(`- Page Title: ${tab.title}`);
+  return lines;
+}
+function renderTabsMarkdown(tabs) {
   if (!tabs.length)
-    return ['No open tabs. Use the "browser_navigate" tool to navigate to a page first.'];
+    return ["No open tabs. Navigate to a URL to create one."];
   const lines = [];
   for (let i = 0; i < tabs.length; i++) {
     const tab = tabs[i];
-    const current = tab.isCurrentTab() ? " (current)" : "";
-    lines.push(`- ${i}:${current} [${tab.lastTitle()}] (${tab.page.url()})`);
+    const current = tab.current ? " (current)" : "";
+    lines.push(`- ${i}:${current} [${tab.title}](${tab.url})`);
   }
   return lines;
 }
-function trim(text, maxLength) {
+function trimMiddle(text, maxLength) {
   if (text.length <= maxLength)
     return text;
-  return text.slice(0, maxLength) + "...";
-}
-class RenderedResponse {
-  constructor(copy) {
-    this.states = {};
-    this.updates = [];
-    this.results = [];
-    this.code = [];
-    if (copy) {
-      this.states = copy.states;
-      this.updates = copy.updates;
-      this.results = copy.results;
-      this.code = copy.code;
-    }
-  }
-  asText(filter) {
-    const text = [];
-    if (this.results.length)
-      text.push(`### Result
-${this.results.join("\n")}
-`);
-    if (this.code.length)
-      text.push(`### Ran Playwright code
-${this.code.join("\n")}
-`);
-    for (const { category, content } of this.updates) {
-      if (filter && !filter.categories.includes(category))
-        continue;
-      if (!content.trim())
-        continue;
-      switch (category) {
-        case "console":
-          text.push(`### New console messages
-${content}
-`);
-          break;
-        case "downloads":
-          text.push(`### Downloads
-${content}
-`);
-          break;
-        case "files":
-          text.push(`### Files
-${content}
-`);
-          break;
-      }
-    }
-    for (const [category, value] of Object.entries(this.states)) {
-      if (filter && !filter.categories.includes(category))
-        continue;
-      if (!value.trim())
-        continue;
-      switch (category) {
-        case "page":
-          text.push(`### Page state
-${value}
-`);
-          break;
-        case "tabs":
-          text.push(`### Open tabs
-${value}
-`);
-          break;
-        case "modal":
-          text.push(`### Modal state
-${value}
-`);
-          break;
-      }
-    }
-    return text.join("\n");
-  }
-  asMeta() {
-    const codeUpdate = this.code.length ? { category: "code", content: this.code.join("\n") } : void 0;
-    const resultUpdate = this.results.length ? { category: "result", content: this.results.join("\n") } : void 0;
-    const updates = [resultUpdate, codeUpdate, ...this.updates].filter(Boolean);
-    return {
-      "dev.lowire/history": updates,
-      "dev.lowire/state": { ...this.states }
-    };
-  }
-  redact(secrets) {
-    const redactText = (text) => {
-      for (const [secretName, secretValue] of Object.entries(secrets))
-        text = text.replaceAll(secretValue, `<secret>${secretName}</secret>`);
-      return text;
-    };
-    const updates = this.updates.map((update) => ({ ...update, content: redactText(update.content) }));
-    const results = this.results.map((result) => redactText(result));
-    const code = this.code.map((code2) => redactText(code2));
-    const states = Object.fromEntries(Object.entries(this.states).map(([key, value]) => [key, redactText(value)]));
-    return new RenderedResponse({ states, updates, results, code });
-  }
+  return text.slice(0, Math.floor(maxLength / 2)) + "..." + text.slice(-3 - Math.floor(maxLength / 2));
 }
 function parseSections(text) {
   const sections = /* @__PURE__ */ new Map();
@@ -313,40 +177,108 @@ function parseSections(text) {
   }
   return sections;
 }
+async function serializeResponse(context, sections, rootPath) {
+  const redactText = (text2) => {
+    for (const [secretName, secretValue] of Object.entries(context.config.secrets ?? {}))
+      text2 = text2.replaceAll(secretValue, `<secret>${secretName}</secret>`);
+    return text2;
+  };
+  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;
+      }
+      if (result.file.suggestedFilename || context.config.outputMode === "file" || result.data) {
+        const generatedFileName = await context.outputFile((0, import_utils.dateAsFileName)(result.file.prefix, result.file.ext), { origin: "code", title: section.title });
+        const fileName = result.file.suggestedFilename ? await context.outputFile(result.file.suggestedFilename, { origin: "llm", title: section.title }) : generatedFileName;
+        text.push(`- [${result.title}](${rootPath ? import_path.default.relative(rootPath, fileName) : fileName})`);
+        if (result.data)
+          await import_fs.default.promises.writeFile(fileName, result.data, "utf-8");
+        else
+          await import_fs.default.promises.writeFile(fileName, result.text);
+      } else {
+        if (result.file.ext === "yml")
+          text.push(`\`\`\`yaml
+${result.text}
+\`\`\``);
+        else
+          text.push(result.text);
+      }
+    }
+  }
+  const content = [
+    {
+      type: "text",
+      text: redactText(text.join("\n"))
+    }
+  ];
+  if (context.config.imageResponses !== "omit") {
+    for (const result of sections.flatMap((section) => section.content).filter((result2) => result2.file?.contentType)) {
+      const scaledData = (0, import_screenshot.scaleImageToFitMessage)(result.data, result.file.contentType === "image/png" ? "png" : "jpeg");
+      content.push({ type: "image", data: scaledData.toString("base64"), mimeType: result.file.contentType });
+    }
+  }
+  return {
+    content,
+    ...sections.some((section) => section.isError) ? { isError: true } : {}
+  };
+}
+async function serializeStructuredResponse(sections) {
+  for (const section of sections) {
+    for (const result of section.content) {
+      if (!result.data)
+        continue;
+      result.isBase64 = true;
+      result.text = result.data.toString("base64");
+      result.data = void 0;
+    }
+  }
+  return {
+    content: [{ type: "text", text: "", _meta: { sections } }],
+    isError: sections.some((section) => section.isError)
+  };
+}
 function parseResponse(response) {
   if (response.content?.[0].type !== "text")
     return void 0;
   const text = response.content[0].text;
   const sections = parseSections(text);
+  const error = sections.get("Error");
   const result = sections.get("Result");
   const code = sections.get("Ran Playwright code");
   const tabs = sections.get("Open tabs");
-  const pageState = sections.get("Page state");
-  const consoleMessages = sections.get("New console messages");
+  const page = sections.get("Page");
+  const snapshot = sections.get("Snapshot");
+  const events = sections.get("Events");
   const modalState = sections.get("Modal state");
-  const downloads = sections.get("Downloads");
-  const files = sections.get("Files");
   const codeNoFrame = code?.replace(/^```js\n/, "").replace(/\n```$/, "");
   const isError = response.isError;
-  const attachments = response.content.slice(1);
+  const attachments = response.content.length > 1 ? response.content.slice(1) : void 0;
   return {
     result,
+    error,
     code: codeNoFrame,
     tabs,
-    pageState,
-    consoleMessages,
+    page,
+    snapshot,
+    events,
     modalState,
-    downloads,
-    files,
     isError,
     attachments,
-    _meta: response._meta
+    text
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RenderedResponse,
   Response,
   parseResponse,
-  requestDebug
+  renderTabMarkdown,
+  renderTabsMarkdown,
+  requestDebug,
+  serializeResponse,
+  serializeStructuredResponse
 });

package/lib/mcp/browser/sessionLog.js

@@ -33,124 +33,39 @@ __export(sessionLog_exports, {
 module.exports = __toCommonJS(sessionLog_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var import_log = require("../log");
 var import_config = require("./config");
+var import_response = require("./response");
 class SessionLog {
   constructor(sessionFolder) {
-    this._ordinal = 0;
-    this._pendingEntries = [];
     this._sessionFileQueue = Promise.resolve();
     this._folder = sessionFolder;
     this._file = import_path.default.join(this._folder, "session.md");
   }
   static async create(config, clientInfo) {
-    const sessionFolder = await (0, import_config.outputFile)(config, clientInfo, `session-${Date.now()}`, { origin: "code", reason: "Saving session" });
+    const sessionFolder = await (0, import_config.outputFile)(config, clientInfo, `session-${Date.now()}`, { origin: "code", title: "Saving session" });
     await import_fs.default.promises.mkdir(sessionFolder, { recursive: true });
     console.error(`Session: ${sessionFolder}`);
     return new SessionLog(sessionFolder);
   }
-  logResponse(response) {
-    const entry = {
-      timestamp: performance.now(),
-      toolCall: {
-        toolName: response.toolName,
-        toolArgs: response.toolArgs,
-        result: response.result(),
-        isError: response.isError()
-      },
-      code: response.code(),
-      tabSnapshot: response.tabSnapshot()
-    };
-    this._appendEntry(entry);
-  }
-  logUserAction(action, tab, code, isUpdate) {
-    code = code.trim();
-    if (isUpdate) {
-      const lastEntry = this._pendingEntries[this._pendingEntries.length - 1];
-      if (lastEntry?.userAction?.name === action.name) {
-        lastEntry.userAction = action;
-        lastEntry.code = code;
-        return;
-      }
-    }
-    if (action.name === "navigate") {
-      const lastEntry = this._pendingEntries[this._pendingEntries.length - 1];
-      if (lastEntry?.tabSnapshot?.url === action.url)
-        return;
-    }
-    const entry = {
-      timestamp: performance.now(),
-      userAction: action,
-      code,
-      tabSnapshot: {
-        url: tab.page.url(),
-        title: "",
-        ariaSnapshot: action.ariaSnapshot || "",
-        modalStates: [],
-        consoleMessages: [],
-        downloads: []
-      }
-    };
-    this._appendEntry(entry);
-  }
-  _appendEntry(entry) {
-    this._pendingEntries.push(entry);
-    if (this._flushEntriesTimeout)
-      clearTimeout(this._flushEntriesTimeout);
-    this._flushEntriesTimeout = setTimeout(() => this._flushEntries(), 1e3);
-  }
-  async _flushEntries() {
-    clearTimeout(this._flushEntriesTimeout);
-    const entries = this._pendingEntries;
-    this._pendingEntries = [];
+  logResponse(toolName, toolArgs, responseObject) {
+    const parsed = (0, import_response.parseResponse)(responseObject);
+    if (parsed)
+      delete parsed.text;
     const lines = [""];
-    for (const entry of entries) {
-      const ordinal = (++this._ordinal).toString().padStart(3, "0");
-      if (entry.toolCall) {
-        lines.push(
-          `### Tool call: ${entry.toolCall.toolName}`,
-          `- Args`,
-          "```json",
-          JSON.stringify(entry.toolCall.toolArgs, null, 2),
-          "```"
-        );
-        if (entry.toolCall.result) {
-          lines.push(
-            entry.toolCall.isError ? `- Error` : `- Result`,
-            "```",
-            entry.toolCall.result,
-            "```"
-          );
-        }
-      }
-      if (entry.userAction) {
-        const actionData = { ...entry.userAction };
-        delete actionData.ariaSnapshot;
-        delete actionData.selector;
-        delete actionData.signals;
-        lines.push(
-          `### User action: ${entry.userAction.name}`,
-          `- Args`,
-          "```json",
-          JSON.stringify(actionData, null, 2),
-          "```"
-        );
-      }
-      if (entry.code) {
-        lines.push(
-          `- Code`,
-          "```js",
-          entry.code,
-          "```"
-        );
-      }
-      if (entry.tabSnapshot) {
-        const fileName = `${ordinal}.snapshot.yml`;
-        import_fs.default.promises.writeFile(import_path.default.join(this._folder, fileName), entry.tabSnapshot.ariaSnapshot).catch(import_log.logUnhandledError);
-        lines.push(`- Snapshot: ${fileName}`);
-      }
-      lines.push("", "");
+    lines.push(
+      `### Tool call: ${toolName}`,
+      `- Args`,
+      "```json",
+      JSON.stringify(toolArgs, null, 2),
+      "```"
+    );
+    if (parsed) {
+      lines.push(`- Result`);
+      lines.push("```json");
+      lines.push(JSON.stringify(parsed, null, 2));
+      lines.push("```");
     }
+    lines.push("");
     this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
   }
 }