@tontoko/fast-playwright-mcp 0.0.4

package/lib/utils/disposable-manager.js

@@ -0,0 +1,135 @@
+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/disposable-manager.ts
+import { handleResourceDisposalError } from "./common-formatters.js";
+
+class DisposableManager {
+  disposables = new Set;
+  category;
+  maxParallelDisposals;
+  disposed = false;
+  constructor(options = {}) {
+    this.category = options.category ?? "DisposableManager";
+    this.maxParallelDisposals = options.maxParallelDisposals ?? 10;
+  }
+  register(resource) {
+    if (this.disposed) {
+      throw new Error("Cannot register resource: DisposableManager already disposed");
+    }
+    this.disposables.add(resource);
+    return resource;
+  }
+  unregister(resource) {
+    return this.disposables.delete(resource);
+  }
+  getRegisteredCount() {
+    return this.disposables.size;
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    const resources = Array.from(this.disposables);
+    if (resources.length === 0) {
+      return;
+    }
+    await this.disposeInBatches(resources);
+    this.disposables.clear();
+  }
+  async disposeInBatches(resources) {
+    const batches = this.createBatches(resources, this.maxParallelDisposals);
+    await this.disposeBatchesRecursive(batches, 0);
+  }
+  async disposeBatchesRecursive(batches, index) {
+    if (index >= batches.length) {
+      return;
+    }
+    const batch = batches[index];
+    const disposePromises = batch.map((resource) => this.safeDisposeResource(resource));
+    const results = await Promise.allSettled(disposePromises);
+    this.logDisposalResults(results, batch.length);
+    await this.disposeBatchesRecursive(batches, index + 1);
+  }
+  createBatches(items, batchSize) {
+    const batches = [];
+    for (let i = 0;i < items.length; i += batchSize) {
+      batches.push(items.slice(i, i + batchSize));
+    }
+    return batches;
+  }
+  async safeDisposeResource(resource) {
+    try {
+      await resource.dispose();
+    } catch (error) {
+      handleResourceDisposalError(error, `${this.category} resource`, () => {});
+    }
+  }
+  logDisposalResults(results, batchSize) {
+    const failures = results.filter((result) => result.status === "rejected").length;
+    const _successes = batchSize - failures;
+  }
+}
+function createDisposableManager(category, options = {}) {
+  return new DisposableManager({ ...options, category });
+}
+
+class AutoDisposableWrapper {
+  disposed = false;
+  resource;
+  constructor(resource, timeoutMs) {
+    this.resource = resource;
+    if (timeoutMs !== undefined) {
+      setTimeout(() => {
+        if (!this.disposed) {
+          this.dispose();
+        }
+      }, timeoutMs);
+    }
+  }
+  get() {
+    if (this.disposed) {
+      throw new Error("Cannot access disposed resource");
+    }
+    return this.resource;
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    await this.resource.dispose();
+  }
+}
+function createAutoDisposable(resource, timeoutMs) {
+  return new AutoDisposableWrapper(resource, timeoutMs);
+}
+export {
+  createDisposableManager,
+  createAutoDisposable,
+  DisposableManager,
+  AutoDisposableWrapper
+};

package/lib/utils/error-handler-middleware.js

@@ -0,0 +1,77 @@
+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/error-handler-middleware.ts
+import debug from "debug";
+import { getErrorMessage } from "./common-formatters.js";
+var errorHandlerDebug = debug("pw:mcp:error-handler");
+async function withErrorHandling(operation, context) {
+  try {
+    const result = await operation();
+    return result;
+  } catch (error) {
+    const message = getErrorMessage(error);
+    const contextInfo = context ? `[${context.component || "Unknown"}:${context.operationName || "operation"}]` : "[Unknown:operation]";
+    const enrichedError = new Error(`${contextInfo} ${message}`);
+    enrichedError.cause = error;
+    if (context?.onError) {
+      context.onError(enrichedError);
+    }
+    throw enrichedError;
+  }
+}
+function withErrorHandlingSync(operation, context) {
+  try {
+    return operation();
+  } catch (error) {
+    const message = getErrorMessage(error);
+    const contextInfo = context ? `[${context.component || "Unknown"}:${context.operationName || "operation"}]` : "[Unknown:operation]";
+    const enrichedError = new Error(`${contextInfo} ${message}`);
+    enrichedError.cause = error;
+    if (context?.onError) {
+      context.onError(enrichedError);
+    }
+    throw enrichedError;
+  }
+}
+function createBatchErrorHandler(componentName) {
+  return (error, stepName) => {
+    const message = getErrorMessage(error);
+    const step = stepName ? ` (step: ${stepName})` : "";
+    return new Error(`[${componentName}] Batch operation failed${step}: ${message}`);
+  };
+}
+function createErrorReporter(component) {
+  return {
+    reportAndThrow(error, operation) {
+      const message = getErrorMessage(error);
+      throw new Error(`[${component}:${operation}] ${message}`);
+    },
+    reportWarning(error, operation) {
+      const message = getErrorMessage(error);
+      errorHandlerDebug(`[${component}:${operation}] Warning: ${message}`);
+    }
+  };
+}
+export {
+  withErrorHandlingSync,
+  withErrorHandling,
+  createErrorReporter,
+  createBatchErrorHandler
+};

package/lib/utils/image-processor.js

@@ -0,0 +1,137 @@
+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/image-processor.ts
+import sharp from "sharp";
+function validateImageOptions(options) {
+  const errors = [];
+  if (options.quality !== undefined && (options.quality < 1 || options.quality > 100)) {
+    errors.push("quality must be between 1 and 100");
+  }
+  if (options.maxWidth !== undefined && options.maxWidth <= 0) {
+    errors.push("maxWidth must be greater than 0");
+  }
+  if (options.maxHeight !== undefined && options.maxHeight <= 0) {
+    errors.push("maxHeight must be greater than 0");
+  }
+  return errors;
+}
+async function processImageWithoutOptions(data, contentType) {
+  try {
+    const metadata = await sharp(data).metadata();
+    return {
+      data,
+      contentType,
+      originalSize: {
+        width: metadata.width || 0,
+        height: metadata.height || 0
+      },
+      processedSize: {
+        width: metadata.width || 0,
+        height: metadata.height || 0
+      },
+      compressionRatio: 1
+    };
+  } catch {
+    return {
+      data,
+      contentType,
+      originalSize: { width: 0, height: 0 },
+      processedSize: { width: 0, height: 0 },
+      compressionRatio: 1
+    };
+  }
+}
+function applyFormatConversion(image, format, quality) {
+  const outputContentType = `image/${format}`;
+  let processedImage = image;
+  switch (format) {
+    case "jpeg":
+      processedImage = image.jpeg({ quality: quality || 80 });
+      break;
+    case "png":
+      processedImage = image.png({ quality: quality || 100 });
+      break;
+    case "webp":
+      processedImage = image.webp({ quality: quality || 80 });
+      break;
+    default:
+      break;
+  }
+  return { image: processedImage, contentType: outputContentType };
+}
+function applyQualityToExistingFormat(image, contentType, quality) {
+  if (contentType.includes("jpeg")) {
+    return image.jpeg({ quality });
+  }
+  if (contentType.includes("png")) {
+    return image.png({ quality });
+  }
+  if (contentType.includes("webp")) {
+    return image.webp({ quality });
+  }
+  return image;
+}
+async function processImage(data, contentType, options) {
+  if (!options || Object.keys(options).length === 0) {
+    return processImageWithoutOptions(data, contentType);
+  }
+  try {
+    const originalMetadata = await sharp(data).metadata();
+    const originalSize = {
+      width: originalMetadata.width || 0,
+      height: originalMetadata.height || 0
+    };
+    let image = sharp(data);
+    if (options.maxWidth || options.maxHeight) {
+      image = image.resize(options.maxWidth, options.maxHeight, {
+        fit: "inside",
+        withoutEnlargement: true
+      });
+    }
+    let outputContentType = contentType;
+    if (options.format) {
+      const result = applyFormatConversion(image, options.format, options.quality);
+      image = result.image;
+      outputContentType = result.contentType;
+    } else if (options.quality) {
+      image = applyQualityToExistingFormat(image, contentType, options.quality);
+    }
+    const processedBuffer = await image.toBuffer();
+    const processedMetadata = await sharp(processedBuffer).metadata();
+    const processedSize = {
+      width: processedMetadata.width || originalSize.width,
+      height: processedMetadata.height || originalSize.height
+    };
+    const compressionRatio = processedBuffer.length / data.length;
+    return {
+      data: processedBuffer,
+      contentType: outputContentType,
+      originalSize,
+      processedSize,
+      compressionRatio
+    };
+  } catch (error) {
+    throw new Error(`Image processing failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+export {
+  validateImageOptions,
+  processImage
+};

package/lib/utils/index.js

@@ -0,0 +1,92 @@
+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/index.ts
+import {
+  deduplicate,
+  deduplicateAndLimit,
+  filterTruthy,
+  joinFiltered,
+  limitItems
+} from "./array-utils.js";
+import {
+  ArrayBuilder,
+  formatDiagnosticKeyValue,
+  formatElementCounts,
+  formatError,
+  formatListItems,
+  getStatusIcon,
+  joinLines,
+  truncateAtWordBoundary
+} from "./code-deduplication-utils.js";
+import {
+  formatConfidence,
+  formatDiagnosticPair,
+  formatExecutionTime,
+  getErrorMessage,
+  handleResourceDisposalError
+} from "./common-formatters.js";
+import { createDisposableManager } from "./disposable-manager.js";
+import {
+  addMouseOperationComment,
+  addNavigationComment,
+  addOperationComment,
+  addToolErrorContext,
+  applyCommonExpectations,
+  executeToolOperation,
+  resolveElementLocator,
+  setupToolResponse,
+  ToolPatterns,
+  validateAndResolveElement,
+  validateElementParams,
+  waitForToolCompletion
+} from "./tool-patterns.js";
+export {
+  waitForToolCompletion,
+  validateElementParams,
+  validateAndResolveElement,
+  truncateAtWordBoundary,
+  setupToolResponse,
+  resolveElementLocator,
+  limitItems,
+  joinLines,
+  joinFiltered,
+  handleResourceDisposalError,
+  getStatusIcon,
+  getErrorMessage,
+  formatListItems,
+  formatExecutionTime,
+  formatError,
+  formatElementCounts,
+  formatDiagnosticPair,
+  formatDiagnosticKeyValue,
+  formatConfidence,
+  filterTruthy,
+  executeToolOperation,
+  deduplicateAndLimit,
+  deduplicate,
+  createDisposableManager,
+  applyCommonExpectations,
+  addToolErrorContext,
+  addOperationComment,
+  addNavigationComment,
+  addMouseOperationComment,
+  ToolPatterns,
+  ArrayBuilder
+};

package/lib/utils/report-builder.js

@@ -0,0 +1,189 @@
+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/report-builder.ts
+import { formatConfidence } from "./common-formatters.js";
+
+class TextReportBuilder {
+  sections = [];
+  constructor() {
+    this.sections = [];
+  }
+  addHeader(text, level = 2) {
+    const prefix = "#".repeat(level);
+    this.sections.push(`${prefix} ${text}`);
+    return this;
+  }
+  addLine(text) {
+    this.sections.push(text);
+    return this;
+  }
+  addLines(lines) {
+    this.sections.push(...lines);
+    return this;
+  }
+  addListItem(text, level = 0) {
+    const indent = "  ".repeat(level);
+    this.sections.push(`${indent}- ${text}`);
+    return this;
+  }
+  addKeyValue(key, value, level = 0) {
+    const indent = "  ".repeat(level);
+    this.sections.push(`${indent}- **${key}:** ${value}`);
+    return this;
+  }
+  addEmptyLine() {
+    this.sections.push("");
+    return this;
+  }
+  addCodeBlock(code, language = "") {
+    this.sections.push(`\`\`\`${language}`);
+    this.sections.push(code);
+    this.sections.push("```");
+    return this;
+  }
+  addIf(condition, builder) {
+    const shouldAdd = typeof condition === "function" ? condition() : condition;
+    if (shouldAdd) {
+      builder(this);
+    }
+    return this;
+  }
+  addSection(title, builder, level = 2) {
+    this.addEmptyLine();
+    this.addHeader(title, level);
+    builder(this);
+    return this;
+  }
+  build() {
+    return this.sections.join(`
+`);
+  }
+  getSections() {
+    return [...this.sections];
+  }
+  clear() {
+    this.sections = [];
+    return this;
+  }
+}
+
+class PerformanceReportBuilder extends TextReportBuilder {
+  addMetric(name, value, unit, threshold, level = 0) {
+    let text = `**${name}:** ${value}${unit}`;
+    if (threshold && value > threshold) {
+      text += ` ⚠️ (threshold: ${threshold}${unit})`;
+    }
+    this.addListItem(text, level);
+    return this;
+  }
+  addTiming(name, timeMs, thresholdMs, level = 0) {
+    return this.addMetric(name, Math.round(timeMs), "ms", thresholdMs, level);
+  }
+  addPercentage(name, value, level = 0) {
+    const percentage = Math.round(value * 100);
+    this.addListItem(`**${name}:** ${percentage}%`, level);
+    return this;
+  }
+}
+
+class DiagnosticReportBuilder extends TextReportBuilder {
+  addDiagnosticInfo(label, value, level = 0) {
+    let formattedValue;
+    if (typeof value === "boolean") {
+      formattedValue = value ? "Yes" : "No";
+    } else if (typeof value === "number") {
+      formattedValue = value.toString();
+    } else {
+      formattedValue = value;
+    }
+    this.addKeyValue(label, formattedValue, level);
+    return this;
+  }
+  addDiagnosticSection(title, data, formatter, level = 2) {
+    return this.addSection(title, (builder) => {
+      if (data) {
+        try {
+          formatter(data);
+        } catch (error) {
+          builder.addListItem(`Error formatting diagnostic data: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      } else {
+        builder.addListItem("No data available");
+      }
+    }, level);
+  }
+  addElementCounts(counts) {
+    if (counts.total !== undefined) {
+      this.addDiagnosticInfo("Total elements", counts.total);
+    }
+    if (counts.visible !== undefined) {
+      this.addDiagnosticInfo("Visible elements", counts.visible);
+    }
+    if (counts.interactable !== undefined) {
+      this.addDiagnosticInfo("Interactable elements", counts.interactable);
+    }
+    if (counts.disabled !== undefined) {
+      this.addDiagnosticInfo("Disabled elements", counts.disabled);
+    }
+    return this;
+  }
+}
+function formatFileSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)}${units[unitIndex]}`;
+}
+function getPerformanceStatusIcon(value, thresholds) {
+  if (value <= thresholds.good) {
+    return "\uD83D\uDFE2";
+  }
+  if (value <= thresholds.warning) {
+    return "\uD83D\uDFE1";
+  }
+  return "\uD83D\uDD34";
+}
+function getReportStatusIcon(status) {
+  switch (status) {
+    case "success":
+      return "✅";
+    case "warning":
+      return "⚠️";
+    case "error":
+      return "\uD83D\uDEA8";
+    case "info":
+      return "ℹ️";
+    default:
+      return "⚪";
+  }
+}
+export {
+  getReportStatusIcon,
+  getPerformanceStatusIcon,
+  formatFileSize,
+  formatConfidence as formatConfidencePercentage,
+  TextReportBuilder,
+  PerformanceReportBuilder,
+  DiagnosticReportBuilder
+};

package/lib/utils/request-logger.js

@@ -0,0 +1,82 @@
+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/request-logger.ts
+import { randomBytes } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { requestDebug } from "../log.js";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var PROJECT_ROOT = join(__dirname2, "..", "..");
+var LOG_DIR = join(PROJECT_ROOT, "logs");
+var LOG_FILE = join(LOG_DIR, "mcp-requests.log");
+var FILE_LOGGING_ENABLED = process.env.PLAYWRIGHT_MCP_LOG_REQUESTS === "file" || process.env.PLAYWRIGHT_MCP_LOG_REQUESTS === "both";
+if (FILE_LOGGING_ENABLED && !existsSync(LOG_DIR)) {
+  mkdirSync(LOG_DIR, { recursive: true });
+}
+function logRequest(toolName, params) {
+  try {
+    const timestamp = new Date().toISOString();
+    const requestId = randomBytes(4).toString("hex");
+    requestDebug("Tool: %s (ID: %s) - Parameters: %o", toolName, requestId, params);
+    if (FILE_LOGGING_ENABLED) {
+      const logEntry = [
+        `[${timestamp}] Tool: ${toolName} (ID: ${requestId})`,
+        `Parameters: ${JSON.stringify(params, null, 2)}`,
+        "---"
+      ].join(`
+`);
+      appendFileSync(LOG_FILE, `${logEntry}
+`, "utf-8");
+    }
+  } catch (error) {
+    requestDebug("Failed to log request: %o", error);
+  }
+}
+function getLogFilePath() {
+  return LOG_FILE;
+}
+function logServerStart() {
+  try {
+    const timestamp = new Date().toISOString();
+    requestDebug("=== MCP Server Started === PID: %d, Node: %s", process.pid, process.version);
+    if (FILE_LOGGING_ENABLED) {
+      const logEntry = [
+        `[${timestamp}] === MCP Server Started ===`,
+        `Process ID: ${process.pid}`,
+        `Node Version: ${process.version}`,
+        `Log Mode: ${process.env.PLAYWRIGHT_MCP_LOG_REQUESTS ?? "debug only"}`,
+        "---"
+      ].join(`
+`);
+      appendFileSync(LOG_FILE, `${logEntry}
+`, "utf-8");
+      requestDebug("Request logging to file enabled: %s", LOG_FILE);
+    }
+  } catch (error) {
+    requestDebug("Failed to log server start: %o", error);
+  }
+}
+export {
+  logServerStart,
+  logRequest,
+  getLogFilePath
+};