@tontoko/fast-playwright-mcp 0.0.4

package/lib/schemas/expectation.js

@@ -0,0 +1,152 @@
+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/schemas/expectation.ts
+import { z } from "zod";
+var diffOptionsSchema = z.object({
+  enabled: z.boolean().default(false),
+  threshold: z.number().min(0).max(1).default(0.1),
+  format: z.enum(["unified", "split", "minimal"]).default("unified"),
+  maxDiffLines: z.number().positive().default(50),
+  ignoreWhitespace: z.boolean().default(true),
+  context: z.number().min(0).default(3)
+}).optional();
+var expectationSchema = z.object({
+  includeSnapshot: z.boolean().optional().default(false),
+  includeConsole: z.boolean().optional().default(false),
+  includeDownloads: z.boolean().optional().default(false),
+  includeTabs: z.boolean().optional().default(false),
+  includeCode: z.boolean().optional().default(false),
+  snapshotOptions: z.object({
+    selector: z.string().optional().describe("CSS selector to limit snapshot scope"),
+    maxLength: z.number().optional().describe("Maximum characters for snapshot"),
+    format: z.enum(["aria", "text", "html"]).optional().default("aria")
+  }).optional(),
+  consoleOptions: 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(),
+  imageOptions: z.object({
+    quality: z.number().min(1).max(100).optional().describe("JPEG quality (1-100)"),
+    maxWidth: z.number().optional().describe("Maximum width in pixels"),
+    maxHeight: z.number().optional().describe("Maximum height in pixels"),
+    format: z.enum(["jpeg", "png", "webp"]).optional()
+  }).optional(),
+  diffOptions: diffOptionsSchema
+}).optional();
+var TOOL_DEFAULTS = {
+  browser_navigate: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_click: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_type: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_take_screenshot: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_snapshot: {
+    includeSnapshot: true,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_evaluate: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_pdf_save: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: true
+  },
+  browser_wait_for: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: false,
+    includeCode: false
+  },
+  browser_close: {
+    includeSnapshot: false,
+    includeConsole: false,
+    includeDownloads: false,
+    includeTabs: true,
+    includeCode: true
+  }
+};
+var GENERAL_DEFAULT = {
+  includeSnapshot: false,
+  includeConsole: false,
+  includeDownloads: false,
+  includeTabs: false,
+  includeCode: false
+};
+function getDefaultExpectation(toolName) {
+  return TOOL_DEFAULTS[toolName] ?? GENERAL_DEFAULT;
+}
+function mergeExpectations(toolName, userExpectation) {
+  const defaults = getDefaultExpectation(toolName);
+  if (!userExpectation) {
+    return defaults;
+  }
+  return {
+    includeSnapshot: userExpectation.includeSnapshot ?? defaults.includeSnapshot,
+    includeConsole: userExpectation.includeConsole ?? defaults.includeConsole,
+    includeDownloads: userExpectation.includeDownloads ?? defaults.includeDownloads,
+    includeTabs: userExpectation.includeTabs ?? defaults.includeTabs,
+    includeCode: userExpectation.includeCode ?? defaults.includeCode,
+    snapshotOptions: userExpectation.snapshotOptions,
+    consoleOptions: userExpectation.consoleOptions,
+    imageOptions: userExpectation.imageOptions,
+    diffOptions: userExpectation.diffOptions
+  };
+}
+export {
+  mergeExpectations,
+  getDefaultExpectation,
+  expectationSchema,
+  diffOptionsSchema
+};

package/lib/session-log.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/session-log.ts
+import fs from "node:fs";
+import path from "node:path";
+import { outputFile } from "./config.js";
+import { logUnhandledError } from "./log.js";
+
+class SessionLog {
+  _folder;
+  _file;
+  _pendingEntries = [];
+  _sessionFileQueue = Promise.resolve();
+  _flushEntriesTimeout;
+  _ordinal = 0;
+  constructor(sessionFolder) {
+    this._folder = sessionFolder;
+    this._file = path.join(this._folder, "session.md");
+  }
+  static async create(config, rootPath) {
+    const sessionFolder = await outputFile(config, rootPath, `session-${Date.now()}`);
+    await fs.promises.mkdir(sessionFolder, { recursive: true });
+    return new SessionLog(sessionFolder);
+  }
+  logResponse(response) {
+    const entry = {
+      timestamp: performance.now(),
+      toolCall: {
+        toolName: response.toolName,
+        toolArgs: response.toolArgs,
+        result: response.result(),
+        isError: response.isError()
+      },
+      code: response.code(),
+      tabSnapshot: response.tabSnapshot()
+    };
+    this._appendEntry(entry);
+  }
+  logUserAction(action, tab, code, isUpdate) {
+    const trimmedCode = code.trim();
+    if (this._shouldUpdateExistingEntry(action, isUpdate, trimmedCode)) {
+      return;
+    }
+    if (this._shouldSkipDuplicateNavigation(action)) {
+      return;
+    }
+    const entry = this._createUserActionEntry(action, tab, trimmedCode);
+    this._appendEntry(entry);
+  }
+  _shouldUpdateExistingEntry(action, isUpdate, trimmedCode) {
+    if (!isUpdate) {
+      return false;
+    }
+    const lastEntry = this._pendingEntries.at(-1);
+    if (lastEntry?.userAction?.name === action.name) {
+      lastEntry.userAction = action;
+      lastEntry.code = trimmedCode;
+      return true;
+    }
+    return false;
+  }
+  _shouldSkipDuplicateNavigation(action) {
+    if (action.name !== "navigate") {
+      return false;
+    }
+    const lastEntry = this._pendingEntries.at(-1);
+    return lastEntry?.tabSnapshot?.url === action.url;
+  }
+  _createUserActionEntry(action, tab, trimmedCode) {
+    return {
+      timestamp: performance.now(),
+      userAction: action,
+      code: trimmedCode,
+      tabSnapshot: this._createTabSnapshot(action, tab)
+    };
+  }
+  _createTabSnapshot(action, tab) {
+    return this._buildTabSnapshotObject(action, tab);
+  }
+  _buildTabSnapshotObject(action, tab) {
+    return {
+      url: tab.page.url(),
+      title: "",
+      ariaSnapshot: action.ariaSnapshot ?? "",
+      modalStates: [],
+      consoleMessages: [],
+      downloads: []
+    };
+  }
+  _appendEntry(entry) {
+    this._pendingEntries.push(entry);
+    if (this._flushEntriesTimeout) {
+      clearTimeout(this._flushEntriesTimeout);
+    }
+    this._flushEntriesTimeout = setTimeout(() => this._flushEntries(), 1000);
+  }
+  _flushEntries() {
+    this._executeFlushProcess();
+  }
+  _executeFlushProcess() {
+    this._clearFlushTimeout();
+    const { entries, lines } = this._prepareFlushData();
+    this._processEntries(entries, lines);
+    this._writeToFile(lines);
+  }
+  _clearFlushTimeout() {
+    if (this._flushEntriesTimeout) {
+      clearTimeout(this._flushEntriesTimeout);
+    }
+  }
+  _prepareFlushData() {
+    const entries = this._pendingEntries;
+    this._pendingEntries = [];
+    const lines = [""];
+    return { entries, lines };
+  }
+  _processEntries(entries, lines) {
+    for (const entry of entries) {
+      this._ordinal++;
+      const ordinal = this._ordinal.toString().padStart(3, "0");
+      this._formatSingleLogEntry(entry, ordinal, lines);
+    }
+  }
+  _writeToFile(lines) {
+    this._sessionFileQueue = this._sessionFileQueue.then(() => fs.promises.appendFile(this._file, lines.join(`
+`)));
+  }
+  _formatSingleLogEntry(entry, ordinal, lines) {
+    this._addAllEntryContent(entry, ordinal, lines);
+    this._addEntryDelimiters(lines);
+  }
+  _addAllEntryContent(entry, ordinal, lines) {
+    this._addToolCallContent(entry, lines);
+    this._addUserActionContent(entry, lines);
+    this._addCodeContent(entry, lines);
+    this._addTabSnapshotContent(entry, ordinal, lines);
+  }
+  _addEntryDelimiters(lines) {
+    lines.push("", "");
+  }
+  _addToolCallContent(entry, lines) {
+    if (!entry.toolCall) {
+      return;
+    }
+    this._addToolCallLines(entry.toolCall, lines);
+  }
+  _addUserActionContent(entry, lines) {
+    if (!entry.userAction) {
+      return;
+    }
+    this._addUserActionLines(entry.userAction, lines);
+  }
+  _addCodeContent(entry, lines) {
+    if (!entry.code) {
+      return;
+    }
+    lines.push("- Code", "```js", entry.code, "```");
+  }
+  _addTabSnapshotContent(entry, ordinal, lines) {
+    if (!entry.tabSnapshot) {
+      return;
+    }
+    this._addTabSnapshotLines(entry.tabSnapshot, ordinal, lines);
+  }
+  _addToolCallLines(toolCall, lines) {
+    this._addToolCallHeader(toolCall, lines);
+    this._addToolCallResult(toolCall, lines);
+  }
+  _addToolCallHeader(toolCall, lines) {
+    lines.push(`### Tool call: ${toolCall.toolName}`, "- Args", "```json", JSON.stringify(toolCall.toolArgs, null, 2), "```");
+  }
+  _addToolCallResult(toolCall, lines) {
+    if (!toolCall.result) {
+      return;
+    }
+    lines.push(toolCall.isError ? "- Error" : "- Result", "```", toolCall.result, "```");
+  }
+  _addUserActionLines(userAction, lines) {
+    const actionData = { ...userAction };
+    actionData.ariaSnapshot = undefined;
+    actionData.selector = undefined;
+    actionData.signals = undefined;
+    lines.push(`### User action: ${userAction.name}`, "- Args", "```json", JSON.stringify(actionData, null, 2), "```");
+  }
+  _addTabSnapshotLines(tabSnapshot, ordinal, lines) {
+    const fileName = `${ordinal}.snapshot.yml`;
+    fs.promises.writeFile(path.join(this._folder, fileName), tabSnapshot.ariaSnapshot).catch(logUnhandledError);
+    lines.push(`- Snapshot: ${fileName}`);
+  }
+}
+export {
+  SessionLog
+};