@tontoko/fast-playwright-mcp 0.0.4

package/lib/tools/common.js

@@ -0,0 +1,65 @@
+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/tools/common.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTabTool, defineTool } from "./tool.js";
+var close = defineTool({
+  capability: "core",
+  schema: {
+    name: "browser_close",
+    title: "Close browser",
+    description: "Close the page",
+    inputSchema: z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, _params, response) => {
+    await context.closeBrowserContext();
+    response.setIncludeTabs();
+    response.addCode("await page.close()");
+  }
+});
+var resize = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_resize",
+    title: "Resize browser window",
+    description: "Resize the browser window",
+    inputSchema: z.object({
+      width: z.number().describe("Width of the browser window"),
+      height: z.number().describe("Height of the browser window"),
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`);
+    await tab.waitForCompletion(async () => {
+      await tab.page.setViewportSize({
+        width: params.width,
+        height: params.height
+      });
+    });
+  }
+});
+var common_default = [close, resize];
+export {
+  common_default as default
+};

package/lib/tools/console.js

@@ -0,0 +1,60 @@
+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/tools/console.ts
+import { z } from "zod";
+import { filterConsoleMessages } from "../utils/console-filter.js";
+import { defineTabTool } from "./tool.js";
+var consoleOptionsSchema = z.object({
+  levels: z.array(z.enum(["log", "warn", "error", "info"])).optional(),
+  maxMessages: z.number().optional().default(10),
+  patterns: z.array(z.string()).optional().describe("Regex patterns to filter messages"),
+  removeDuplicates: z.boolean().optional().default(false).describe("Remove duplicate messages")
+}).optional();
+var console = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_console_messages",
+    title: "Get console messages",
+    description: "Returns all console messages",
+    inputSchema: z.object({
+      consoleOptions: consoleOptionsSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const messages = await Promise.resolve(tab.consoleMessages());
+    if (messages.length === 0) {
+      response.addResult("No console messages");
+      return;
+    }
+    const filteredMessages = filterConsoleMessages(messages, params.consoleOptions);
+    if (filteredMessages.length === 0) {
+      response.addResult("No console messages match the filter criteria");
+      return;
+    }
+    for (const message of filteredMessages) {
+      response.addResult(message.toString());
+    }
+  }
+});
+var console_default = [console];
+export {
+  console_default as default
+};

package/lib/tools/diagnose/diagnose-analysis-runner.js

@@ -0,0 +1,101 @@
+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/tools/diagnose/diagnose-analysis-runner.ts
+class DiagnoseAnalysisRunner {
+  async runAnalysis(unifiedSystem, pageAnalyzer, useParallelAnalysis, includeSystemStats) {
+    if (unifiedSystem) {
+      return await this.runUnifiedSystemAnalysis(unifiedSystem, useParallelAnalysis, includeSystemStats);
+    }
+    if (useParallelAnalysis && pageAnalyzer) {
+      return await this.runLegacyParallelAnalysis(pageAnalyzer);
+    }
+    if (pageAnalyzer) {
+      return await this.runStandardAnalysis(pageAnalyzer);
+    }
+    throw new Error("No analysis system available");
+  }
+  async runUnifiedSystemAnalysis(unifiedSystem, useParallelAnalysis, includeSystemStats) {
+    const structureResult = await unifiedSystem.analyzePageStructure(useParallelAnalysis);
+    if (!structureResult.success) {
+      throw new Error(`Unified system analysis failed: ${structureResult.error?.message ?? "Unknown error"}`);
+    }
+    let diagnosticInfo = structureResult.data;
+    let performanceMetrics;
+    let analysisType;
+    let analysisStatus;
+    if ("structureAnalysis" in diagnosticInfo) {
+      const parallelResult = diagnosticInfo;
+      performanceMetrics = parallelResult.performanceMetrics;
+      diagnosticInfo = parallelResult.structureAnalysis;
+      analysisType = `Enhanced Parallel Analysis (${structureResult.executionTime}ms)`;
+      analysisStatus = "Successfully executed with resource monitoring";
+    } else {
+      analysisType = `Standard Analysis (${structureResult.executionTime}ms)`;
+      analysisStatus = useParallelAnalysis ? "Parallel analysis requested but fell back to standard" : "Standard analysis by configuration";
+    }
+    let systemHealthInfo;
+    if (includeSystemStats) {
+      const healthResult = unifiedSystem.performHealthCheck();
+      systemHealthInfo = {
+        ...healthResult,
+        timestamp: Date.now()
+      };
+    }
+    return {
+      diagnosticInfo,
+      performanceMetrics,
+      systemHealthInfo,
+      analysisType,
+      executionTime: structureResult.executionTime,
+      analysisStatus
+    };
+  }
+  async runLegacyParallelAnalysis(pageAnalyzer) {
+    const parallelRecommendation = await pageAnalyzer.shouldUseParallelAnalysis();
+    if (parallelRecommendation.recommended) {
+      const parallelResult = await pageAnalyzer.runParallelAnalysis();
+      return {
+        diagnosticInfo: parallelResult.structureAnalysis,
+        performanceMetrics: parallelResult.performanceMetrics,
+        analysisType: "Enhanced Diagnostic Report (Parallel Analysis)",
+        executionTime: parallelResult.executionTime,
+        analysisStatus: "Parallel analysis completed successfully",
+        errors: parallelResult.errors.map((err) => `${err.step}: ${err.error}`)
+      };
+    }
+    const diagnosticInfo = await pageAnalyzer.analyzePageStructure();
+    return {
+      diagnosticInfo,
+      analysisType: "Standard Diagnostic Report",
+      analysisStatus: `Parallel Analysis: Not recommended - ${parallelRecommendation.reason}`
+    };
+  }
+  async runStandardAnalysis(pageAnalyzer) {
+    const diagnosticInfo = await pageAnalyzer.analyzePageStructure();
+    return {
+      diagnosticInfo,
+      analysisType: "Standard Analysis",
+      analysisStatus: "Standard analysis completed"
+    };
+  }
+}
+export {
+  DiagnoseAnalysisRunner
+};

package/lib/tools/diagnose/diagnose-config-handler.js

@@ -0,0 +1,130 @@
+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/tools/diagnose/diagnose-config-handler.ts
+import debug from "debug";
+import { getCurrentThresholds } from "../../diagnostics/diagnostic-thresholds.js";
+import { PageAnalyzer } from "../../diagnostics/page-analyzer.js";
+import { UnifiedDiagnosticSystem } from "../../diagnostics/unified-system.js";
+var configDebug = debug("pw:mcp:diagnose-config");
+
+class DiagnoseConfigHandler {
+  validateConfiguration() {
+    try {
+      const thresholdsManager = getCurrentThresholds();
+      return thresholdsManager.getConfigDiagnostics();
+    } catch (error) {
+      configDebug("Configuration validation failed:", error);
+      return {
+        status: "failed",
+        warnings: [
+          "Configuration system validation failed - using fallback settings"
+        ],
+        customizations: []
+      };
+    }
+  }
+  initializeSystems(tab, useUnifiedSystem, _useParallelAnalysis, configOverrides) {
+    const appliedOverrides = [];
+    if (useUnifiedSystem) {
+      const configUpdates = this.buildConfigUpdates(configOverrides, appliedOverrides);
+      const unifiedSystem = UnifiedDiagnosticSystem.getInstance(tab.page, configUpdates);
+      return {
+        unifiedSystem,
+        appliedOverrides
+      };
+    }
+    const pageAnalyzer = new PageAnalyzer(tab.page);
+    return {
+      pageAnalyzer,
+      appliedOverrides
+    };
+  }
+  buildConfigUpdates(configOverrides, appliedOverrides = []) {
+    const configUpdates = {};
+    if (!configOverrides) {
+      return configUpdates;
+    }
+    if (configOverrides.enableResourceMonitoring !== undefined) {
+      configUpdates.features = {
+        enableParallelAnalysis: true,
+        enableSmartHandleManagement: true,
+        enableAdvancedElementDiscovery: true,
+        enableResourceLeakDetection: configOverrides.enableResourceMonitoring,
+        enableRealTimeMonitoring: false
+      };
+      appliedOverrides.push(`Resource Monitoring: ${configOverrides.enableResourceMonitoring ? "Enabled" : "Disabled"}`);
+    }
+    if (configOverrides.enableErrorEnrichment !== undefined) {
+      configUpdates.errorHandling = {
+        enableErrorEnrichment: configOverrides.enableErrorEnrichment,
+        enableContextualSuggestions: true,
+        logLevel: "warn",
+        maxErrorHistory: 100,
+        enablePerformanceErrorDetection: true
+      };
+      appliedOverrides.push(`Error Enrichment: ${configOverrides.enableErrorEnrichment ? "Enabled" : "Disabled"}`);
+    }
+    if (configOverrides.enableAdaptiveThresholds !== undefined) {
+      configUpdates.runtime = {
+        enableAdaptiveThresholds: configOverrides.enableAdaptiveThresholds,
+        enableAutoTuning: false,
+        statsCollectionEnabled: true
+      };
+      appliedOverrides.push(`Adaptive Thresholds: ${configOverrides.enableAdaptiveThresholds ? "Enabled" : "Disabled"}`);
+    }
+    if (configOverrides.performanceThresholds) {
+      this.applyPerformanceThresholds(configUpdates, configOverrides.performanceThresholds, appliedOverrides);
+    }
+    return configUpdates;
+  }
+  applyPerformanceThresholds(configUpdates, performanceThresholds, appliedOverrides) {
+    const baseThresholds = getCurrentThresholds().getMetricsThresholds();
+    const customThresholds = { ...baseThresholds };
+    const thresholdChanges = [];
+    if (performanceThresholds.pageAnalysis) {
+      const oldValue = customThresholds.executionTime.pageAnalysis;
+      customThresholds.executionTime.pageAnalysis = performanceThresholds.pageAnalysis;
+      thresholdChanges.push(`Page Analysis: ${oldValue}ms → ${performanceThresholds.pageAnalysis}ms`);
+    }
+    if (performanceThresholds.elementDiscovery) {
+      const oldValue = customThresholds.executionTime.elementDiscovery;
+      customThresholds.executionTime.elementDiscovery = performanceThresholds.elementDiscovery;
+      thresholdChanges.push(`Element Discovery: ${oldValue}ms → ${performanceThresholds.elementDiscovery}ms`);
+    }
+    if (performanceThresholds.resourceMonitoring) {
+      const oldValue = customThresholds.executionTime.resourceMonitoring;
+      customThresholds.executionTime.resourceMonitoring = performanceThresholds.resourceMonitoring;
+      thresholdChanges.push(`Resource Monitoring: ${oldValue}ms → ${performanceThresholds.resourceMonitoring}ms`);
+    }
+    if (thresholdChanges.length > 0) {
+      appliedOverrides.push(`Performance Thresholds: ${thresholdChanges.join(", ")}`);
+      configUpdates.performance = {
+        enableMetricsCollection: true,
+        enableResourceMonitoring: true,
+        enablePerformanceWarnings: true,
+        autoOptimization: true,
+        thresholds: customThresholds
+      };
+    }
+  }
+}
+export {
+  DiagnoseConfigHandler
+};