@tontoko/fast-playwright-mcp 0.0.4

package/lib/diagnostics/smart-config.js

@@ -0,0 +1,482 @@
+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/smart-config.ts
+import debug from "debug";
+import { DiagnosticLevel } from "./diagnostic-level.js";
+import { DiagnosticThresholds } from "./diagnostic-thresholds.js";
+var configDebug = debug("pw:mcp:config");
+
+class SmartConfigManager {
+  static instance;
+  config;
+  listeners = [];
+  thresholdsManager;
+  constructor(initialConfig) {
+    this.config = this.createDefaultConfig();
+    this.thresholdsManager = DiagnosticThresholds.getInstance();
+    if (initialConfig) {
+      this.updateConfig(initialConfig);
+    }
+  }
+  static getInstance(initialConfig) {
+    SmartConfigManager.instance ??= new SmartConfigManager(initialConfig);
+    if (!SmartConfigManager.instance) {
+      configDebug("Critical: SmartConfigManager instance is null after creation");
+      SmartConfigManager.instance = new SmartConfigManager(initialConfig);
+    }
+    return SmartConfigManager.instance;
+  }
+  static resetInstance() {
+    const wasNull = SmartConfigManager.instance === null;
+    SmartConfigManager.instance = null;
+    configDebug("SmartConfigManager instance reset", {
+      wasAlreadyNull: wasNull
+    });
+  }
+  createDefaultConfig() {
+    const defaultThresholds = DiagnosticThresholds.getInstance().getMetricsThresholds();
+    return {
+      autoDisposeTimeout: 30000,
+      maxConcurrentHandles: 100,
+      enableLeakDetection: true,
+      batchSizeLimit: 50,
+      parallelAnalysisEnabled: true,
+      diagnostic: {
+        level: DiagnosticLevel.STANDARD,
+        enableAlternativeSuggestions: true,
+        enablePageAnalysis: true,
+        enablePerformanceMetrics: true,
+        maxAlternatives: 5,
+        enableDetailedErrors: true
+      },
+      performance: {
+        enableMetricsCollection: true,
+        enableResourceMonitoring: true,
+        enablePerformanceWarnings: true,
+        autoOptimization: true,
+        thresholds: defaultThresholds
+      },
+      errorHandling: {
+        enableErrorEnrichment: true,
+        enableContextualSuggestions: true,
+        logLevel: "warn",
+        maxErrorHistory: 100,
+        enablePerformanceErrorDetection: true
+      },
+      features: {
+        enableParallelAnalysis: true,
+        enableSmartHandleManagement: true,
+        enableAdvancedElementDiscovery: true,
+        enableResourceLeakDetection: true,
+        enableRealTimeMonitoring: false
+      },
+      runtime: {
+        enableAdaptiveThresholds: true,
+        enableAutoTuning: false,
+        statsCollectionEnabled: true
+      }
+    };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(updates) {
+    this.config = this.mergeDeep(this.config, updates);
+    if (updates.performance?.thresholds) {
+      this.syncThresholdsWithManager(updates.performance.thresholds);
+    }
+    this.notifyListeners();
+  }
+  mergeDeep(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (Object.hasOwn(source, key)) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+          result[key] = {
+            ...targetValue,
+            ...sourceValue
+          };
+        } else {
+          result[key] = sourceValue;
+        }
+      }
+    }
+    return result;
+  }
+  onConfigChange(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      try {
+        listener(this.config);
+      } catch (error) {
+        configDebug("Config change listener failed:", error);
+      }
+    }
+  }
+  adjustThresholds(component, avgExecutionTime, successRate) {
+    if (!this.isAdaptiveThresholdsEnabled()) {
+      return;
+    }
+    const currentThreshold = this.config.performance.thresholds.executionTime[component];
+    if (avgExecutionTime > currentThreshold * 0.8 && successRate > 0.9) {
+      const newThreshold = Math.min(currentThreshold * 1.2, currentThreshold + 1000);
+      this.updateConfig({
+        performance: {
+          ...this.config.performance,
+          thresholds: {
+            ...this.config.performance.thresholds,
+            executionTime: {
+              ...this.config.performance.thresholds.executionTime,
+              [component]: newThreshold
+            }
+          }
+        }
+      });
+    }
+    if (avgExecutionTime < currentThreshold * 0.5 && successRate > 0.95) {
+      const newThreshold = Math.max(currentThreshold * 0.9, 100);
+      this.updateConfig({
+        performance: {
+          ...this.config.performance,
+          thresholds: {
+            ...this.config.performance.thresholds,
+            executionTime: {
+              ...this.config.performance.thresholds.executionTime,
+              [component]: newThreshold
+            }
+          }
+        }
+      });
+    }
+  }
+  getComponentConfig(component) {
+    const base = {
+      diagnostic: this.config.diagnostic,
+      performance: this.config.performance,
+      errorHandling: this.config.errorHandling
+    };
+    switch (component) {
+      case "pageAnalyzer":
+        return {
+          ...base,
+          executionTimeout: this.config.performance.thresholds.executionTime.pageAnalysis,
+          enableParallel: this.config.features.enableParallelAnalysis,
+          enableResourceMonitoring: this.config.features.enableResourceLeakDetection
+        };
+      case "elementDiscovery":
+        return {
+          ...base,
+          executionTimeout: this.config.performance.thresholds.executionTime.elementDiscovery,
+          maxAlternatives: this.config.diagnostic.maxAlternatives,
+          enableAdvanced: this.config.features.enableAdvancedElementDiscovery
+        };
+      case "resourceManager":
+        return {
+          ...base,
+          executionTimeout: this.config.performance.thresholds.executionTime.resourceMonitoring,
+          autoDisposeTimeout: this.config.autoDisposeTimeout,
+          maxHandles: this.config.maxConcurrentHandles,
+          enableLeakDetection: this.config.features.enableResourceLeakDetection
+        };
+      default:
+        return base;
+    }
+  }
+  exportConfig() {
+    return JSON.stringify(this.config, null, 2);
+  }
+  reset() {
+    this.config = this.createDefaultConfig();
+    this.thresholdsManager.resetToDefaults();
+    this.notifyListeners();
+  }
+  syncThresholdsWithManager(thresholds) {
+    try {
+      const thresholdsConfig = {
+        executionTime: thresholds.executionTime,
+        memory: thresholds.memory,
+        performance: thresholds.performance,
+        dom: thresholds.dom,
+        interaction: thresholds.interaction,
+        layout: thresholds.layout
+      };
+      this.thresholdsManager.updateThresholds(thresholdsConfig);
+    } catch (error) {
+      configDebug("Failed to sync thresholds:", error);
+    }
+  }
+  getThresholdsFromManager() {
+    return this.thresholdsManager.getMetricsThresholds();
+  }
+  getThresholdsStatus() {
+    const managerThresholds = this.thresholdsManager.getMetricsThresholds();
+    const configThresholds = this.config.performance.thresholds;
+    const isInSync = JSON.stringify(managerThresholds) === JSON.stringify(configThresholds);
+    return {
+      isInSync,
+      diagnostics: this.thresholdsManager.getConfigDiagnostics(),
+      smartConfigStatus: isInSync ? "Synchronized with DiagnosticThresholds" : "Out of sync - manual update required"
+    };
+  }
+  isAdaptiveThresholdsEnabled() {
+    return this.config.runtime.enableAdaptiveThresholds;
+  }
+  isAutoTuningEnabled() {
+    return this.config.runtime.enableAutoTuning;
+  }
+  isStatsCollectionEnabled() {
+    return this.config.runtime.statsCollectionEnabled;
+  }
+  configureForEnvironment(env) {
+    const envConfigs = {
+      development: {
+        diagnostic: { level: DiagnosticLevel.FULL },
+        performance: {
+          enableMetricsCollection: true,
+          enableResourceMonitoring: true,
+          enablePerformanceWarnings: true,
+          autoOptimization: true,
+          thresholds: this.thresholdsManager.getMetricsThresholds()
+        },
+        errorHandling: {
+          enableErrorEnrichment: true,
+          enableContextualSuggestions: true,
+          logLevel: "debug",
+          maxErrorHistory: 100,
+          enablePerformanceErrorDetection: true
+        },
+        features: {
+          enableParallelAnalysis: true,
+          enableSmartHandleManagement: true,
+          enableAdvancedElementDiscovery: true,
+          enableResourceLeakDetection: true,
+          enableRealTimeMonitoring: true
+        }
+      },
+      production: {
+        diagnostic: { level: DiagnosticLevel.STANDARD },
+        performance: {
+          enableMetricsCollection: true,
+          enableResourceMonitoring: true,
+          enablePerformanceWarnings: false,
+          autoOptimization: true,
+          thresholds: this.thresholdsManager.getMetricsThresholds()
+        },
+        errorHandling: {
+          enableErrorEnrichment: true,
+          enableContextualSuggestions: true,
+          logLevel: "warn",
+          maxErrorHistory: 50,
+          enablePerformanceErrorDetection: true
+        },
+        features: {
+          enableParallelAnalysis: true,
+          enableSmartHandleManagement: true,
+          enableAdvancedElementDiscovery: true,
+          enableResourceLeakDetection: true,
+          enableRealTimeMonitoring: false
+        }
+      },
+      testing: {
+        diagnostic: { level: DiagnosticLevel.BASIC },
+        performance: {
+          enableMetricsCollection: false,
+          enableResourceMonitoring: false,
+          enablePerformanceWarnings: false,
+          autoOptimization: false,
+          thresholds: this.thresholdsManager.getMetricsThresholds()
+        },
+        errorHandling: {
+          enableErrorEnrichment: false,
+          enableContextualSuggestions: false,
+          logLevel: "error",
+          maxErrorHistory: 20,
+          enablePerformanceErrorDetection: false
+        },
+        features: {
+          enableParallelAnalysis: false,
+          enableSmartHandleManagement: false,
+          enableAdvancedElementDiscovery: false,
+          enableResourceLeakDetection: false,
+          enableRealTimeMonitoring: false
+        }
+      }
+    };
+    this.updateConfig(envConfigs[env]);
+  }
+  updateThresholds(thresholdsConfig) {
+    this.thresholdsManager.updateThresholds(thresholdsConfig);
+    const updatedThresholds = this.thresholdsManager.getMetricsThresholds();
+    this.updateConfig({
+      performance: {
+        ...this.config.performance,
+        thresholds: updatedThresholds
+      }
+    });
+  }
+  getConfigurationImpactReport() {
+    const defaultConfig = this.createDefaultConfig();
+    const currentConfig = this.getConfig();
+    const activeOverrides = [];
+    const executionTimeChanges = this.analyzeThresholdChanges(defaultConfig, currentConfig, activeOverrides);
+    const featureChanges = this.analyzeFeatureChanges(defaultConfig, currentConfig, activeOverrides);
+    this.analyzeConfigurationChanges(defaultConfig, currentConfig, featureChanges.modified, activeOverrides);
+    const performanceImpact = this.evaluatePerformanceImpact(currentConfig, defaultConfig, executionTimeChanges);
+    const validationStatus = this.generateValidationWarnings(executionTimeChanges, featureChanges.enabled);
+    return {
+      activeOverrides,
+      performanceImpact,
+      featureChanges,
+      validationStatus
+    };
+  }
+  analyzeThresholdChanges(defaultConfig, currentConfig, activeOverrides) {
+    const executionTimeChanges = {};
+    const defaultThresholds = defaultConfig.performance.thresholds.executionTime;
+    const currentThresholds = currentConfig.performance.thresholds.executionTime;
+    for (const key of Object.keys(defaultThresholds)) {
+      const componentKey = key;
+      const defaultValue = defaultThresholds[componentKey];
+      const currentValue = currentThresholds[componentKey];
+      if (defaultValue !== currentValue) {
+        const percentChange = (currentValue - defaultValue) / defaultValue * 100;
+        executionTimeChanges[key] = {
+          from: defaultValue,
+          to: currentValue,
+          percentChange: Math.round(percentChange)
+        };
+        activeOverrides.push(`${key} threshold: ${defaultValue}ms → ${currentValue}ms (${percentChange > 0 ? "+" : ""}${percentChange.toFixed(1)}%)`);
+      }
+    }
+    return executionTimeChanges;
+  }
+  analyzeFeatureChanges(defaultConfig, currentConfig, activeOverrides) {
+    const enabled = [];
+    const disabled = [];
+    const modified = [];
+    const featureChecks = [
+      { key: "enableParallelAnalysis", name: "Parallel Analysis" },
+      { key: "enableSmartHandleManagement", name: "Smart Handle Management" },
+      {
+        key: "enableAdvancedElementDiscovery",
+        name: "Advanced Element Discovery"
+      },
+      { key: "enableResourceLeakDetection", name: "Resource Leak Detection" },
+      { key: "enableRealTimeMonitoring", name: "Real-Time Monitoring" }
+    ];
+    for (const { key, name } of featureChecks) {
+      const featureKey = key;
+      const defaultValue = defaultConfig.features[featureKey];
+      const currentValue = currentConfig.features[featureKey];
+      if (defaultValue !== currentValue) {
+        if (currentValue && !defaultValue) {
+          enabled.push(name);
+          activeOverrides.push(`${name}: Enabled (was disabled by default)`);
+        } else if (!currentValue && defaultValue) {
+          disabled.push(name);
+          activeOverrides.push(`${name}: Disabled (was enabled by default)`);
+        }
+      }
+    }
+    return { enabled, disabled, modified };
+  }
+  analyzeConfigurationChanges(defaultConfig, currentConfig, modified, activeOverrides) {
+    if (defaultConfig.errorHandling.enableErrorEnrichment !== currentConfig.errorHandling.enableErrorEnrichment) {
+      const status = currentConfig.errorHandling.enableErrorEnrichment ? "Enabled" : "Disabled";
+      modified.push(`Error Enrichment: ${status}`);
+      activeOverrides.push(`Error Enrichment: ${status}`);
+    }
+    if (defaultConfig.diagnostic.level !== currentConfig.diagnostic.level) {
+      modified.push(`Diagnostic Level: ${defaultConfig.diagnostic.level} → ${currentConfig.diagnostic.level}`);
+      activeOverrides.push(`Diagnostic Level: ${defaultConfig.diagnostic.level} → ${currentConfig.diagnostic.level}`);
+    }
+  }
+  evaluatePerformanceImpact(currentConfig, defaultConfig, executionTimeChanges) {
+    let memoryImpact = "Minimal";
+    const recommendedOptimizations = [];
+    if (currentConfig.features.enableResourceLeakDetection && !defaultConfig.features.enableResourceLeakDetection) {
+      memoryImpact = "Low - Resource monitoring adds overhead";
+      recommendedOptimizations.push("Consider disabling in production if not needed");
+    }
+    if (currentConfig.features.enableRealTimeMonitoring) {
+      memoryImpact = "Medium - Real-time monitoring requires continuous data collection";
+      recommendedOptimizations.push("Only enable for debugging sessions");
+    }
+    return {
+      executionTimeChanges,
+      memoryImpact,
+      recommendedOptimizations
+    };
+  }
+  generateValidationWarnings(executionTimeChanges, enabledFeatures) {
+    const warnings = [];
+    const errors = [];
+    for (const [component, change] of Object.entries(executionTimeChanges)) {
+      if (change.percentChange > 50) {
+        warnings.push(`${component} timeout increased significantly (+${change.percentChange}%) - may mask performance issues`);
+      } else if (change.percentChange < -30) {
+        warnings.push(`${component} timeout decreased significantly (${change.percentChange}%) - may cause false failures`);
+      }
+    }
+    if (enabledFeatures.length > 3) {
+      warnings.push(`Many features enabled (${enabledFeatures.length}) - consider selective enablement for better performance`);
+    }
+    const isValid = errors.length === 0;
+    return { isValid, warnings, errors };
+  }
+  getConfigurationSummary() {
+    const impactReport = this.getConfigurationImpactReport();
+    const totalOverrides = impactReport.activeOverrides.length;
+    const significantChanges = impactReport.featureChanges.enabled.length + impactReport.featureChanges.disabled.length + Object.keys(impactReport.performanceImpact.executionTimeChanges).length;
+    let performanceRisk = "low";
+    if (impactReport.validationStatus.errors.length > 0) {
+      performanceRisk = "high";
+    } else if (impactReport.validationStatus.warnings.length > 2 || significantChanges > 5) {
+      performanceRisk = "medium";
+    }
+    let recommendation = "Configuration is optimal";
+    if (performanceRisk === "high") {
+      recommendation = "Review and fix configuration errors before proceeding";
+    } else if (performanceRisk === "medium") {
+      recommendation = "Consider reviewing warnings and optimizing configuration";
+    } else if (totalOverrides === 0) {
+      recommendation = "Using default configuration - consider customization for your use case";
+    }
+    return {
+      totalOverrides,
+      significantChanges,
+      performanceRisk,
+      recommendation
+    };
+  }
+}
+export {
+  SmartConfigManager
+};

package/lib/diagnostics/smart-handle.js

@@ -0,0 +1,118 @@
+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/smart-handle.ts
+import debug from "debug";
+import {
+  globalResourceManager
+} from "./resource-manager.js";
+var smartHandleDebug = debug("pw:mcp:smart-handle");
+
+class SmartHandle {
+  disposed = false;
+  resource;
+  resourceId;
+  tracker;
+  constructor(resource, tracker) {
+    this.resource = resource;
+    this.tracker = tracker || globalResourceManager;
+    this.resourceId = this.tracker.trackResource(resource, "dispose");
+  }
+  get(target, prop, _receiver) {
+    if (this.disposed) {
+      throw new Error("SmartHandle has been disposed");
+    }
+    const value = target[prop];
+    if (typeof value === "function") {
+      return value.bind(target);
+    }
+    return value;
+  }
+  set(target, prop, value, _receiver) {
+    if (this.disposed) {
+      throw new Error("SmartHandle has been disposed");
+    }
+    target[prop] = value;
+    return true;
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    try {
+      if (this.resource && typeof this.resource.dispose === "function") {
+        await this.resource.dispose();
+      }
+    } catch (error) {
+      smartHandleDebug("Resource disposal failed:", error instanceof Error ? error.message : String(error));
+    } finally {
+      this.disposed = true;
+      this.tracker.untrackResource(this.resourceId);
+    }
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  getResource() {
+    if (this.disposed) {
+      throw new Error("SmartHandle has been disposed");
+    }
+    return this.resource;
+  }
+}
+function createSmartHandle(elementHandle, tracker) {
+  const smartHandle = new SmartHandle(elementHandle, tracker);
+  return new Proxy(elementHandle, smartHandle);
+}
+
+class SmartHandleBatch {
+  handles = [];
+  disposed = false;
+  add(handle, tracker) {
+    if (this.disposed) {
+      throw new Error("SmartHandleBatch has been disposed");
+    }
+    const smartHandle = new SmartHandle(handle, tracker);
+    this.handles.push(smartHandle);
+    return new Proxy(handle, smartHandle);
+  }
+  async dispose() {
+    await this.disposeAll();
+  }
+  async disposeAll() {
+    if (this.disposed) {
+      return;
+    }
+    const disposePromises = this.handles.map((handle) => handle.dispose());
+    await Promise.allSettled(disposePromises);
+    this.handles.length = 0;
+    this.disposed = true;
+  }
+  getActiveCount() {
+    return this.handles.filter((handle) => !handle.isDisposed()).length;
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+}
+export {
+  createSmartHandle,
+  SmartHandleBatch,
+  SmartHandle
+};