@tontoko/fast-playwright-mcp 0.0.4

package/lib/diagnostics/common/initialization-manager.js

@@ -0,0 +1,210 @@
+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/common/initialization-manager.ts
+import { DiagnosticError } from "../diagnostic-error.js";
+
+class InitializationManager {
+  isInitialized = false;
+  initializationPromise;
+  initializationError;
+  performanceTracker;
+  partiallyInitialized = [];
+  context;
+  constructor(context) {
+    this.context = context;
+    this.performanceTracker = context.performanceTracker;
+  }
+  async initialize(stages) {
+    if (this.isInitialized) {
+      return;
+    }
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+    if (this.initializationError) {
+      throw this.initializationError;
+    }
+    this.initializationPromise = this.performInitialization(stages);
+    try {
+      await this.initializationPromise;
+      this.isInitialized = true;
+    } catch (error) {
+      if (error instanceof DiagnosticError) {
+        this.initializationError = error;
+      } else {
+        const baseError = error instanceof Error ? error : new Error(String(error));
+        this.initializationError = new DiagnosticError(`Initialization failed: ${baseError.message}`, {
+          timestamp: Date.now(),
+          component: "InitializationManager",
+          operation: "initialize",
+          suggestions: [
+            "Check component dependencies",
+            "Verify all required services are available",
+            "Review initialization order"
+          ],
+          context: {
+            componentName: this.context.componentName,
+            errorStage: "initialization"
+          }
+        }, baseError);
+      }
+      throw this.initializationError;
+    } finally {
+      this.initializationPromise = undefined;
+    }
+  }
+  async performInitialization(stages) {
+    const completedStages = new Set;
+    try {
+      const executeStagesSequentially = async (index) => {
+        if (index >= stages.length) {
+          return;
+        }
+        const stage = stages[index];
+        await this.executeStage(stage, completedStages);
+        completedStages.add(stage.name);
+        await executeStagesSequentially(index + 1);
+      };
+      await executeStagesSequentially(0);
+    } catch (error) {
+      await this.cleanupPartialInitialization();
+      throw error;
+    }
+  }
+  async executeStage(stage, completedStages) {
+    if (stage.dependencies) {
+      for (const dependency of stage.dependencies) {
+        if (!completedStages.has(dependency)) {
+          throw new Error(`Dependency '${dependency}' not satisfied for stage '${stage.name}'`);
+        }
+      }
+    }
+    const executeWithTracking = async () => {
+      const executeComponentsSequentially = async (index) => {
+        if (index >= stage.components.length) {
+          return;
+        }
+        const componentInit = stage.components[index];
+        await this.executeWithRetry(componentInit, stage.retryCount ?? 1, stage.timeout);
+        await executeComponentsSequentially(index + 1);
+      };
+      await executeComponentsSequentially(0);
+    };
+    if (this.performanceTracker) {
+      await this.performanceTracker.trackOperation(`init-stage-${stage.name}`, this.context.componentName, executeWithTracking);
+    } else {
+      await executeWithTracking();
+    }
+  }
+  async executeWithRetry(operation, retryCount, timeout) {
+    const attemptOperation = async (attempt) => {
+      try {
+        if (timeout) {
+          await Promise.race([
+            operation(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timeout after ${timeout}ms`)), timeout))
+          ]);
+        } else {
+          await operation();
+        }
+        return;
+      } catch (error) {
+        const lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < retryCount) {
+          await this.delay(1000 * attempt);
+          return attemptOperation(attempt + 1);
+        }
+        throw lastError;
+      }
+    };
+    await attemptOperation(1);
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  trackPartialInitialization(component) {
+    this.partiallyInitialized.push(component);
+  }
+  async cleanupPartialInitialization() {
+    const cleanupPromises = this.partiallyInitialized.map(async (component) => {
+      try {
+        await component.dispose();
+      } catch {}
+    });
+    await Promise.allSettled(cleanupPromises);
+    this.partiallyInitialized.length = 0;
+  }
+  getIsInitialized() {
+    return this.isInitialized;
+  }
+  getInitializationError() {
+    return this.initializationError;
+  }
+  reset() {
+    this.isInitialized = false;
+    this.initializationPromise = undefined;
+    this.initializationError = undefined;
+    this.partiallyInitialized.length = 0;
+  }
+  async dispose() {
+    if (this.initializationPromise) {
+      try {
+        await this.initializationPromise;
+      } catch {}
+    }
+    await this.cleanupPartialInitialization();
+    this.reset();
+  }
+}
+function createCoreStage(name, components) {
+  return {
+    name,
+    components,
+    timeout: 5000
+  };
+}
+function createDependentStage(name, dependencies, components) {
+  return {
+    name,
+    dependencies,
+    components,
+    timeout: 1e4,
+    retryCount: 2
+  };
+}
+function createAdvancedStage(name, components, additionalDependencies = []) {
+  return {
+    name,
+    dependencies: [
+      "core-infrastructure",
+      "page-dependent",
+      ...additionalDependencies
+    ],
+    components,
+    timeout: 15000,
+    retryCount: 1
+  };
+}
+export {
+  createDependentStage,
+  createCoreStage,
+  createAdvancedStage,
+  InitializationManager
+};

package/lib/diagnostics/common/performance-tracker.js

@@ -0,0 +1,132 @@
+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/common/performance-tracker.ts
+class PerformanceTracker {
+  metrics = [];
+  maxHistorySize;
+  constructor(maxHistorySize = 1000) {
+    this.maxHistorySize = maxHistorySize;
+  }
+  async trackOperation(operation, component, fn, metadata) {
+    const startTime = Date.now();
+    const startMemory = process.memoryUsage().heapUsed;
+    let success = false;
+    let result;
+    try {
+      result = await fn();
+      success = true;
+      return {
+        result,
+        metric: this.recordMetric(operation, component, startTime, success, startMemory, metadata)
+      };
+    } catch (error) {
+      this.recordMetric(operation, component, startTime, success, startMemory, metadata);
+      throw error;
+    }
+  }
+  recordMetric(operation, component, startTime, success, startMemory, metadata) {
+    const executionTime = Date.now() - startTime;
+    const currentMemory = process.memoryUsage().heapUsed;
+    const metric = {
+      operation,
+      component,
+      executionTime,
+      timestamp: startTime,
+      success,
+      memoryUsage: currentMemory - startMemory,
+      metadata
+    };
+    this.addMetric(metric);
+    return metric;
+  }
+  addMetric(metric) {
+    this.metrics.push(metric);
+    if (this.metrics.length > this.maxHistorySize) {
+      const excessCount = this.metrics.length - this.maxHistorySize;
+      this.metrics.splice(0, excessCount);
+    }
+  }
+  getOperationStats(operation, component) {
+    const relevantMetrics = this.metrics.filter((m) => m.operation === operation && (!component || m.component === component));
+    if (relevantMetrics.length === 0) {
+      return {
+        averageExecutionTime: 0,
+        minExecutionTime: 0,
+        maxExecutionTime: 0,
+        totalOperations: 0,
+        successRate: 1,
+        recentFailures: 0
+      };
+    }
+    const executionTimes = relevantMetrics.map((m) => m.executionTime);
+    const successCount = relevantMetrics.filter((m) => m.success).length;
+    const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
+    const recentFailures = relevantMetrics.filter((m) => !m.success && m.timestamp > fiveMinutesAgo).length;
+    return {
+      averageExecutionTime: executionTimes.reduce((sum, time) => sum + time, 0) / executionTimes.length,
+      minExecutionTime: Math.min(...executionTimes),
+      maxExecutionTime: Math.max(...executionTimes),
+      totalOperations: relevantMetrics.length,
+      successRate: successCount / relevantMetrics.length,
+      recentFailures
+    };
+  }
+  getAllStats() {
+    const operations = [...new Set(this.metrics.map((m) => m.operation))];
+    const stats = {};
+    for (const operation of operations) {
+      stats[operation] = this.getOperationStats(operation);
+    }
+    return stats;
+  }
+  getMetricsInRange(startTime, endTime, operation, component) {
+    return this.metrics.filter((m) => m.timestamp >= startTime && m.timestamp <= endTime && (!operation || m.operation === operation) && (!component || m.component === component));
+  }
+  clearMetrics() {
+    this.metrics.splice(0, this.metrics.length);
+  }
+  getRecentMetrics(limit = 50) {
+    return this.metrics.slice(-limit);
+  }
+  detectAnomalies(operation, threshold = 2) {
+    const stats = this.getOperationStats(operation);
+    const recentMetrics = this.getMetricsInRange(Date.now() - 10 * 60 * 1000, Date.now(), operation);
+    const slowOperations = recentMetrics.filter((m) => m.executionTime > stats.averageExecutionTime * threshold);
+    const recommendations = [];
+    if (slowOperations.length > 0) {
+      recommendations.push(`${slowOperations.length} slow operations detected for ${operation}`);
+    }
+    if (stats.successRate < 0.9) {
+      recommendations.push(`Low success rate (${(stats.successRate * 100).toFixed(1)}%) for ${operation}`);
+    }
+    if (stats.recentFailures > 3) {
+      recommendations.push(`${stats.recentFailures} recent failures detected for ${operation}`);
+    }
+    return {
+      slowOperations,
+      recommendations
+    };
+  }
+}
+var globalPerformanceTracker = new PerformanceTracker;
+export {
+  globalPerformanceTracker,
+  PerformanceTracker
+};

package/lib/diagnostics/diagnostic-error.js

@@ -0,0 +1,140 @@
+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/diagnostic-error.ts
+var PERFORMANCE_IMPACT_LEVELS = ["low", "medium", "high"];
+
+class DiagnosticError extends Error {
+  timestamp;
+  component;
+  operation;
+  originalError;
+  executionTime;
+  memoryUsage;
+  performanceImpact;
+  suggestions;
+  context;
+  constructor(message, context, originalError) {
+    const enhancedMessage = `[${context.component}:${context.operation}] ${message}`;
+    super(enhancedMessage);
+    this.name = "DiagnosticError";
+    this.timestamp = context.timestamp;
+    this.component = context.component;
+    this.operation = context.operation;
+    this.originalError = originalError;
+    this.executionTime = context.executionTime;
+    this.memoryUsage = context.memoryUsage;
+    this.performanceImpact = context.performanceImpact ?? "low";
+    this.suggestions = context.suggestions ?? [];
+    this.context = context.context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DiagnosticError);
+    }
+  }
+  static from(error, component, operation, additionalContext) {
+    return new DiagnosticError(error.message, {
+      timestamp: Date.now(),
+      component,
+      operation,
+      ...additionalContext
+    }, error);
+  }
+  static performance(message, component, operation, executionTime, threshold) {
+    let impact;
+    if (executionTime > threshold * 3) {
+      impact = "high";
+    } else if (executionTime > threshold * 2) {
+      impact = "medium";
+    } else {
+      impact = "low";
+    }
+    return new DiagnosticError(`Performance issue: ${message} (${executionTime}ms > ${threshold}ms)`, {
+      timestamp: Date.now(),
+      component,
+      operation,
+      executionTime,
+      performanceImpact: impact,
+      suggestions: [
+        `Operation took longer than expected (${executionTime}ms vs ${threshold}ms threshold)`,
+        "Consider optimizing this operation or increasing timeout thresholds"
+      ]
+    });
+  }
+  static resource(message, component, operation, memoryUsage, memoryLimit) {
+    let impact;
+    if (memoryUsage > memoryLimit * 2) {
+      impact = "high";
+    } else if (memoryUsage > memoryLimit * 1.5) {
+      impact = "medium";
+    } else {
+      impact = "low";
+    }
+    return new DiagnosticError(`Resource issue: ${message} (${(memoryUsage / 1024 / 1024).toFixed(2)}MB)`, {
+      timestamp: Date.now(),
+      component,
+      operation,
+      memoryUsage,
+      performanceImpact: impact,
+      suggestions: [
+        `Memory usage exceeded expectations (${(memoryUsage / 1024 / 1024).toFixed(2)}MB vs ${(memoryLimit / 1024 / 1024).toFixed(2)}MB limit)`,
+        "Consider enabling resource cleanup or reducing analysis scope"
+      ]
+    });
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      timestamp: this.timestamp,
+      component: this.component,
+      operation: this.operation,
+      executionTime: this.executionTime,
+      memoryUsage: this.memoryUsage,
+      performanceImpact: this.performanceImpact,
+      suggestions: this.suggestions,
+      stack: this.stack,
+      originalError: this.originalError ? {
+        name: this.originalError.name,
+        message: this.originalError.message,
+        stack: this.originalError.stack
+      } : undefined
+    };
+  }
+  toString() {
+    const parts = [this.message];
+    if (this.executionTime !== undefined) {
+      parts.push(`Execution Time: ${this.executionTime}ms`);
+    }
+    if (this.memoryUsage !== undefined) {
+      parts.push(`Memory Usage: ${(this.memoryUsage / 1024 / 1024).toFixed(2)}MB`);
+    }
+    if (this.suggestions.length > 0) {
+      parts.push("Suggestions:");
+      for (const suggestion of this.suggestions) {
+        parts.push(`  - ${suggestion}`);
+      }
+    }
+    return parts.join(`
+`);
+  }
+}
+export {
+  PERFORMANCE_IMPACT_LEVELS,
+  DiagnosticError
+};

package/lib/diagnostics/diagnostic-level.js

@@ -0,0 +1,123 @@
+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/diagnostic-level.ts
+var DiagnosticLevel = {
+  NONE: "none",
+  BASIC: "basic",
+  STANDARD: "standard",
+  DETAILED: "detailed",
+  FULL: "full"
+};
+
+class DiagnosticLevelManager {
+  static defaultConfig = {
+    level: DiagnosticLevel.STANDARD,
+    features: undefined,
+    thresholds: {
+      maxDiagnosticTime: 300
+    }
+  };
+  config;
+  constructor(config) {
+    this.config = this.mergeConfig(config);
+  }
+  mergeConfig(partial) {
+    if (!partial) {
+      return { ...DiagnosticLevelManager.defaultConfig };
+    }
+    return {
+      level: partial.level ?? DiagnosticLevelManager.defaultConfig.level,
+      features: partial.features ? { ...partial.features } : undefined,
+      thresholds: {
+        ...DiagnosticLevelManager.defaultConfig.thresholds,
+        ...partial.thresholds
+      }
+    };
+  }
+  getMaxAlternatives() {
+    if (this.config.maxAlternatives !== undefined) {
+      return this.config.maxAlternatives;
+    }
+    if (this.config.thresholds?.maxAlternatives !== undefined) {
+      return this.config.thresholds.maxAlternatives;
+    }
+    switch (this.config.level) {
+      case DiagnosticLevel.NONE:
+        return 0;
+      case DiagnosticLevel.BASIC:
+        return 1;
+      case DiagnosticLevel.STANDARD:
+        return 5;
+      case DiagnosticLevel.DETAILED:
+      case DiagnosticLevel.FULL:
+        return 10;
+      default:
+        return 5;
+    }
+  }
+  shouldSkipDiagnostics() {
+    return this.config.level === DiagnosticLevel.NONE;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(partial) {
+    const updatedConfig = this.mergeConfig({ ...this.config, ...partial });
+    this.config = updatedConfig;
+  }
+  shouldEnableFeature(feature) {
+    if (feature === "alternativeSuggestions" && this.config.enableAlternativeSuggestions !== undefined) {
+      return this.config.enableAlternativeSuggestions;
+    }
+    if (feature === "pageAnalysis" && this.config.enablePageAnalysis !== undefined) {
+      return this.config.enablePageAnalysis;
+    }
+    if (feature === "performanceMetrics" && this.config.enablePerformanceMetrics !== undefined) {
+      return this.config.enablePerformanceMetrics;
+    }
+    if (this.config.features?.[feature] !== undefined) {
+      const featureValue = this.config.features[feature];
+      return featureValue ?? false;
+    }
+    switch (this.config.level) {
+      case DiagnosticLevel.NONE:
+        return false;
+      case DiagnosticLevel.BASIC:
+        return feature === "iframeDetection" || feature === "modalDetection";
+      case DiagnosticLevel.STANDARD:
+        return feature !== "performanceTracking" && feature !== "accessibilityAnalysis";
+      case DiagnosticLevel.DETAILED:
+        return feature !== "accessibilityAnalysis";
+      case DiagnosticLevel.FULL:
+        return true;
+      default:
+        return false;
+    }
+  }
+  getMaxDiagnosticTime() {
+    return this.config.thresholds?.maxDiagnosticTime ?? 300;
+  }
+}
+var globalDiagnosticConfig = new DiagnosticLevelManager;
+export {
+  globalDiagnosticConfig,
+  DiagnosticLevelManager,
+  DiagnosticLevel
+};