@treegress.com/treegress-browser-mcp 0.0.56-treegress.3

package/mcp/browser/domSnapshot.js

@@ -0,0 +1,307 @@
+"use strict";
+
+var import_fs = require("fs");
+var import_path = require("path");
+
+const KNOWN_KIND_PRIORITY = [
+  "testId",
+  "role",
+  "text",
+  "label",
+  "placeholder",
+  "altText",
+  "title",
+  "id",
+  "name",
+  "dataAttr",
+  "css",
+  "xpath"
+];
+
+function defaultDomSerializerPath(configuredPath) {
+  if (configuredPath)
+    return configuredPath;
+  return process.cwd() + "/domSerializer.js";
+}
+
+async function loadDomSerializerSource(configuredPath, fallbackToDefault = true) {
+  const candidates = [];
+  if (configuredPath)
+    candidates.push(configuredPath);
+  if (fallbackToDefault)
+    candidates.push(defaultDomSerializerPath());
+  for (const candidate of candidates) {
+    const resolvedPath = import_path.resolve(process.cwd(), candidate);
+    if (import_fs.existsSync(resolvedPath))
+      return { path: resolvedPath, source: await import_fs.promises.readFile(resolvedPath, "utf-8") };
+  }
+  return { path: void 0, source: void 0 };
+}
+
+function buildCandidatesFromRaw(rawCandidates) {
+  if (!rawCandidates || typeof rawCandidates !== "object")
+    return [];
+  const entries = [];
+  const seen = new Set();
+
+  const addCandidate = (kind, payload) => {
+    if (!kind || !payload)
+      return;
+    const key = JSON.stringify({ kind, ...payload });
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    entries.push({ kind, payload });
+  };
+
+  const parseStrategy = (strategy, details) => {
+    if (!details)
+      return;
+    switch (strategy) {
+      case "getByTestId": {
+        if (details.testId)
+          addCandidate("testId", { testId: details.testId });
+        break;
+      }
+      case "getByRole": {
+        if (details.role)
+          addCandidate("role", { role: details.role, name: details.name, exact: details.exact !== false });
+        break;
+      }
+      case "getByText": {
+        if (details.text)
+          addCandidate("text", { text: details.text, exact: details.exact !== false });
+        break;
+      }
+      case "getByPlaceholder": {
+        if (details.placeholder)
+          addCandidate("placeholder", { value: details.placeholder });
+        break;
+      }
+      case "getByCss": {
+        if (details.css)
+          addCandidate("css", { value: details.css });
+        break;
+      }
+      case "getByXpath": {
+        if (details.xpath)
+          addCandidate("xpath", { value: details.xpath });
+        break;
+      }
+      case "filtered_getByRole":
+      case "chained_getByRole": {
+        if (details.target?.details?.role)
+          addCandidate("role", { role: details.target.details.role, name: details.target.details.name, exact: details.target.details.exact !== false });
+        else if (details.base?.details?.role)
+          addCandidate("role", { role: details.base.details.role, name: details.base.details.name, exact: details.base.details.exact !== false });
+        break;
+      }
+      case "filtered_getByText":
+      case "chained_getByText": {
+        if (details.target?.details?.text)
+          addCandidate("text", { text: details.target.details.text, exact: details.target.details.exact !== false });
+        else if (details.base?.details?.text)
+          addCandidate("text", { text: details.base.details.text, exact: details.base.details.exact !== false });
+        break;
+      }
+      case "label": {
+        if (details.label)
+          addCandidate("label", { value: details.label });
+        break;
+      }
+      default:
+        break;
+    }
+  };
+
+  if (Array.isArray(rawCandidates.priority)) {
+    for (const strategy of rawCandidates.priority)
+      parseStrategy(strategy, rawCandidates[strategy]);
+  }
+
+  if (rawCandidates.getByTestId && rawCandidates.getByTestId.testId)
+    parseStrategy("getByTestId", rawCandidates.getByTestId);
+  if (rawCandidates.getByRole && rawCandidates.getByRole.role)
+    parseStrategy("getByRole", rawCandidates.getByRole);
+  if (rawCandidates.getByText && rawCandidates.getByText.text)
+    parseStrategy("getByText", rawCandidates.getByText);
+  if (rawCandidates.getByPlaceholder && rawCandidates.getByPlaceholder.placeholder)
+    parseStrategy("getByPlaceholder", rawCandidates.getByPlaceholder);
+  if (rawCandidates.getByCss && rawCandidates.getByCss.css)
+    parseStrategy("getByCss", rawCandidates.getByCss);
+  if (rawCandidates.getByXpath && rawCandidates.getByXpath.xpath)
+    parseStrategy("getByXpath", rawCandidates.getByXpath);
+
+  const ordered = [];
+  const addByPriority = (kind) => {
+    for (const candidate of entries) {
+      if (candidate.kind === kind)
+        ordered.push(candidate);
+    }
+  };
+  for (const kind of KNOWN_KIND_PRIORITY) {
+    addByPriority(kind);
+  }
+  for (const candidate of entries) {
+    if (!KNOWN_KIND_PRIORITY.includes(candidate.kind))
+      ordered.push(candidate);
+  }
+  return ordered;
+}
+
+function collectDomNodes(node, result, onNode) {
+  if (!node || typeof node !== "object")
+    return;
+  onNode(node, result);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children)
+      collectDomNodes(child, result, onNode);
+  }
+}
+
+function candidateFromNodeAttributes(node) {
+  const candidates = [];
+  if (!node || typeof node !== "object")
+    return candidates;
+
+  if (node.id)
+    candidates.push({ kind: "id", payload: { id: node.id } });
+
+  if (node.tag === "input" && node.type)
+    candidates.push({ kind: "dataAttr", payload: { attr: "type", value: node.type } });
+
+  if (node.name)
+    candidates.push({ kind: "name", payload: { name: node.name } });
+
+  return candidates;
+}
+
+function normalizeDomSerializerResult(raw) {
+  const result = {
+    domSnapshotText: "",
+    elements: []
+  };
+  if (!raw || typeof raw !== "object") {
+    return result;
+  }
+
+  const dom = raw.dom || raw.snapshot || {};
+  const locators = raw.locators || raw.locatorMap || {};
+  const explicitElements = Array.isArray(raw.elements) ? raw.elements : [];
+
+  const explicitById = new Map();
+  for (const element of explicitElements) {
+    if (!element?.id)
+      continue;
+    const id = String(element.id);
+    explicitById.set(id, element);
+  }
+
+  collectDomNodes(dom, null, (node) => {
+    if (!node || typeof node !== "object")
+      return;
+
+    const id = node.id != null ? String(node.id) : void 0;
+    if (!id)
+      return;
+
+    const explicit = explicitById.get(id);
+    const locatorInfo = explicit?.locator || explicit?.locators || locators[id];
+    const candidates = explicit?.candidates?.length ? explicit.candidates : buildCandidatesFromRaw(locatorInfo) || [];
+    const meta = {
+      tag: node.tag || explicit?.tag,
+      role: node.role || explicit?.role,
+      text: node.text || explicit?.text,
+      accessibleName: node.accessibleName || explicit?.accessibleName,
+      isFocused: !!node.isFocused,
+      onTop: !!node.onTop
+    };
+
+    const mergedCandidates = [...candidates, ...candidateFromNodeAttributes(node)];
+
+    result.elements.push({
+      id,
+      candidates: mergedCandidates,
+      framePath: node.framePath,
+      meta
+    });
+  });
+
+  if (explicitElements.length && result.elements.length === 0) {
+    for (const element of explicitElements) {
+      if (!element?.id)
+        continue;
+      result.elements.push({
+        id: String(element.id),
+        candidates: Array.isArray(element.candidates) ? element.candidates : [],
+        framePath: element.framePath,
+        meta: {
+          tag: element.tag,
+          role: element.role,
+          text: element.text || element.accessibleName,
+          accessibleName: element.accessibleName
+        }
+      });
+    }
+  }
+
+  if (!result.elements.length && Array.isArray(raw.elements)) {
+    for (const element of raw.elements) {
+      if (!element?.id)
+        continue;
+      result.elements.push({
+        id: String(element.id),
+        candidates: Array.isArray(element.candidates) ? element.candidates : [],
+        framePath: element.framePath,
+        meta: element.meta || {}
+      });
+    }
+  }
+
+  result.domSnapshotText = buildDomText(dom);
+  return result;
+}
+
+function escapeText(value) {
+  if (!value)
+    return "";
+  return String(value).replace(/[\r\n]/g, " ").trim();
+}
+
+function buildDomText(node, depth = 0, result = []) {
+  if (!node || typeof node !== "object")
+    return result.join("\n");
+
+  const isInteractive = node.isInteractive || node.onTop || node.role === "button" || node.role === "link" || node.role === "textbox" || node.role === "combobox" || node.tag === "input" || node.tag === "select";
+  const id = node.id != null ? `[ref=${node.id}]` : "";
+  if (isInteractive) {
+    const indent = "  ".repeat(Math.max(0, depth));
+    const role = node.role || node.tag || "element";
+    const state = [];
+    if (node.isFocused)
+      state.push("active");
+    if (node.onTop)
+      state.push("interactive");
+    const descriptor = [
+      `${indent}- ${role}`,
+      escapeText(node.accessibleName || node.text) ? ` \"${escapeText(node.accessibleName || node.text)}\"` : "",
+      state.length ? ` [${state.join(", ")}]` : "",
+      id ? ` [${id}]` : ""
+    ].join("");
+    result.push(descriptor);
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children)
+      buildDomText(child, depth + 1, result);
+  }
+  return result.join("\n");
+}
+
+const normalizeDomSnapshotResult = normalizeDomSerializerResult;
+
+module.exports = {
+  defaultDomSerializerPath,
+  loadDomSerializerSource,
+  normalizeDomSerializerResult,
+  normalizeDomSnapshotResult
+};

package/mcp/browser/logFile.js

@@ -0,0 +1,96 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logFile_exports = {};
+__export(logFile_exports, {
+  LogFile: () => LogFile
+});
+module.exports = __toCommonJS(logFile_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_log = require("../log");
+class LogFile {
+  constructor(context, startTime, filePrefix, title) {
+    this._stopped = false;
+    this._line = 0;
+    this._entries = 0;
+    this._lastLine = 0;
+    this._lastEntries = 0;
+    this._writeChain = Promise.resolve();
+    this._context = context;
+    this._startTime = startTime;
+    this._filePrefix = filePrefix;
+    this._title = title;
+  }
+  appendLine(wallTime, text) {
+    this._writeChain = this._writeChain.then(() => this._write(wallTime, text)).catch(import_log.logUnhandledError);
+  }
+  stop() {
+    this._stopped = true;
+  }
+  async take(relativeTo) {
+    const logChunk = await this._take();
+    if (!logChunk)
+      return void 0;
+    const logFilePath = relativeTo ? import_path.default.relative(relativeTo, logChunk.file) : logChunk.file;
+    const lineRange = logChunk.fromLine === logChunk.toLine ? `#L${logChunk.fromLine}` : `#L${logChunk.fromLine}-L${logChunk.toLine}`;
+    return `${logFilePath}${lineRange}`;
+  }
+  async _take() {
+    await this._writeChain;
+    if (!this._file || this._entries === this._lastEntries)
+      return void 0;
+    const chunk = {
+      type: this._title.toLowerCase(),
+      file: this._file,
+      fromLine: this._lastLine + 1,
+      toLine: this._line,
+      entryCount: this._entries - this._lastEntries
+    };
+    this._lastLine = this._line;
+    this._lastEntries = this._entries;
+    return chunk;
+  }
+  async _write(wallTime, text) {
+    if (this._stopped)
+      return;
+    this._file ??= await this._context.outputFile({ prefix: this._filePrefix, ext: "log", date: new Date(this._startTime) }, { origin: "code" });
+    const relativeTime = Math.round(wallTime - this._startTime);
+    const renderedText = await text();
+    const logLine = `[${String(relativeTime).padStart(8, " ")}ms] ${renderedText}
+`;
+    await import_fs.default.promises.appendFile(this._file, logLine);
+    const lineCount = logLine.split("\n").length - 1;
+    this._line += lineCount;
+    this._entries++;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogFile
+});

package/mcp/browser/response.js

@@ -0,0 +1,299 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+__export(response_exports, {
+  Response: () => Response,
+  parseResponse: () => parseResponse,
+  renderTabMarkdown: () => renderTabMarkdown,
+  renderTabsMarkdown: () => renderTabsMarkdown,
+  requestDebug: () => requestDebug
+});
+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_screenshot = require("./tools/screenshot");
+const requestDebug = (0, import_utilsBundle.debug)("pw:mcp:request");
+class Response {
+  constructor(context, toolName, toolArgs, relativeTo) {
+    this._results = [];
+    this._errors = [];
+    this._code = [];
+    this._includeSnapshot = "none";
+    this._imageResults = [];
+    this._context = context;
+    this.toolName = toolName;
+    this.toolArgs = toolArgs;
+    this._clientWorkspace = relativeTo ?? context.firstRootPath();
+  }
+  _computRelativeTo(fileName) {
+    if (this._clientWorkspace)
+      return import_path.default.relative(this._clientWorkspace, fileName);
+    return fileName;
+  }
+  async resolveClientFile(template, title) {
+    let fileName;
+    if (template.suggestedFilename)
+      fileName = await this._context.workspaceFile(template.suggestedFilename, this._clientWorkspace);
+    else
+      fileName = await this._context.outputFile(template, { origin: "llm" });
+    const relativeName = this._computRelativeTo(fileName);
+    const printableLink = `- [${title}](${relativeName})`;
+    return { fileName, relativeName, printableLink };
+  }
+  addTextResult(text) {
+    this._results.push(text);
+  }
+  async addResult(title, data, file) {
+    if (this._context.config.outputMode === "file" || file.suggestedFilename || typeof data !== "string") {
+      const resolvedFile = await this.resolveClientFile(file, title);
+      await this.addFileResult(resolvedFile, data);
+    } else {
+      this.addTextResult(data);
+    }
+  }
+  async addFileResult(resolvedFile, data) {
+    if (typeof data === "string")
+      await import_fs.default.promises.writeFile(resolvedFile.fileName, data, "utf-8");
+    else if (data)
+      await import_fs.default.promises.writeFile(resolvedFile.fileName, data);
+    this.addTextResult(resolvedFile.printableLink);
+  }
+  addFileLink(title, fileName) {
+    const relativeName = this._computRelativeTo(fileName);
+    this.addTextResult(`- [${title}](${relativeName})`);
+  }
+  async registerImageResult(data, imageType) {
+    this._imageResults.push({ data, imageType });
+  }
+  addError(error) {
+    this._errors.push(error);
+  }
+  addCode(code) {
+    this._code.push(code);
+  }
+  setIncludeSnapshot() {
+    this._includeSnapshot = this._context.config.snapshot.mode;
+  }
+  setIncludeFullSnapshot(includeSnapshotFileName) {
+    this._includeSnapshot = "full";
+    this._includeSnapshotFileName = sanitizeSnapshotFileName(includeSnapshotFileName);
+  }
+  async serialize() {
+    const redactText = (text2) => {
+      for (const [secretName, secretValue] of Object.entries(this._context.config.secrets ?? {}))
+        text2 = text2.replaceAll(secretValue, `<secret>${secretName}</secret>`);
+      return text2;
+    };
+    const sections = await this._build();
+    const text = [];
+    for (const section of sections) {
+      if (!section.content.length)
+        continue;
+      text.push(`### ${section.title}`);
+      if (section.codeframe)
+        text.push(`\`\`\`${section.codeframe}`);
+      text.push(...section.content);
+      if (section.codeframe)
+        text.push("```");
+    }
+    const content = [
+      {
+        type: "text",
+        text: redactText(text.join("\n"))
+      }
+    ];
+    if (this._context.config.imageResponses !== "omit") {
+      for (const imageResult of this._imageResults) {
+        const scaledData = (0, import_screenshot.scaleImageToFitMessage)(imageResult.data, imageResult.imageType);
+        content.push({ type: "image", data: scaledData.toString("base64"), mimeType: imageResult.imageType === "png" ? "image/png" : "image/jpeg" });
+      }
+    }
+    return {
+      content,
+      ...sections.some((section) => section.isError) ? { isError: true } : {}
+    };
+  }
+  async _build() {
+    const sections = [];
+    const addSection = (title, content, codeframe) => {
+      const section = { title, content, isError: title === "Error", codeframe };
+      sections.push(section);
+      return content;
+    };
+    if (this._errors.length)
+      addSection("Error", this._errors);
+    if (this._results.length)
+      addSection("Result", this._results);
+    if (this._context.config.codegen !== "none" && this._code.length)
+      addSection("Ran Playwright code", this._code, "js");
+    const tabSnapshot = this._context.currentTab() ? await this._context.currentTabOrDie().captureSnapshot(this._clientWorkspace) : 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)
+        addSection("Open tabs", renderTabsMarkdown(tabHeaders));
+      addSection("Page", renderTabMarkdown(tabHeaders[0]));
+    }
+    if (tabSnapshot?.modalStates.length)
+      addSection("Modal state", (0, import_tab.renderModalStates)(this._context.config, tabSnapshot.modalStates));
+    if (tabSnapshot && this._includeSnapshot !== "none") {
+      const snapshot = this._includeSnapshot === "full" ? tabSnapshot.ariaSnapshot : tabSnapshot.ariaSnapshotDiff ?? tabSnapshot.ariaSnapshot;
+      if (this._context.config.outputMode === "file" || this._includeSnapshotFileName) {
+        const resolvedFile = await this.resolveClientFile({ prefix: "page", ext: "yml", suggestedFilename: this._includeSnapshotFileName }, "Snapshot");
+        await import_fs.default.promises.writeFile(resolvedFile.fileName, snapshot, "utf-8");
+        addSection("Snapshot", [resolvedFile.printableLink]);
+      } else {
+        addSection("Snapshot", [snapshot], "yaml");
+      }
+    }
+    const text = [];
+    if (tabSnapshot?.consoleLink)
+      text.push(`- New console entries: ${tabSnapshot.consoleLink}`);
+    if (tabSnapshot?.events.filter((event) => event.type !== "request").length) {
+      for (const event of tabSnapshot.events) {
+        if (event.type === "console" && this._context.config.outputMode !== "file") {
+          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 "${this._computRelativeTo(event.download.outputFile)}"`);
+        }
+      }
+    }
+    if (text.length)
+      addSection("Events", text);
+    return sections;
+  }
+}
+function renderTabMarkdown(tab) {
+  const lines = [`- Page URL: ${tab.url}`];
+  if (tab.title)
+    lines.push(`- Page Title: ${tab.title}`);
+  if (tab.console.errors || tab.console.warnings)
+    lines.push(`- Console: ${tab.console.errors} errors, ${tab.console.warnings} warnings`);
+  return lines;
+}
+function renderTabsMarkdown(tabs) {
+  if (!tabs.length)
+    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.current ? " (current)" : "";
+    lines.push(`- ${i}:${current} [${tab.title}](${tab.url})`);
+  }
+  return lines;
+}
+function trimMiddle(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, Math.floor(maxLength / 2)) + "..." + text.slice(-3 - Math.floor(maxLength / 2));
+}
+function parseSections(text) {
+  const sections = /* @__PURE__ */ new Map();
+  const sectionHeaders = text.split(/^### /m).slice(1);
+  for (const section of sectionHeaders) {
+    const firstNewlineIndex = section.indexOf("\n");
+    if (firstNewlineIndex === -1)
+      continue;
+    const sectionName = section.substring(0, firstNewlineIndex);
+    const sectionContent = section.substring(firstNewlineIndex + 1).trim();
+    sections.set(sectionName, sectionContent);
+  }
+  return sections;
+}
+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 page = sections.get("Page");
+  const snapshot = sections.get("Snapshot");
+  const events = sections.get("Events");
+  const modalState = sections.get("Modal state");
+  const codeNoFrame = code?.replace(/^```js\n/, "").replace(/\n```$/, "");
+  const isError = response.isError;
+  const attachments = response.content.length > 1 ? response.content.slice(1) : void 0;
+  return {
+    result,
+    error,
+    code: codeNoFrame,
+    tabs,
+    page,
+    snapshot,
+    events,
+    modalState,
+    isError,
+    attachments,
+    text
+  };
+}
+function sanitizeSnapshotFileName(fileName) {
+  if (typeof fileName !== "string")
+    return void 0;
+  let safeName = fileName.trim();
+  if (!safeName)
+    return void 0;
+  const maybeUrl = safeName.match(/^[a-z][a-z0-9+.-]*:\/\//i);
+  if (maybeUrl) {
+    try {
+      const parsedUrl = new URL(safeName);
+      const pathname = parsedUrl.pathname || "";
+      const segments = pathname.split("/").filter(Boolean);
+      safeName = segments[segments.length - 1] || "snapshot";
+      if (safeName.includes(".") && safeName.startsWith("."))
+        safeName = "snapshot" + safeName;
+    } catch (error) {
+    }
+  }
+  safeName = safeName.split(/[\\/]/).filter(Boolean).at(-1) || safeName;
+  safeName = safeName.replace(/[#?].*$/, "");
+  if (safeName.includes(":"))
+    safeName = safeName.split(":").at(-1);
+  safeName = safeName.replace(/[^a-zA-Z0-9._-]/g, "_");
+  safeName = safeName.replace(/_+/g, "_");
+  safeName = safeName.replace(/^_+|_+$/g, "");
+  if (!safeName)
+    return void 0;
+  return safeName.slice(0, 100);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Response,
+  parseResponse,
+  renderTabMarkdown,
+  renderTabsMarkdown,
+  requestDebug
+});