@tontoko/fast-playwright-mcp 0.0.4

package/lib/tools/utils.js

@@ -0,0 +1,131 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/utils.ts
+import debug from "debug";
+import { asLocator } from "playwright-core/lib/utils";
+import { TIMEOUTS } from "../config/constants.js";
+var toolsDebug = debug("pw:mcp:tools");
+async function waitForCompletion(tab, callback) {
+  const requests = new Set;
+  let frameNavigated = false;
+  let navigationCompleted = false;
+  let waitCallback = () => {};
+  const waitBarrier = new Promise((f) => {
+    waitCallback = f;
+  });
+  const requestListener = (request) => requests.add(request);
+  const requestFinishedListener = (request) => {
+    requests.delete(request);
+    if (!requests.size && navigationCompleted) {
+      waitCallback();
+    }
+  };
+  const frameNavigateListener = (frame) => {
+    if (frame.parentFrame()) {
+      return;
+    }
+    frameNavigated = true;
+    (async () => {
+      try {
+        await tab.waitForLoadState("load");
+        await tab.waitForLoadState("networkidle", {
+          timeout: getNavigationConfig().networkIdleTimeout
+        }).catch((error) => {
+          toolsDebug("Network idle timeout reached:", error);
+        });
+        navigationCompleted = true;
+        if (!requests.size) {
+          waitCallback();
+        }
+      } catch (error) {
+        toolsDebug("Load state waiting failed, continuing:", error);
+        navigationCompleted = true;
+        waitCallback();
+      }
+    })().catch((error) => {
+      toolsDebug("Navigation handling failed:", error);
+      navigationCompleted = true;
+      waitCallback();
+    });
+  };
+  const onTimeout = () => {
+    dispose();
+    navigationCompleted = true;
+    waitCallback();
+  };
+  tab.page.on("request", requestListener);
+  tab.page.on("requestfinished", requestFinishedListener);
+  tab.page.on("framenavigated", frameNavigateListener);
+  const timeout = setTimeout(onTimeout, getNavigationConfig().completionTimeout);
+  const dispose = () => {
+    tab.page.off("request", requestListener);
+    tab.page.off("requestfinished", requestFinishedListener);
+    tab.page.off("framenavigated", frameNavigateListener);
+    clearTimeout(timeout);
+  };
+  try {
+    const result = await callback();
+    if (!(requests.size || frameNavigated)) {
+      navigationCompleted = true;
+      waitCallback();
+    }
+    await waitBarrier;
+    if (frameNavigated) {
+      await tab.waitForTimeout(getNavigationConfig().stabilityWait);
+      try {
+        await tab.page.evaluate(() => document.readyState);
+      } catch (error) {
+        toolsDebug("Page readyState check failed (context may be destroyed):", error);
+      }
+    } else {
+      await tab.waitForTimeout(getNavigationConfig().defaultWait);
+    }
+    return result;
+  } finally {
+    dispose();
+  }
+}
+async function generateLocator(locator) {
+  try {
+    const { resolvedSelector } = await locator._resolveSelector();
+    return asLocator("javascript", resolvedSelector);
+  } catch (error) {
+    toolsDebug("Locator generation failed:", error);
+    throw new Error("Ref not found, likely because element was removed. Use browser_snapshot to see what elements are currently on the page.");
+  }
+}
+async function callOnPageNoTrace(page, callback) {
+  return await page._wrapApiCall(() => callback(page), {
+    internal: true
+  });
+}
+function getNavigationConfig() {
+  return {
+    networkIdleTimeout: TIMEOUTS.NETWORK_IDLE_TIMEOUT,
+    completionTimeout: 15000,
+    stabilityWait: TIMEOUTS.STABILITY_WAIT,
+    defaultWait: TIMEOUTS.WAIT_FOR_COMPLETION
+  };
+}
+export {
+  waitForCompletion,
+  generateLocator,
+  callOnPageNoTrace
+};

package/lib/tools/wait.js

@@ -0,0 +1,64 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/wait.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTool } from "./tool.js";
+var wait = defineTool({
+  capability: "core",
+  schema: {
+    name: "browser_wait_for",
+    title: "Wait for",
+    description: `Wait for text to appear/disappear or time to pass.PREFER text-based wait over time for reliability.For loading states:wait for text:"Loading..." textGone:true.For dynamic content:wait for specific text to appear.expectation:{includeSnapshot:true,snapshotOptions:{selector:"#status"},diffOptions:{enabled:true}} shows only what changed.AVOID:fixed time waits unless necessary.`,
+    inputSchema: z.object({
+      time: z.number().optional().describe("The time to wait in seconds"),
+      text: z.string().optional().describe("The text to wait for"),
+      textGone: z.string().optional().describe("The text to wait for to disappear"),
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    if (!(params.text || params.textGone || params.time)) {
+      throw new Error("Either time, text or textGone must be provided");
+    }
+    if (params.time) {
+      response.addCode(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
+      await new Promise((f) => setTimeout(f, Math.min(30000, (params.time ?? 0) * 1000)));
+    }
+    const tab = context.currentTabOrDie();
+    const locator = params.text ? tab.page.getByText(params.text).first() : undefined;
+    const goneLocator = params.textGone ? tab.page.getByText(params.textGone).first() : undefined;
+    if (goneLocator) {
+      response.addCode(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
+      await goneLocator.waitFor({ state: "hidden" });
+    }
+    if (locator) {
+      response.addCode(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
+      await locator.waitFor({ state: "visible" });
+    }
+    response.addResult(`Waited for ${params.text ?? params.textGone ?? params.time}`);
+    response.setIncludeSnapshot();
+  }
+});
+var wait_default = [wait];
+export {
+  wait_default as default
+};

package/lib/tools.js

@@ -0,0 +1,65 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools.ts
+import { batchExecuteTool } from "./tools/batch-execute.js";
+import common from "./tools/common.js";
+import console from "./tools/console.js";
+import { browserDiagnose } from "./tools/diagnose.js";
+import dialogs from "./tools/dialogs.js";
+import evaluate from "./tools/evaluate.js";
+import files from "./tools/files.js";
+import { browserFindElements } from "./tools/find-elements.js";
+import install from "./tools/install.js";
+import keyboard from "./tools/keyboard.js";
+import mouse from "./tools/mouse.js";
+import navigate from "./tools/navigate.js";
+import network from "./tools/network.js";
+import pdf from "./tools/pdf.js";
+import screenshot from "./tools/screenshot.js";
+import snapshot from "./tools/snapshot.js";
+import tabs from "./tools/tabs.js";
+import wait from "./tools/wait.js";
+var allTools = [
+  ...common,
+  ...console,
+  ...dialogs,
+  ...evaluate,
+  ...files,
+  ...install,
+  ...keyboard,
+  ...navigate,
+  ...network,
+  ...mouse,
+  ...pdf,
+  ...screenshot,
+  ...snapshot,
+  ...tabs,
+  ...wait,
+  batchExecuteTool,
+  browserFindElements,
+  browserDiagnose
+];
+function filteredTools(config) {
+  return allTools.filter((tool) => tool.capability.startsWith("core") || config.capabilities?.includes(tool.capability));
+}
+export {
+  filteredTools,
+  allTools
+};

package/lib/types/batch.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/types/batch.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+var parseJsonString = (val) => {
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  return val;
+};
+var batchStepSchema = z.object({
+  tool: z.string().describe("Tool name to execute"),
+  arguments: z.record(z.unknown()).describe("Arguments for the tool"),
+  continueOnError: z.boolean().optional().default(false).describe("Continue batch execution if this step fails"),
+  expectation: expectationSchema.describe("Expected output configuration for this step")
+});
+var batchExecuteSchema = z.object({
+  steps: z.array(batchStepSchema).min(1).describe("Array of steps to execute in sequence"),
+  stopOnFirstError: z.boolean().optional().default(false).describe("Stop entire batch on first error"),
+  globalExpectation: z.preprocess(parseJsonString, expectationSchema).optional().describe("Default expectation for all steps")
+});
+export {
+  batchStepSchema,
+  batchExecuteSchema
+};

package/lib/utils/array-utils.js

@@ -0,0 +1,44 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/array-utils.ts
+function deduplicateAndLimit(items, limit) {
+  const unique = [...new Set(items)];
+  return limit ? unique.slice(0, limit) : unique;
+}
+function deduplicate(items) {
+  return [...new Set(items)];
+}
+function limitItems(items, limit) {
+  return limit > 0 ? items.slice(0, limit) : items;
+}
+function filterTruthy(items) {
+  return items.filter((item) => Boolean(item));
+}
+function joinFiltered(items, separator = `
+`) {
+  return filterTruthy(items).join(separator);
+}
+export {
+  limitItems,
+  joinFiltered,
+  filterTruthy,
+  deduplicateAndLimit,
+  deduplicate
+};

package/lib/utils/code-deduplication-utils.js

@@ -0,0 +1,141 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/code-deduplication-utils.ts
+import { formatDiagnosticPair } from "./common-formatters.js";
+var formatDiagnosticKeyValue = formatDiagnosticPair;
+function formatElementCounts(counts) {
+  const results = [];
+  if (counts.total !== undefined) {
+    results.push(formatDiagnosticPair("Total elements", counts.total));
+  }
+  if (counts.visible !== undefined) {
+    results.push(formatDiagnosticPair("Visible elements", counts.visible));
+  }
+  if (counts.interactable !== undefined) {
+    results.push(formatDiagnosticPair("Interactable elements", counts.interactable));
+  }
+  if (counts.disabled !== undefined) {
+    results.push(formatDiagnosticPair("Disabled elements", counts.disabled));
+  }
+  return results;
+}
+function formatListItems(items, level = 0) {
+  const indent = "  ".repeat(level);
+  return items.map((item) => `${indent}- ${item}`);
+}
+
+class ArrayBuilder {
+  items = [];
+  constructor(initial) {
+    if (initial) {
+      this.items = [...initial];
+    }
+  }
+  add(item) {
+    this.items.push(item);
+    return this;
+  }
+  addAll(items) {
+    this.items.push(...items);
+    return this;
+  }
+  addIf(condition, item) {
+    const shouldAdd = typeof condition === "function" ? condition() : condition;
+    if (shouldAdd) {
+      const itemToAdd = typeof item === "function" ? item() : item;
+      this.items.push(itemToAdd);
+    }
+    return this;
+  }
+  addAllIf(condition, items) {
+    const shouldAdd = typeof condition === "function" ? condition() : condition;
+    if (shouldAdd) {
+      const itemsToAdd = typeof items === "function" ? items() : items;
+      this.items.push(...itemsToAdd);
+    }
+    return this;
+  }
+  build() {
+    return [...this.items];
+  }
+  getItems() {
+    return [...this.items];
+  }
+  clear() {
+    this.items = [];
+    return this;
+  }
+}
+function joinLines(lines) {
+  return lines.join(`
+`);
+}
+function truncateAtWordBoundary(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  let truncateIndex = maxLength;
+  if (text[maxLength] && text[maxLength] !== " " && text[maxLength] !== `
+`) {
+    for (let i = maxLength - 1;i >= 0; i--) {
+      if (text[i] === " " || text[i] === `
+`) {
+        truncateIndex = i;
+        break;
+      }
+    }
+    if (maxLength - truncateIndex > 20) {
+      truncateIndex = maxLength;
+    }
+  }
+  return text.substring(0, truncateIndex).trim();
+}
+function formatError(error) {
+  const result = [`Error: ${error.message}`];
+  if (error.suggestions && error.suggestions.length > 0) {
+    result.push("", "Suggestions:");
+    result.push(...error.suggestions.map((s) => `- ${s}`));
+  }
+  return result;
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "success":
+      return "✅";
+    case "warning":
+      return "⚠️";
+    case "error":
+      return "\uD83D\uDEA8";
+    case "info":
+      return "ℹ️";
+    default:
+      return "⚪";
+  }
+}
+export {
+  truncateAtWordBoundary,
+  joinLines,
+  getStatusIcon,
+  formatListItems,
+  formatError,
+  formatElementCounts,
+  formatDiagnosticKeyValue,
+  ArrayBuilder
+};