@tontoko/fast-playwright-mcp 0.0.4

package/lib/diagnostics/frame-reference-manager.js

@@ -0,0 +1,179 @@
+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/frame-reference-manager.ts
+import debug from "debug";
+var frameDebug = debug("pw:mcp:frame");
+
+class FrameReferenceManager {
+  frameRefs = new WeakMap;
+  activeFrames = new Set;
+  cleanupInterval = null;
+  disposed = false;
+  constructor() {
+    this.startCleanupTimer();
+  }
+  trackFrame(frame) {
+    if (this.disposed) {
+      throw new Error("FrameReferenceManager has been disposed");
+    }
+    try {
+      const metadata = {
+        url: frame.url() ?? "about:blank",
+        name: frame.name() ?? null,
+        parentFrame: frame.parentFrame(),
+        isDetached: false,
+        timestamp: Date.now()
+      };
+      this.frameRefs.set(frame, metadata);
+      this.activeFrames.add(frame);
+    } catch (error) {
+      frameDebug("Frame tracking failed (frame might be detached):", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  untrackFrame(frame) {
+    this.activeFrames.delete(frame);
+  }
+  getFrameMetadata(frame) {
+    return this.frameRefs.get(frame);
+  }
+  getActiveFrames() {
+    return Array.from(this.activeFrames);
+  }
+  updateElementCount(frame, count) {
+    const metadata = this.frameRefs.get(frame);
+    if (metadata) {
+      metadata.elementCount = count;
+    }
+  }
+  async cleanupDetachedFrames() {
+    if (this.disposed) {
+      return;
+    }
+    const framesToRemove = [];
+    const frameCheckPromises = Array.from(this.activeFrames).map(async (frame) => {
+      try {
+        await Promise.race([
+          frame.url(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 1000))
+        ]);
+        return { frame, isDetached: false };
+      } catch (error) {
+        let frameUrl = "unknown";
+        try {
+          frameUrl = frame.url();
+        } catch (urlError) {
+          frameDebug("Could not retrieve frame URL:", urlError);
+        }
+        frameDebug("Frame accessibility check failed (frame likely detached):", {
+          url: frameUrl,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        return { frame, isDetached: true };
+      }
+    });
+    const frameCheckResults = await Promise.all(frameCheckPromises);
+    for (const { frame, isDetached } of frameCheckResults) {
+      if (isDetached) {
+        const metadata = this.frameRefs.get(frame);
+        if (metadata) {
+          metadata.isDetached = true;
+        }
+        framesToRemove.push(frame);
+      }
+    }
+    for (const frame of framesToRemove) {
+      this.activeFrames.delete(frame);
+    }
+  }
+  getStatistics() {
+    let detachedCount = 0;
+    let totalElements = 0;
+    let framesWithElementCount = 0;
+    for (const frame of Array.from(this.activeFrames)) {
+      const metadata = this.frameRefs.get(frame);
+      if (metadata) {
+        if (metadata.isDetached) {
+          detachedCount++;
+        }
+        if (typeof metadata.elementCount === "number") {
+          totalElements += metadata.elementCount;
+          framesWithElementCount++;
+        }
+      }
+    }
+    const averageElementCount = framesWithElementCount > 0 ? totalElements / framesWithElementCount : 0;
+    return {
+      activeCount: this.activeFrames.size,
+      totalTracked: this.activeFrames.size,
+      detachedCount,
+      averageElementCount: Math.round(averageElementCount)
+    };
+  }
+  findPerformanceIssues() {
+    const now = Date.now();
+    const largeFrames = [];
+    const oldFrames = [];
+    for (const frame of Array.from(this.activeFrames)) {
+      const metadata = this.frameRefs.get(frame);
+      if (metadata && !metadata.isDetached) {
+        if (typeof metadata.elementCount === "number" && metadata.elementCount > 1000) {
+          largeFrames.push({
+            frame,
+            elementCount: metadata.elementCount,
+            url: metadata.url
+          });
+        }
+        const age = now - metadata.timestamp;
+        if (age > 300000) {
+          oldFrames.push({
+            frame,
+            age,
+            url: metadata.url
+          });
+        }
+      }
+    }
+    return { largeFrames, oldFrames };
+  }
+  startCleanupTimer() {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupDetachedFrames().catch((error) => {
+        frameDebug("Frame cleanup timer failed:", error instanceof Error ? error.message : "Unknown error");
+      });
+    }, 30000);
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    await this.cleanupDetachedFrames();
+    this.activeFrames.clear();
+    this.disposed = true;
+  }
+}
+export {
+  FrameReferenceManager
+};