@tontoko/fast-playwright-mcp 0.0.4

package/lib/tools/diagnose/diagnose-report-builder.js

@@ -0,0 +1,394 @@
+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-report-builder.ts
+import { ElementDiscovery } from "../../diagnostics/element-discovery.js";
+import { ArrayBuilder } from "../../utils/code-deduplication-utils.js";
+import {
+  formatPerformanceComparison,
+  formatStatusString,
+  getErrorMessage,
+  processBrowserMetrics
+} from "../../utils/common-formatters.js";
+import {
+  addDomComplexityMetrics,
+  addElementList as addElementListUtil,
+  addErrorSection,
+  addInteractionMetrics,
+  addKeyValuePairs as addKeyValuePairsUtil,
+  addModalStatesIfPresent,
+  addOptionalListSection as addOptionalListSectionUtil,
+  addResourceMetrics,
+  addSystemHealthSection
+} from "../../utils/diagnostic-report-utils.js";
+import { DiagnosticReportBuilder } from "../../utils/report-builder.js";
+
+class DiagnoseReportBuilder {
+  reportBuilder;
+  tab;
+  constructor(tab) {
+    this.tab = tab;
+    this.reportBuilder = new DiagnosticReportBuilder;
+  }
+  addKeyValuePairs(pairs, headerText, subHeaderText, headerLevel = 2) {
+    if (headerText) {
+      this.reportBuilder.addHeader(headerText, 1).addEmptyLine();
+    }
+    if (subHeaderText) {
+      this.reportBuilder.addHeader(subHeaderText, headerLevel);
+    }
+    addKeyValuePairsUtil(this.reportBuilder, pairs.map(([key, value]) => ({ key, value })));
+    this.reportBuilder.addEmptyLine();
+  }
+  addOptionalListSection(title, items, formatter, headerLevel = 2) {
+    addOptionalListSectionUtil(this.reportBuilder, title, items, formatter, headerLevel);
+  }
+  shouldIncludeSection(options, section) {
+    const sectionConfig = {
+      accessibility: options.includeAccessibilityInfo || options.diagnosticLevel === "full",
+      performance: options.includePerformanceMetrics || options.diagnosticLevel === "detailed" || options.diagnosticLevel === "full",
+      troubleshooting: options.includeTroubleshootingSuggestions || ["standard", "detailed", "full"].includes(options.diagnosticLevel)
+    };
+    return sectionConfig[section] && options.diagnosticLevel !== "basic";
+  }
+  addElementList(title, elements, formatter, maxItems = 5) {
+    addElementListUtil(this.reportBuilder, title, elements, formatter, maxItems);
+  }
+  async buildReport(analysisResult, unifiedSystem, pageAnalyzer, options) {
+    this.reportBuilder.clear();
+    if (options.diagnosticLevel === "none") {
+      return "Diagnostics disabled (level: none)";
+    }
+    this.addReportHeader(analysisResult, unifiedSystem, options);
+    await this.addPageStructureSection(analysisResult.diagnosticInfo, options);
+    this.addModalStatesSection(analysisResult.diagnosticInfo);
+    await this.addElementSearchSection(options);
+    await this.addPerformanceSection(analysisResult, unifiedSystem, pageAnalyzer, options);
+    await this.addAccessibilitySection(analysisResult.diagnosticInfo, options);
+    this.addTroubleshootingSection(analysisResult.diagnosticInfo, options);
+    return this.reportBuilder.build();
+  }
+  addReportHeader(analysisResult, unifiedSystem, options) {
+    if (unifiedSystem) {
+      this.addKeyValuePairs([
+        [
+          "Unified System Status",
+          "Active with enhanced error handling and monitoring"
+        ],
+        [
+          "Configuration",
+          options.appliedOverrides?.length ? "Custom overrides applied" : "Default settings"
+        ],
+        ["Analysis Type", analysisResult.analysisType],
+        ["Analysis Status", analysisResult.analysisStatus]
+      ], "Unified Diagnostic System Report");
+      this.addOptionalListSection("Applied Configuration Overrides", options.appliedOverrides, (item) => `**${item}**`);
+      this.addOptionalListSection("Analysis Warnings", analysisResult.errors, (item) => `**${item}**`);
+      this.addSystemHealthSection(analysisResult, unifiedSystem, options);
+    }
+  }
+  addSystemHealthSection(analysisResult, unifiedSystem, options) {
+    if (!(options.includeSystemStats && analysisResult.systemHealthInfo)) {
+      return;
+    }
+    const systemHealthInfo = analysisResult.systemHealthInfo;
+    const systemStats = unifiedSystem.getSystemStats();
+    addSystemHealthSection(this.reportBuilder, {
+      status: systemHealthInfo.status,
+      totalOperations: systemStats.performanceMetrics.totalOperations,
+      successRate: systemStats.performanceMetrics.successRate,
+      activeHandles: systemStats.resourceUsage.currentHandles,
+      totalErrors: Object.values(systemStats.errorCount).reduce((sum, count) => sum + count, 0)
+    });
+    this.addConfigurationImpactSection(unifiedSystem, options);
+    this.addSystemIssuesAndRecommendations(systemHealthInfo);
+  }
+  addConfigurationImpactSection(unifiedSystem, options) {
+    if (!options.appliedOverrides?.length) {
+      return;
+    }
+    const configReport = unifiedSystem.getConfigurationReport();
+    this.reportBuilder.addSection("Configuration Impact Analysis", (builder) => {
+      builder.addKeyValue("Configuration Status", configReport.configurationStatus.replace("-", " ").replace(/\b\w/g, (l) => l.toUpperCase()));
+    }, 3);
+    this.addPerformanceBaselineComparison(configReport);
+    this.addAppliedOverridesDetails(configReport);
+    this.addHighPriorityRecommendations(configReport);
+  }
+  addPerformanceBaselineComparison(configReport) {
+    const { expectedExecutionTimes, actualAverages, deviations } = configReport.performanceBaseline;
+    const hasActualData = Object.values(actualAverages).some((val) => val > 0);
+    if (!hasActualData) {
+      return;
+    }
+    this.reportBuilder.addEmptyLine().addLine("**Performance Baseline Comparison:**");
+    for (const component of Object.keys(expectedExecutionTimes)) {
+      const expected = expectedExecutionTimes[component];
+      const actual = actualAverages[component];
+      const deviation = deviations[component];
+      if (actual > 0) {
+        this.reportBuilder.addLine(formatPerformanceComparison(component, expected, actual, deviation));
+      }
+    }
+  }
+  addAppliedOverridesDetails(configReport) {
+    if (configReport.appliedOverrides.length === 0) {
+      return;
+    }
+    this.reportBuilder.addEmptyLine().addLine("**Applied Configuration Changes:**");
+    for (const override of configReport.appliedOverrides) {
+      this.reportBuilder.addLine(formatStatusString(`**${override.category}**`, override.impact, "impact", `(${override.impact} impact):`));
+      for (const change of override.changes) {
+        this.reportBuilder.addLine(`    - ${change}`);
+      }
+    }
+  }
+  addHighPriorityRecommendations(configReport) {
+    const highPriorityRecs = configReport.recommendations.filter((r) => r.priority === "high");
+    if (highPriorityRecs.length === 0) {
+      return;
+    }
+    this.reportBuilder.addEmptyLine().addLine("**High Priority Recommendations:**");
+    for (const rec of highPriorityRecs) {
+      this.reportBuilder.addLine(formatStatusString(rec.message, rec.type, "recommendation"));
+    }
+  }
+  addSystemIssuesAndRecommendations(systemHealthInfo) {
+    this.addOptionalListSection("System Issues", systemHealthInfo.issues, (item) => `⚠️ ${item}`, 3);
+    this.addOptionalListSection("System Recommendations", systemHealthInfo.recommendations, (item) => `\uD83D\uDCA1 ${item}`, 3);
+    this.reportBuilder.addEmptyLine();
+  }
+  async addPageStructureSection(diagnosticInfo, options) {
+    const isBasic = options.diagnosticLevel === "basic";
+    const title = isBasic ? "Basic Diagnostic Report" : "Page Diagnostic Report";
+    const url = this.tab.page.url();
+    const basicKeyValues = [["URL", url]];
+    if (!isBasic) {
+      basicKeyValues.push(["Title", await this.tab.page.title()]);
+    }
+    this.addKeyValuePairs(basicKeyValues, title);
+    if (isBasic) {
+      this.addBasicDiagnosticInfo(diagnosticInfo);
+    } else {
+      this.addDetailedPageStructure(diagnosticInfo);
+    }
+  }
+  addBasicDiagnosticInfo(diagnosticInfo) {
+    this.reportBuilder.addHeader("Critical Information", 2);
+    const criticalInfo = [
+      [
+        "IFrames detected",
+        diagnosticInfo.iframes.count,
+        diagnosticInfo.iframes.detected
+      ],
+      [
+        "Active modals",
+        diagnosticInfo.modalStates.blockedBy.join(", "),
+        diagnosticInfo.modalStates.blockedBy.length > 0
+      ],
+      [
+        "Interactable elements",
+        diagnosticInfo.elements.totalInteractable,
+        true
+      ]
+    ];
+    for (const [key, value, condition] of criticalInfo) {
+      if (condition) {
+        this.reportBuilder.addKeyValue(key, value);
+      }
+    }
+    this.reportBuilder.addEmptyLine();
+  }
+  addDetailedPageStructure(diagnosticInfo) {
+    this.reportBuilder.addHeader("Page Structure Analysis", 2);
+    const structureData = [
+      [
+        "IFrames",
+        `${diagnosticInfo.iframes.count} iframes detected: ${diagnosticInfo.iframes.detected}`
+      ],
+      ["Accessible iframes", diagnosticInfo.iframes.accessible.length],
+      ["Inaccessible iframes", diagnosticInfo.iframes.inaccessible.length]
+    ];
+    this.addKeyValuePairs(structureData);
+    const elementData = [
+      ["Total visible elements", diagnosticInfo.elements.totalVisible],
+      [
+        "Total interactable elements",
+        diagnosticInfo.elements.totalInteractable
+      ],
+      ["Elements missing ARIA", diagnosticInfo.elements.missingAria]
+    ];
+    this.addKeyValuePairs(elementData);
+  }
+  addModalStatesSection(diagnosticInfo) {
+    addModalStatesIfPresent(this.reportBuilder, diagnosticInfo.modalStates);
+  }
+  async addElementSearchSection(options) {
+    if (!options.searchForElements || options.diagnosticLevel === "basic") {
+      return;
+    }
+    const elementDiscovery = new ElementDiscovery(this.tab.page);
+    const foundElements = await elementDiscovery.findAlternativeElements({
+      originalSelector: "",
+      searchCriteria: options.searchForElements,
+      maxResults: 10
+    });
+    this.reportBuilder.addHeader("Element Search Results", 2);
+    if (foundElements.length === 0) {
+      this.reportBuilder.addListItem("No elements found matching the search criteria");
+    } else {
+      this.reportBuilder.addLine(`Found ${foundElements.length} matching elements:`);
+      for (let index = 0;index < foundElements.length; index++) {
+        const element = foundElements[index];
+        this.reportBuilder.addLine(`${index + 1}. **${element.selector}** (${(element.confidence * 100).toFixed(0)}% confidence)`);
+        this.reportBuilder.addLine(`   - ${element.reason}`);
+      }
+    }
+    this.reportBuilder.addEmptyLine();
+  }
+  async addPerformanceSection(analysisResult, unifiedSystem, pageAnalyzer, options) {
+    const shouldIncludeMetrics = (options.includePerformanceMetrics || options.diagnosticLevel === "detailed" || options.diagnosticLevel === "full") && options.diagnosticLevel !== "basic";
+    if (!shouldIncludeMetrics) {
+      return;
+    }
+    const diagnosisTime = Date.now() - options.startTime;
+    this.reportBuilder.addHeader("Performance Metrics", 2).addKeyValue("Diagnosis execution time", `${diagnosisTime}ms`);
+    try {
+      const comprehensiveMetrics = await this.getComprehensiveMetrics(analysisResult, unifiedSystem, pageAnalyzer);
+      addDomComplexityMetrics(this.reportBuilder, comprehensiveMetrics);
+      addInteractionMetrics(this.reportBuilder, comprehensiveMetrics);
+      addResourceMetrics(this.reportBuilder, comprehensiveMetrics);
+      if (options.diagnosticLevel === "full") {
+        this.addLayoutMetrics(comprehensiveMetrics);
+      }
+      this.addPerformanceWarnings(comprehensiveMetrics);
+    } catch (error) {
+      addErrorSection(this.reportBuilder, error, "analyzing performance metrics");
+    }
+    await this.addBrowserPerformanceMetrics();
+    this.reportBuilder.addEmptyLine();
+  }
+  async getComprehensiveMetrics(analysisResult, unifiedSystem, pageAnalyzer) {
+    if (analysisResult.performanceMetrics) {
+      return analysisResult.performanceMetrics;
+    }
+    if (pageAnalyzer) {
+      return await pageAnalyzer.analyzePerformanceMetrics();
+    }
+    if (unifiedSystem) {
+      const perfResult = await unifiedSystem.analyzePerformanceMetrics();
+      if (perfResult.success) {
+        return perfResult.data;
+      }
+      throw new Error(`Performance metrics analysis failed: ${getErrorMessage(perfResult.error)}`);
+    }
+    throw new Error("No performance analyzer available");
+  }
+  addLayoutMetrics(metrics) {
+    const layoutData = [
+      [
+        "Fixed position elements",
+        metrics?.layoutMetrics?.fixedElements?.length ?? 0
+      ],
+      [
+        "High z-index elements",
+        metrics?.layoutMetrics?.highZIndexElements?.length ?? 0
+      ],
+      [
+        "Overflow hidden elements",
+        metrics?.layoutMetrics?.overflowHiddenElements ?? 0
+      ]
+    ];
+    this.addKeyValuePairs(layoutData, undefined, "Layout Analysis", 3);
+    this.addElementList("Fixed Elements", metrics?.layoutMetrics?.fixedElements, (element, index) => `${index + 1}. **${element.selector}**: ${element.purpose} (z-index: ${element.zIndex})`);
+    this.addElementList("High Z-Index Elements", metrics?.layoutMetrics?.highZIndexElements, (element, index) => `${index + 1}. **${element.selector}**: z-index ${element.zIndex} (${element.description})`);
+  }
+  addPerformanceWarnings(metrics) {
+    if (metrics?.warnings?.length && metrics.warnings.length > 0) {
+      this.reportBuilder.addEmptyLine().addHeader("Performance Warnings", 3);
+      for (const warning of metrics.warnings) {
+        const icon = warning.level === "danger" ? "\uD83D\uDEA8" : "⚠️";
+        this.reportBuilder.addListItem(`${icon} **${warning.type}**: ${warning.message}`);
+      }
+    }
+  }
+  async addBrowserPerformanceMetrics() {
+    try {
+      const browserMetrics = await this.tab.page.evaluate(() => {
+        const navigationEntries = performance.getEntriesByType("navigation");
+        const navigation = navigationEntries[0];
+        const paint = performance.getEntriesByType("paint");
+        return {
+          domContentLoaded: navigation?.domContentLoadedEventEnd != null && navigation?.domContentLoadedEventStart != null ? navigation.domContentLoadedEventEnd - navigation.domContentLoadedEventStart : undefined,
+          loadComplete: navigation?.loadEventEnd != null && navigation?.loadEventStart != null ? navigation.loadEventEnd - navigation.loadEventStart : undefined,
+          firstPaint: paint.find((p) => p.name === "first-paint")?.startTime,
+          firstContentfulPaint: paint.find((p) => p.name === "first-contentful-paint")?.startTime
+        };
+      });
+      const metricsWithValues = processBrowserMetrics(browserMetrics);
+      if (metricsWithValues.length > 0) {
+        this.addKeyValuePairs(metricsWithValues, undefined, "Browser Performance Timing", 3);
+      }
+    } catch (error) {
+      addErrorSection(this.reportBuilder, error, "retrieving browser timing metrics");
+    }
+  }
+  async addAccessibilitySection(diagnosticInfo, options) {
+    if (!this.shouldIncludeSection(options, "accessibility")) {
+      return;
+    }
+    const a11yMetrics = await this.tab.page.evaluate(() => {
+      const headings = document.querySelectorAll("h1, h2, h3, h4, h5, h6").length;
+      const landmarks = document.querySelectorAll('[role="main"], [role="navigation"], [role="banner"], [role="contentinfo"], main, nav, header, footer').length;
+      const altTexts = document.querySelectorAll("img[alt]").length;
+      const totalImages = document.querySelectorAll("img").length;
+      return { headings, landmarks, imagesWithAlt: altTexts, totalImages };
+    });
+    const a11yData = [
+      [
+        "Elements with missing ARIA labels",
+        diagnosticInfo.elements.missingAria
+      ],
+      ["Heading elements", a11yMetrics.headings],
+      ["Landmark elements", a11yMetrics.landmarks],
+      [
+        "Images with alt text",
+        `${a11yMetrics.imagesWithAlt}/${a11yMetrics.totalImages}`
+      ]
+    ];
+    this.addKeyValuePairs(a11yData, "Accessibility Information");
+  }
+  addTroubleshootingSection(diagnosticInfo, options) {
+    if (!this.shouldIncludeSection(options, "troubleshooting")) {
+      return;
+    }
+    this.reportBuilder.addHeader("Troubleshooting Suggestions", 2);
+    const suggestions = new ArrayBuilder().addIf(diagnosticInfo.iframes.detected, "Elements might be inside iframes - use frameLocator() for iframe interactions").addIf(diagnosticInfo.modalStates.blockedBy.length > 0, `Active modal states (${diagnosticInfo.modalStates.blockedBy.join(", ")}) may block interactions`).addIf(diagnosticInfo.elements.missingAria > 0, `${diagnosticInfo.elements.missingAria} elements lack proper ARIA attributes - consider using text-based selectors`).addIf(diagnosticInfo.elements.totalInteractable < diagnosticInfo.elements.totalVisible * 0.1, "Low ratio of interactable elements - page might still be loading or have CSS issues").build();
+    const finalSuggestions = suggestions.length === 0 ? [
+      "No obvious issues detected - page appears to be in good state for automation"
+    ] : suggestions;
+    for (const suggestion of finalSuggestions) {
+      this.reportBuilder.addListItem(suggestion);
+    }
+    this.reportBuilder.addEmptyLine();
+  }
+}
+export {
+  DiagnoseReportBuilder
+};

package/lib/tools/diagnose.js

@@ -0,0 +1,147 @@
+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.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { createErrorReporter } from "../utils/error-handler-middleware.js";
+import { DiagnoseAnalysisRunner } from "./diagnose/diagnose-analysis-runner.js";
+import { DiagnoseConfigHandler } from "./diagnose/diagnose-config-handler.js";
+import { DiagnoseReportBuilder } from "./diagnose/diagnose-report-builder.js";
+import { defineTabTool } from "./tool.js";
+var diagnoseSchema = z.object({
+  searchForElements: z.object({
+    text: z.string().optional(),
+    role: z.string().optional(),
+    tagName: z.string().optional(),
+    attributes: z.record(z.string()).optional()
+  }).optional().describe("Search for specific elements and include them in the report"),
+  includePerformanceMetrics: z.boolean().optional().default(false).describe("Include performance metrics in the report"),
+  includeAccessibilityInfo: z.boolean().optional().default(false).describe("Include accessibility information"),
+  includeTroubleshootingSuggestions: z.boolean().optional().default(false).describe("Include troubleshooting suggestions"),
+  diagnosticLevel: z.enum(["none", "basic", "standard", "detailed", "full"]).optional().default("standard").describe("Level of diagnostic detail: none (no diagnostics), basic (critical only), standard (default), detailed (with metrics), full (all info)"),
+  useParallelAnalysis: z.boolean().optional().default(false).describe("Use Phase 2 parallel analysis for improved performance and resource monitoring"),
+  useUnifiedSystem: z.boolean().optional().default(true).describe("Use Phase 3 unified diagnostic system with enhanced error handling and monitoring"),
+  configOverrides: z.object({
+    enableResourceMonitoring: z.boolean().optional(),
+    enableErrorEnrichment: z.boolean().optional(),
+    enableAdaptiveThresholds: z.boolean().optional(),
+    performanceThresholds: z.object({
+      pageAnalysis: z.number().optional(),
+      elementDiscovery: z.number().optional(),
+      resourceMonitoring: z.number().optional()
+    }).optional()
+  }).optional().describe("Runtime configuration overrides for diagnostic system"),
+  includeSystemStats: z.boolean().optional().default(false).describe("Include unified system statistics and health information"),
+  expectation: expectationSchema.optional()
+}).describe("Generate a comprehensive diagnostic report of the current page");
+var browserDiagnose = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_diagnose",
+    title: "Diagnose page",
+    type: "readOnly",
+    description: "Analyze page complexity and performance characteristics. Reports on: iframe count, DOM size, modal states, element statistics. Use for: debugging slow pages, understanding page structure, or monitoring page complexity.",
+    inputSchema: diagnoseSchema
+  },
+  handle: async (tab, params, response) => {
+    const config = extractDiagnoseConfig(params);
+    try {
+      if (config.diagnosticLevel === "none") {
+        response.addResult("Diagnostics disabled (level: none)");
+        return;
+      }
+      const startTime = Date.now();
+      await executeDiagnoseProcess(tab, config, response, startTime);
+    } catch (error) {
+      handleDiagnoseError(error, response);
+    }
+  }
+});
+function extractDiagnoseConfig(params) {
+  return {
+    searchForElements: params.searchForElements,
+    includePerformanceMetrics: Boolean(params.includePerformanceMetrics ?? false),
+    includeAccessibilityInfo: Boolean(params.includeAccessibilityInfo ?? false),
+    includeTroubleshootingSuggestions: Boolean(params.includeTroubleshootingSuggestions ?? false),
+    diagnosticLevel: params.diagnosticLevel ?? "standard",
+    useParallelAnalysis: Boolean(params.useParallelAnalysis ?? false),
+    useUnifiedSystem: Boolean(params.useUnifiedSystem ?? true),
+    configOverrides: params.configOverrides,
+    includeSystemStats: Boolean(params.includeSystemStats ?? false)
+  };
+}
+async function executeDiagnoseProcess(tab, config, response, startTime) {
+  const configHandler = new DiagnoseConfigHandler;
+  const _configDiagnostics = validateAndSetupConfig(configHandler, config, response);
+  const systemConfig = configHandler.initializeSystems(tab, config.useUnifiedSystem, config.useParallelAnalysis, config.configOverrides || {});
+  try {
+    const report = await runAnalysisAndBuildReport(tab, systemConfig, config, startTime);
+    response.addResult(report);
+  } finally {
+    await cleanupSystems(systemConfig);
+  }
+}
+function validateAndSetupConfig(configHandler, config, response) {
+  const configDiagnostics = configHandler.validateConfiguration();
+  if (config.diagnosticLevel === "full" && config.includeSystemStats) {
+    response.addResult(`## Configuration Status
+- **Thresholds Status**: ${configDiagnostics.status}
+- **Customizations**: ${configDiagnostics.customizations.length} active
+- **Warnings**: ${configDiagnostics.warnings.length} items
+
+`);
+  }
+  if (configDiagnostics.status === "failed") {
+    response.addError("Configuration system validation failed - using fallback settings");
+  }
+  return configDiagnostics;
+}
+async function runAnalysisAndBuildReport(tab, systemConfig, config, startTime) {
+  const analysisRunner = new DiagnoseAnalysisRunner;
+  const analysisResult = await analysisRunner.runAnalysis(systemConfig.unifiedSystem ?? null, systemConfig.pageAnalyzer ?? null, config.useParallelAnalysis, config.includeSystemStats);
+  const reportBuilder = new DiagnoseReportBuilder(tab);
+  const reportOptions = {
+    diagnosticLevel: config.diagnosticLevel,
+    includePerformanceMetrics: config.includePerformanceMetrics,
+    includeAccessibilityInfo: config.includeAccessibilityInfo,
+    includeTroubleshootingSuggestions: config.includeTroubleshootingSuggestions,
+    includeSystemStats: config.includeSystemStats,
+    searchForElements: config.searchForElements,
+    appliedOverrides: systemConfig.appliedOverrides,
+    startTime
+  };
+  return await reportBuilder.buildReport(analysisResult, systemConfig.unifiedSystem ?? null, systemConfig.pageAnalyzer ?? null, reportOptions);
+}
+async function cleanupSystems(systemConfig) {
+  if (!systemConfig.unifiedSystem && systemConfig.pageAnalyzer) {
+    await systemConfig.pageAnalyzer.dispose();
+  }
+}
+function handleDiagnoseError(error, response) {
+  const errorReporter = createErrorReporter("Diagnose");
+  try {
+    errorReporter.reportAndThrow(error, "generateDiagnosticReport");
+  } catch (enrichedError) {
+    response.addError(enrichedError instanceof Error ? enrichedError.message : String(enrichedError));
+  }
+}
+export {
+  browserDiagnose
+};

package/lib/tools/dialogs.js

@@ -0,0 +1,57 @@
+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/dialogs.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTabTool } from "./tool.js";
+var handleDialog = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_handle_dialog",
+    title: "Handle a dialog",
+    description: `Handle a dialog(alert,confirm,prompt).accept:true to accept,false to dismiss.promptText:"answer" for prompt dialogs.expectation:{includeSnapshot:true} to see page after dialog handling.USE batch_execute if dialog appears during workflow.`,
+    inputSchema: z.object({
+      accept: z.boolean().describe("Whether to accept the dialog."),
+      promptText: z.string().optional().describe("The text of the prompt in case of a prompt dialog."),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const dialogState = tab.modalStates().find((state) => state.type === "dialog");
+    if (!dialogState) {
+      throw new Error("No dialog visible");
+    }
+    tab.clearModalState(dialogState);
+    await tab.waitForCompletion(async () => {
+      if (params.accept) {
+        await dialogState.dialog.accept(params.promptText);
+      } else {
+        await dialogState.dialog.dismiss();
+      }
+    });
+  },
+  clearsModalState: "dialog"
+});
+var dialogs_default = [handleDialog];
+export {
+  dialogs_default as default
+};

package/lib/tools/evaluate.js

@@ -0,0 +1,67 @@
+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/evaluate.ts
+import { z } from "zod";
+import { quote } from "../javascript.js";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTabTool } from "./tool.js";
+import { generateLocator } from "./utils.js";
+var evaluateSchema = z.object({
+  function: z.string().describe("() => { /* code */ } or (element) => { /* code */ } when element is provided"),
+  element: z.string().optional().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: z.string().optional().describe("Exact target element reference from the page snapshot"),
+  expectation: expectationSchema
+});
+var evaluate = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_evaluate",
+    title: "Evaluate JavaScript",
+    description: "Evaluate JavaScript expression on page or element.Returns evaluation result.USE CASES:extract data,modify DOM,trigger events.expectation:{includeSnapshot:false} for data extraction,true if modifying page.element+ref to run on specific element.CONSIDER batch_execute for multiple evaluations.",
+    inputSchema: evaluateSchema,
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    let locator;
+    if (params.ref && params.element) {
+      locator = await tab.refLocator({
+        ref: params.ref,
+        element: params.element
+      });
+      response.addCode(`await page.${await generateLocator(locator)}.evaluate(${quote(params.function)});`);
+    } else {
+      response.addCode(`await page.evaluate(${quote(params.function)});`);
+    }
+    await tab.waitForCompletion(async () => {
+      try {
+        const receiver = locator ?? tab.page;
+        const result = await receiver._evaluateFunction(params.function);
+        const stringifiedResult = JSON.stringify(result, null, 2);
+        response.addResult(stringifiedResult ?? "undefined");
+      } catch (error) {
+        response.addError(`JavaScript evaluation failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    });
+  }
+});
+var evaluate_default = [evaluate];
+export {
+  evaluate_default as default
+};