@tontoko/fast-playwright-mcp 0.0.4

package/lib/context.js

@@ -0,0 +1,274 @@
+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/context.ts
+import debug from "debug";
+import { BatchExecutor } from "./batch/batch-executor.js";
+import { outputFile } from "./config.js";
+import { logUnhandledError } from "./log.js";
+import { Tab } from "./tab.js";
+var testDebug = debug("pw:mcp:test");
+
+class Context {
+  tools;
+  config;
+  sessionLog;
+  options;
+  _browserContextPromise;
+  _browserContextFactory;
+  _tabs = [];
+  _currentTab;
+  _clientInfo;
+  _batchExecutor;
+  static _allContexts = new Set;
+  _closeBrowserContextPromise;
+  _isRunningTool = false;
+  _abortController = new AbortController;
+  constructor(options) {
+    this.tools = options.tools;
+    this.config = options.config;
+    this.sessionLog = options.sessionLog;
+    this.options = options;
+    this._browserContextFactory = options.browserContextFactory;
+    this._clientInfo = options.clientInfo;
+    testDebug("create context");
+    Context._allContexts.add(this);
+  }
+  static async disposeAll() {
+    await Promise.all([...Context._allContexts].map((context) => context.dispose()));
+  }
+  tabs() {
+    return this._tabs;
+  }
+  currentTab() {
+    return this._currentTab;
+  }
+  currentTabOrDie() {
+    if (!this._currentTab) {
+      throw new Error('No open pages available. Use the "browser_navigate" tool to navigate to a page first.');
+    }
+    return this._currentTab;
+  }
+  async newTab() {
+    const { browserContext } = await this._ensureBrowserContext();
+    const page = await browserContext.newPage();
+    const tab = this._tabs.find((t) => t.page === page);
+    if (!tab) {
+      throw new Error("Failed to create tab: tab not found after creation");
+    }
+    this._currentTab = tab;
+    return this._currentTab;
+  }
+  async selectTab(index) {
+    const tab = this._tabs[index];
+    if (!tab) {
+      throw new Error(`Tab ${index} not found`);
+    }
+    await tab.page.bringToFront();
+    this._currentTab = tab;
+    return tab;
+  }
+  async ensureTab() {
+    const { browserContext } = await this._ensureBrowserContext();
+    if (!this._currentTab) {
+      await browserContext.newPage();
+    }
+    if (!this._currentTab) {
+      throw new Error("Failed to ensure tab: current tab is null after creating page");
+    }
+    return this._currentTab;
+  }
+  async closeTab(index) {
+    const tab = index === undefined ? this._currentTab : this._tabs[index];
+    if (!tab) {
+      throw new Error(`Tab ${index} not found`);
+    }
+    const url = tab.page.url();
+    await tab.page.close();
+    return url;
+  }
+  outputFile(name) {
+    return outputFile(this.config, this._clientInfo.rootPath, name);
+  }
+  _onPageCreated(page) {
+    const newTab = new Tab(this, page, (closedTab) => this._onPageClosed(closedTab));
+    this._tabs.push(newTab);
+    this._currentTab ??= newTab;
+  }
+  _onPageClosed(tab) {
+    const index = this._tabs.indexOf(tab);
+    if (index === -1) {
+      return;
+    }
+    this._tabs.splice(index, 1);
+    if (this._currentTab === tab) {
+      this._currentTab = this._tabs[Math.min(index, this._tabs.length - 1)];
+    }
+    if (!this._tabs.length) {
+      this.closeBrowserContext().catch(() => {});
+    }
+  }
+  async closeBrowserContext() {
+    this._closeBrowserContextPromise ??= this._closeBrowserContextImpl().catch(logUnhandledError);
+    await this._closeBrowserContextPromise;
+    this._closeBrowserContextPromise = undefined;
+  }
+  isRunningTool() {
+    return this._isRunningTool;
+  }
+  setRunningTool(isRunningTool) {
+    this._isRunningTool = isRunningTool;
+  }
+  getBatchExecutor() {
+    this._batchExecutor ??= (() => {
+      const toolRegistry = new Map;
+      for (const tool of this.tools) {
+        toolRegistry.set(tool.schema.name, tool);
+      }
+      return new BatchExecutor(this, toolRegistry);
+    })();
+    return this._batchExecutor;
+  }
+  async _closeBrowserContextImpl() {
+    if (!this._browserContextPromise) {
+      return;
+    }
+    testDebug("close context");
+    const promise = this._browserContextPromise;
+    this._browserContextPromise = undefined;
+    await promise.then(async ({ browserContext, close }) => {
+      if (this.config.saveTrace) {
+        await browserContext.tracing.stop();
+      }
+      await close();
+    });
+  }
+  async dispose() {
+    this._abortController.abort("MCP context disposed");
+    await this.closeBrowserContext();
+    Context._allContexts.delete(this);
+  }
+  async _setupRequestInterception(context) {
+    if (this.config.network?.allowedOrigins?.length) {
+      await context.route("**", (route) => route.abort("blockedbyclient"));
+      await Promise.all(this.config.network.allowedOrigins.map((origin) => context.route(`*://${origin}/**`, (route) => route.continue())));
+    }
+    if (this.config.network?.blockedOrigins?.length) {
+      await Promise.all(this.config.network.blockedOrigins.map((origin) => context.route(`*://${origin}/**`, (route) => route.abort("blockedbyclient"))));
+    }
+  }
+  _ensureBrowserContext() {
+    this._browserContextPromise ??= (() => {
+      const promise = this._setupBrowserContext();
+      promise.catch(() => {
+        this._browserContextPromise = undefined;
+      });
+      return promise;
+    })();
+    return this._browserContextPromise;
+  }
+  async _setupBrowserContext() {
+    if (this._closeBrowserContextPromise) {
+      throw new Error("Another browser context is being closed.");
+    }
+    const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal);
+    const { browserContext } = result;
+    await this._setupRequestInterception(browserContext);
+    if (this.sessionLog) {
+      await InputRecorder.create(this, browserContext);
+    }
+    for (const page of browserContext.pages()) {
+      this._onPageCreated(page);
+    }
+    browserContext.on("page", (page) => this._onPageCreated(page));
+    if (this.config.saveTrace) {
+      await browserContext.tracing.start({
+        name: "trace",
+        screenshots: false,
+        snapshots: true,
+        sources: false
+      });
+    }
+    return result;
+  }
+}
+
+class InputRecorder {
+  _context;
+  _browserContext;
+  constructor(context, browserContext) {
+    this._context = context;
+    this._browserContext = browserContext;
+  }
+  static async create(context, browserContext) {
+    const recorder = new InputRecorder(context, browserContext);
+    await recorder._initialize();
+    return recorder;
+  }
+  async _initialize() {
+    const sessionLog = this._context.sessionLog;
+    if (!sessionLog) {
+      throw new Error("Session log is required for recorder initialization");
+    }
+    await this._browserContext._enableRecorder({
+      mode: "recording",
+      recorderMode: "api"
+    }, {
+      actionAdded: (page, data, code) => {
+        if (this._context.isRunningTool()) {
+          return;
+        }
+        const tab = Tab.forPage(page);
+        if (tab) {
+          sessionLog.logUserAction(data.action, tab, code, false);
+        }
+      },
+      actionUpdated: (page, data, code) => {
+        if (this._context.isRunningTool()) {
+          return;
+        }
+        const tab = Tab.forPage(page);
+        if (tab) {
+          sessionLog.logUserAction(data.action, tab, code, true);
+        }
+      },
+      signalAdded: (page, data) => {
+        if (this._context.isRunningTool()) {
+          return;
+        }
+        if (data.signal.name !== "navigation") {
+          return;
+        }
+        const tab = Tab.forPage(page);
+        const navigateAction = {
+          name: "navigate",
+          url: data.signal.url,
+          signals: []
+        };
+        if (tab) {
+          sessionLog.logUserAction(navigateAction, tab, `await page.goto('${data.signal.url}');`, false);
+        }
+      }
+    });
+  }
+}
+export {
+  InputRecorder,
+  Context
+};

package/lib/diagnostics/common/diagnostic-base.js

@@ -0,0 +1,63 @@
+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/diagnostic-base.ts
+class DiagnosticBase {
+  isDisposed = false;
+  componentName;
+  page;
+  constructor(page, componentName) {
+    this.page = page;
+    this.componentName = componentName;
+  }
+  checkDisposed() {
+    if (this.isDisposed) {
+      throw new Error(`${this.componentName} has been disposed`);
+    }
+  }
+  getPage() {
+    this.checkDisposed();
+    if (!this.page) {
+      throw new Error("Page reference is null");
+    }
+    return this.page;
+  }
+  getIsDisposed() {
+    return this.isDisposed;
+  }
+  get disposed() {
+    return this.isDisposed;
+  }
+  markDisposed() {
+    this.isDisposed = true;
+  }
+  async dispose() {
+    if (this.isDisposed) {
+      return;
+    }
+    try {
+      await this.performDispose();
+    } catch {} finally {
+      this.markDisposed();
+    }
+  }
+}
+export {
+  DiagnosticBase
+};

package/lib/diagnostics/common/error-enrichment-utils.js

@@ -0,0 +1,212 @@
+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/error-enrichment-utils.ts
+import { deduplicateAndLimit } from "../../utils/array-utils.js";
+var errorPatterns = new Map([
+  [
+    /timeout/i,
+    [
+      "Consider increasing timeout values",
+      "Check for slow network conditions",
+      "Verify element loading states"
+    ]
+  ],
+  [
+    /not found|element not visible/i,
+    [
+      "Verify element selector accuracy",
+      "Wait for element to become visible",
+      "Check if element is in correct frame context"
+    ]
+  ],
+  [
+    /not enabled|disabled/i,
+    [
+      "Wait for element to become enabled",
+      "Check element state and attributes",
+      "Verify no modal dialogs are blocking interaction"
+    ]
+  ],
+  [
+    /disposed|disposed/i,
+    [
+      "Component or resource was disposed prematurely",
+      "Check component lifecycle management",
+      "Ensure proper initialization before use"
+    ]
+  ],
+  [
+    /memory/i,
+    [
+      "Check for memory leaks or excessive resource usage",
+      "Consider more aggressive resource cleanup",
+      "Monitor memory usage patterns"
+    ]
+  ]
+]);
+function getPatternBasedSuggestions(message) {
+  const suggestions = [];
+  for (const [pattern, patternSuggestions] of errorPatterns) {
+    if (pattern.test(message)) {
+      suggestions.push(...patternSuggestions);
+    }
+  }
+  return suggestions;
+}
+function getContextSpecificSuggestions(context) {
+  const suggestions = [];
+  if (context.executionTime && context.executionTime > 5000) {
+    suggestions.push("Long execution time detected - consider optimization");
+  }
+  if (context.selector) {
+    suggestions.push(`Failed selector: ${context.selector}`);
+    if (context.selector.includes("#")) {
+      suggestions.push("ID selectors may be fragile - consider alternatives");
+    }
+    if (context.selector.includes("nth-child")) {
+      suggestions.push("Position-based selectors are fragile - use semantic selectors");
+    }
+  }
+  if (context.component === "PageAnalyzer") {
+    suggestions.push("Consider using parallel analysis for complex pages");
+  }
+  if (context.operation.includes("iframe")) {
+    suggestions.push("Check iframe accessibility and cross-origin restrictions");
+  }
+  return suggestions;
+}
+function generateSuggestions(error, context) {
+  const suggestions = [];
+  const message = error.message.toLowerCase();
+  suggestions.push(...getPatternBasedSuggestions(message));
+  if (context) {
+    suggestions.push(...getContextSpecificSuggestions(context));
+  }
+  return deduplicateAndLimit(suggestions, 5);
+}
+async function safeDispose(resource, _resourceType, _operation) {
+  try {
+    await resource.dispose();
+  } catch (error) {
+    console.warn(`Failed to dispose ${_resourceType} during ${_operation}:`, error);
+  }
+}
+async function safeDisposeAll(resources, resourceType, operation) {
+  const disposePromises = resources.map((resource) => safeDispose(resource, resourceType, operation));
+  await Promise.allSettled(disposePromises);
+}
+function createEnrichedError(originalError, context, additionalSuggestions = []) {
+  const suggestions = [
+    ...generateSuggestions(originalError, context),
+    ...additionalSuggestions
+  ];
+  const enhancedError = new Error(originalError.message);
+  enhancedError.originalError = originalError;
+  enhancedError.context = context;
+  enhancedError.suggestions = suggestions;
+  return {
+    enhancedError,
+    suggestions,
+    contextInfo: {
+      component: context.component,
+      operation: context.operation,
+      executionTime: context.executionTime,
+      timestamp: Date.now()
+    }
+  };
+}
+function analyzePatternFrequency(errors) {
+  const patternCounts = new Map;
+  const patternSuggestions = new Map;
+  for (const { error } of errors) {
+    const message = error.message.toLowerCase();
+    for (const [pattern, suggestions] of errorPatterns) {
+      if (pattern.test(message)) {
+        const patternStr = pattern.source;
+        patternCounts.set(patternStr, (patternCounts.get(patternStr) ?? 0) + 1);
+        if (!patternSuggestions.has(patternStr)) {
+          patternSuggestions.set(patternStr, new Set);
+        }
+        for (const s of suggestions) {
+          patternSuggestions.get(patternStr)?.add(s);
+        }
+      }
+    }
+  }
+  return { patternCounts, patternSuggestions };
+}
+function buildFrequentPatterns(patternCounts, patternSuggestions) {
+  return Array.from(patternCounts.entries()).filter(([, count]) => count > 1).sort(([, a], [, b]) => b - a).map(([pattern, count]) => ({
+    pattern,
+    count,
+    suggestions: Array.from(patternSuggestions.get(pattern) ?? [])
+  }));
+}
+function analyzeTimeBasedPatterns(errors) {
+  const now = Date.now();
+  const oneHour = 60 * 60 * 1000;
+  const recentErrors = errors.filter((e) => now - e.timestamp < oneHour);
+  return {
+    recentErrors: recentErrors.length,
+    errorRate: errors.length > 0 ? recentErrors.length / errors.length : 0
+  };
+}
+function analyzeComponentErrors(errors) {
+  const componentAnalysis = {};
+  for (const { context } of errors) {
+    componentAnalysis[context.component] = (componentAnalysis[context.component] ?? 0) + 1;
+  }
+  return componentAnalysis;
+}
+function analyzeErrorPatterns(errors) {
+  const { patternCounts, patternSuggestions } = analyzePatternFrequency(errors);
+  const frequentPatterns = buildFrequentPatterns(patternCounts, patternSuggestions);
+  const timeBasedAnalysis = analyzeTimeBasedPatterns(errors);
+  const componentAnalysis = analyzeComponentErrors(errors);
+  return {
+    frequentPatterns,
+    timeBasedAnalysis,
+    componentAnalysis
+  };
+}
+function generateRecoverySuggestions(errorAnalysis) {
+  const suggestions = [];
+  if (errorAnalysis.timeBasedAnalysis.errorRate > 0.5) {
+    suggestions.push("High error rate detected - review recent changes");
+  }
+  if (errorAnalysis.frequentPatterns.length > 0) {
+    const mostFrequent = errorAnalysis.frequentPatterns[0];
+    suggestions.push(`Most frequent error pattern: ${mostFrequent.pattern} (${mostFrequent.count} occurrences)`);
+    suggestions.push(...mostFrequent.suggestions.slice(0, 2));
+  }
+  const componentWithMostErrors = Object.entries(errorAnalysis.componentAnalysis).sort(([, a], [, b]) => b - a)[0];
+  if (componentWithMostErrors && componentWithMostErrors[1] > 3) {
+    suggestions.push(`${componentWithMostErrors[0]} component has frequent errors - review implementation`);
+  }
+  return suggestions.slice(0, 5);
+}
+export {
+  safeDisposeAll,
+  safeDispose,
+  generateSuggestions,
+  generateRecoverySuggestions,
+  createEnrichedError,
+  analyzeErrorPatterns
+};

package/lib/diagnostics/common/index.js

@@ -0,0 +1,56 @@
+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/index.ts
+import {
+  DiagnosticBase
+} from "./diagnostic-base.js";
+import {
+  analyzeErrorPatterns,
+  createEnrichedError,
+  generateRecoverySuggestions,
+  generateSuggestions,
+  safeDispose,
+  safeDisposeAll
+} from "./error-enrichment-utils.js";
+import {
+  createAdvancedStage,
+  createCoreStage,
+  createDependentStage,
+  InitializationManager
+} from "./initialization-manager.js";
+import {
+  globalPerformanceTracker,
+  PerformanceTracker
+} from "./performance-tracker.js";
+export {
+  safeDisposeAll,
+  safeDispose,
+  globalPerformanceTracker,
+  generateSuggestions,
+  generateRecoverySuggestions,
+  createEnrichedError,
+  createDependentStage,
+  createCoreStage,
+  createAdvancedStage,
+  analyzeErrorPatterns,
+  PerformanceTracker,
+  InitializationManager,
+  DiagnosticBase
+};