@tontoko/fast-playwright-mcp 0.0.4

package/lib/diagnostics/parallel-page-analyzer.js

@@ -0,0 +1,129 @@
+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/diagnostics/parallel-page-analyzer.ts
+import { createDisposableManager } from "../utils/disposable-manager.js";
+import { PageAnalyzer } from "./page-analyzer.js";
+
+class ParallelPageAnalyzer {
+  pageAnalyzer;
+  disposableManager = createDisposableManager("ParallelPageAnalyzer");
+  constructor(page) {
+    this.pageAnalyzer = this.disposableManager.register(new PageAnalyzer(page));
+  }
+  async runParallelAnalysis() {
+    const startTime = Date.now();
+    const errors = [];
+    let structureAnalysis;
+    let performanceMetrics;
+    try {
+      const analysisPromises = [
+        this.executeAnalysis("structure-analysis", async () => {
+          return await this.pageAnalyzer.analyzePageStructure();
+        }),
+        this.executeAnalysis("performance-metrics", async () => {
+          return await this.pageAnalyzer.analyzePerformanceMetrics();
+        })
+      ];
+      const results = await Promise.allSettled(analysisPromises);
+      const processedResults = this.processAnalysisResults(results, errors);
+      structureAnalysis = processedResults.structureAnalysis;
+      performanceMetrics = processedResults.performanceMetrics;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Parallel execution failed";
+      errors.push({
+        step: "parallel-execution",
+        error: errorMsg
+      });
+    }
+    const executionTime = Date.now() - startTime;
+    const convertedStructureAnalysis = structureAnalysis ? {
+      iframes: {
+        detected: structureAnalysis.iframes.detected,
+        count: structureAnalysis.iframes.count,
+        accessible: structureAnalysis.iframes.accessible.map((iframe) => ({
+          id: iframe.src || "unknown",
+          url: iframe.src || "",
+          title: iframe.src || "iframe",
+          contentAccessible: iframe.accessible,
+          crossOrigin: false
+        })),
+        inaccessible: structureAnalysis.iframes.inaccessible.map((iframe, index) => ({
+          id: iframe.reason || `inaccessible-${index}`,
+          reason: iframe.reason || "Unknown reason",
+          url: iframe.src,
+          title: iframe.src || "inaccessible iframe"
+        }))
+      },
+      modalStates: structureAnalysis.modalStates,
+      elements: structureAnalysis.elements
+    } : {
+      iframes: {
+        detected: false,
+        count: 0,
+        accessible: [],
+        inaccessible: []
+      },
+      modalStates: {
+        hasDialog: false,
+        hasFileChooser: false,
+        blockedBy: []
+      },
+      elements: { totalVisible: 0, totalInteractable: 0, missingAria: 0 }
+    };
+    return {
+      structureAnalysis: convertedStructureAnalysis,
+      performanceMetrics: performanceMetrics ?? {},
+      resourceUsage: null,
+      executionTime,
+      errors
+    };
+  }
+  async executeAnalysis(_stepName, analysisFunction) {
+    return await analysisFunction();
+  }
+  processAnalysisResults(results, errors) {
+    let structureAnalysis;
+    let performanceMetrics;
+    for (let index = 0;index < results.length; index++) {
+      const result = results[index];
+      const stepName = index === 0 ? "structure-analysis" : "performance-metrics";
+      if (result.status === "fulfilled") {
+        if (stepName === "structure-analysis") {
+          structureAnalysis = result.value;
+        } else {
+          performanceMetrics = result.value;
+        }
+      } else {
+        const errorMsg = result.reason?.message ?? "Unknown error";
+        errors.push({
+          step: stepName,
+          error: errorMsg
+        });
+      }
+    }
+    return { structureAnalysis, performanceMetrics };
+  }
+  async dispose() {
+    await this.disposableManager.dispose();
+  }
+}
+export {
+  ParallelPageAnalyzer
+};

package/lib/diagnostics/resource-manager.js

@@ -0,0 +1,134 @@
+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/diagnostics/resource-manager.ts
+import debug from "debug";
+var resourceDebug = debug("pw:mcp:resource");
+
+class ResourceManager {
+  resources = new Map;
+  nextId = 0;
+  disposeTimeout = 30000;
+  cleanupInterval = null;
+  constructor() {
+    this.startCleanupTimer();
+  }
+  trackResource(resource, disposeMethod) {
+    const id = `resource_${this.nextId}`;
+    this.nextId++;
+    this.resources.set(id, {
+      resource,
+      disposeMethod,
+      timestamp: Date.now()
+    });
+    return id;
+  }
+  untrackResource(id) {
+    this.resources.delete(id);
+  }
+  async disposeAll() {
+    const disposePromises = [];
+    for (const [id, { resource, disposeMethod }] of Array.from(this.resources.entries())) {
+      try {
+        if (resource && typeof resource[disposeMethod] === "function") {
+          const disposeFn = resource[disposeMethod];
+          disposePromises.push(disposeFn());
+        }
+      } catch (error) {
+        resourceDebug(`Failed to dispose resource ${id}:`, error);
+      }
+    }
+    await Promise.allSettled(disposePromises);
+    this.resources.clear();
+  }
+  getActiveCount() {
+    return this.resources.size;
+  }
+  setDisposeTimeout(timeout) {
+    this.disposeTimeout = timeout;
+  }
+  getDisposeTimeout() {
+    return this.disposeTimeout;
+  }
+  createSmartHandle(resource, disposeMethod) {
+    const id = this.trackResource(resource, disposeMethod);
+    return { handle: resource, id };
+  }
+  getResourceStats() {
+    const now = Date.now();
+    let expiredCount = 0;
+    for (const [, { timestamp }] of Array.from(this.resources.entries())) {
+      if (now - timestamp > this.disposeTimeout) {
+        expiredCount++;
+      }
+    }
+    return {
+      totalTracked: this.resources.size,
+      activeCount: this.resources.size - expiredCount,
+      expiredCount,
+      memoryUsage: process.memoryUsage().heapUsed
+    };
+  }
+  startCleanupTimer() {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredResources().catch(() => {});
+    }, this.disposeTimeout / 2);
+  }
+  async cleanupExpiredResources() {
+    const now = Date.now();
+    const expiredIds = [];
+    for (const [id, { timestamp }] of Array.from(this.resources.entries())) {
+      if (now - timestamp > this.disposeTimeout) {
+        expiredIds.push(id);
+      }
+    }
+    const disposeSequentially = async (index) => {
+      if (index >= expiredIds.length) {
+        return;
+      }
+      const id = expiredIds[index];
+      const entry = this.resources.get(id);
+      if (entry) {
+        try {
+          if (entry.resource && typeof entry.resource[entry.disposeMethod] === "function") {
+            const disposeFn = entry.resource[entry.disposeMethod];
+            await disposeFn();
+          }
+        } catch (error) {
+          resourceDebug(`Failed to dispose expired resource ${id}:`, error);
+        }
+        this.untrackResource(id);
+      }
+      await disposeSequentially(index + 1);
+    };
+    await disposeSequentially(0);
+  }
+  async dispose() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    await this.disposeAll();
+  }
+}
+var globalResourceManager = new ResourceManager;
+export {
+  globalResourceManager,
+  ResourceManager
+};