@skyramp/mcp 0.0.65 → 0.1.0-rc.2

package/node_modules/playwright/lib/mcp/skyramp/traceRecordingBackend.js

@@ -46,9 +46,17 @@ var import_assertTool = require("./assertTool");
 var import_types = require("./types");
 const traceDebug = (0, import_utilsBundle.debug)("pw:mcp:trace");
 class TraceRecordingBackend {
+  // true while page.reload() is in progress — suppresses spurious popup tracking
   constructor(options) {
     this._trackedActions = [];
     this._initialized = false;
+    this._pageCount = 0;
+    // number of popup pages seen
+    this._currentPageAlias = "page";
+    // alias of the currently active page
+    this._pendingPopupAlias = null;
+    // popup alias to stamp on the NEXT tracked click
+    this._reloading = false;
     this._options = options || {};
     this._outputDir = options?.outputDir || process.cwd();
     this._tempDir = import_fs.default.mkdtempSync(import_path.default.join(import_os.default.tmpdir(), "skyramp-trace-"));
@@ -72,6 +80,8 @@ class TraceRecordingBackend {
       },
       capabilities: ["testing"],
       outputDir: this._tempDir,
+      snapshot: { mode: "full" },
+      // Always return full snapshots — incremental diffs cause empty snapshots after clicks
       timeouts: {
         action: 15e3,
         // 15s — modals and dynamic content need more time
@@ -83,6 +93,7 @@ class TraceRecordingBackend {
     await this._browserBackend.initialize(clientInfo);
     this._initialized = true;
     traceDebug("TraceRecordingBackend initialized");
+    this._setupPopupTracking();
   }
   async listTools() {
     const browserTools = await this._browserBackend.listTools();
@@ -99,7 +110,6 @@ class TraceRecordingBackend {
       }
       const handler = (0, import_exportTool.createExportZipHandler)({
         trackedActions: this._trackedActions,
-        rootPath: this._outputDir,
         harPath: this._harPath
       });
       const exportResult = await handler(parsed);
@@ -115,8 +125,60 @@ class TraceRecordingBackend {
       const result2 = await this._handleSelectOption(args || {});
       return result2;
     }
+    if (name === "browser_tabs" && ["select", "switch"].includes(args?.action)) {
+      const index = args?.index ?? 0;
+      this._currentPageAlias = index === 0 ? "page" : `page${index}`;
+      traceDebug(`Tab switched to index ${index} \u2192 pageAlias: ${this._currentPageAlias}`);
+      const tabResult = await this._browserBackend.callTool(name, args);
+      return tabResult;
+    }
+    if (name === "browser_navigate") {
+      const targetUrl = args?.url;
+      const currentUrl = this._browserBackend.context?.currentTab()?.page.url();
+      if (targetUrl && currentUrl && this._normalizeUrl(targetUrl) === this._normalizeUrl(currentUrl)) {
+        traceDebug(`Navigate to same URL detected (${targetUrl}), converting to reload`);
+        const ts = Date.now();
+        const reloadAlias = this._currentPageAlias;
+        const tab = this._browserBackend.context.currentTab();
+        this._reloading = true;
+        try {
+          await tab.page.reload({ waitUntil: "domcontentloaded" });
+        } finally {
+          this._reloading = false;
+          this._currentPageAlias = reloadAlias;
+          this._pendingPopupAlias = null;
+        }
+        this._trackedActions.push({
+          toolName: "browser_navigate",
+          args: { url: currentUrl },
+          code: "",
+          timestamp: ts,
+          pageAlias: this._currentPageAlias
+        });
+        const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
+        return {
+          content: [
+            { type: "text", text: `### Navigation (reload)
+Reloaded current page: ${currentUrl}
+` },
+            ...snapResult.content || []
+          ]
+        };
+      }
+    }
     const timestampBeforeAction = Date.now();
-    const result = await this._browserBackend.callTool(name, args);
+    const pageAliasBeforeAction = this._currentPageAlias;
+    let preClickHoverCode = null;
+    if (name === "browser_click" && args?.ref) {
+      const hoverResult = await this._browserBackend.callTool("browser_hover", {
+        element: args.element || "element",
+        ref: args.ref
+      });
+      if (!hoverResult.isError)
+        preClickHoverCode = (0, import_response.parseResponse)(hoverResult)?.code ?? null;
+    }
+    let result = await this._browserBackend.callTool(name, args);
+    result = await this._improveActionSelector(name, args || {}, result, preClickHoverCode);
     if (name === "browser_fill_form" && result.isError) {
       const resultText = result.content?.[0]?.type === "text" ? result.content[0].text : "";
       if (resultText.includes("not a <select> element") || resultText.includes("selectOption") && resultText.includes("Timeout")) {
@@ -125,7 +187,7 @@ class TraceRecordingBackend {
           const comboField = fields.find((f) => f.type === "combobox");
           if (comboField) {
             traceDebug("fill_form failed on combobox field, retrying with select fallback");
-            this._maybeTrackAction(name, args || {}, { content: result.content, isError: false }, timestampBeforeAction);
+            this._maybeTrackAction(name, args || {}, { content: result.content, isError: false }, timestampBeforeAction, pageAliasBeforeAction);
             const selectResult = await this._handleSelectOption({
               element: comboField.name || "dropdown",
               ref: comboField.ref,
@@ -136,7 +198,7 @@ class TraceRecordingBackend {
         }
       }
     }
-    this._maybeTrackAction(name, args || {}, result, timestampBeforeAction);
+    this._maybeTrackAction(name, args || {}, result, timestampBeforeAction, pageAliasBeforeAction);
     return result;
   }
   serverClosed() {
@@ -471,7 +533,227 @@ ${details}` }]
     }
     return null;
   }
-  _maybeTrackAction(toolName, args, result, timestamp) {
+  /**
+   * Improve ambiguous selectors in action code before tracking.
+   * Handles role-based selectors like getByRole("combobox") that match multiple elements.
+   * Also upgrades raw CSS locators (locator('.class')) to semantic selectors.
+   * preClickHoverCode: hover result taken BEFORE the click (needed for navigation clicks
+   * where the element ref is no longer valid after navigation).
+   */
+  async _improveActionSelector(toolName, args, result, preClickHoverCode = null) {
+    if (result.isError)
+      return result;
+    const selectorTools = /* @__PURE__ */ new Set(["browser_click", "browser_hover", "browser_type", "browser_fill"]);
+    if (!selectorTools.has(toolName))
+      return result;
+    const parsed = (0, import_response.parseResponse)(result);
+    const code = parsed?.code ?? "";
+    if (!code)
+      return result;
+    const cssLocatorMatch = code.match(/await\s+page\.locator\(\s*(['"])[.#][^'"]+\1\s*\)\./);
+    if (cssLocatorMatch) {
+      const actionMatch = code.match(/\.(click|fill|hover|dblclick|check|uncheck)\s*\(/);
+      const action = actionMatch?.[1] ?? "click";
+      if (preClickHoverCode) {
+        const locatorMatch = preClickHoverCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+        if (locatorMatch) {
+          const locatorExpr = locatorMatch[1].trim();
+          if (!locatorExpr.startsWith("locator(")) {
+            const improvedCode = `await page.${locatorExpr}.${action}();`;
+            traceDebug(`Improved CSS locator via pre-hover: ${locatorExpr}`);
+            return this._modifyResultCode(result, improvedCode);
+          }
+        }
+      }
+      const ref2 = args.ref;
+      const snapText2 = parsed?.snapshot ?? "";
+      if (ref2 && snapText2) {
+        const refLine2 = snapText2.split("\n").find((l) => l.includes(`[ref=${ref2}]`)) || "";
+        if (refLine2) {
+          const locatorData = this._extractLocatorForRef(refLine2);
+          if (locatorData) {
+            const locatorCode = this._locatorToCode(locatorData);
+            if (locatorCode) {
+              const improvedCode = `await page.${locatorCode}.${action}();`;
+              traceDebug(`Improved CSS locator from snapshot: ${locatorCode}`);
+              return this._modifyResultCode(result, improvedCode);
+            }
+          }
+        }
+      }
+      return result;
+    }
+    const roleMatch = code.match(/getByRole\(\s*['"](\w+)['"]\s*\)(?!\s*\.(?:filter|nth|first|last))/);
+    if (!roleMatch)
+      return result;
+    const role = roleMatch[1];
+    const ref = args.ref;
+    if (!ref)
+      return result;
+    const snapText = parsed?.snapshot ?? "";
+    if (!snapText)
+      return result;
+    const snapLines = snapText.split("\n");
+    const rolePattern = new RegExp(`^\\s*-\\s*${role}\\s+`, "m");
+    const roleCount = snapLines.filter((l) => rolePattern.test(l)).length;
+    if (roleCount <= 1) {
+      traceDebug(`Role "${role}" is unique, no improvement needed`);
+      return result;
+    }
+    traceDebug(`Role "${role}" appears ${roleCount} times \u2014 attempting to disambiguate`);
+    const refPattern = `[ref=${ref}]`;
+    const refIdx = snapLines.findIndex((l) => l.includes(refPattern));
+    if (refIdx < 0)
+      return result;
+    const refLine = snapLines[refIdx];
+    const textMatch = refLine.match(/^\s*-\s*\w+\s+"([^"]*)"/);
+    if (textMatch && textMatch[1]) {
+      const visibleText = textMatch[1];
+      const textPattern = new RegExp(`^\\s*-\\s*${role}\\s+"[^"]*${visibleText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i");
+      const textCount = snapLines.filter((l) => textPattern.test(l)).length;
+      if (textCount === 1) {
+        const improvedCode = code.replace(
+          /getByRole\((\s*['"](\w+)['"]\s*)\)/,
+          `getByRole($1).filter({ hasText: "${visibleText}" })`
+        );
+        traceDebug(`Improved selector with text filter: ${visibleText}`);
+        return this._modifyResultCode(result, improvedCode);
+      }
+    }
+    const refIndent = refLine.match(/^(\s*)/)?.[1]?.length ?? 0;
+    for (let i = refIdx - 1; i >= 0; i--) {
+      const line = snapLines[i];
+      const indent = line.match(/^(\s*)/)?.[1]?.length ?? 0;
+      if (indent >= refIndent)
+        continue;
+      const ancestorRefMatch = line.match(/\[ref=(\w+)\]/);
+      if (!ancestorRefMatch)
+        continue;
+      const ancestorRef = ancestorRefMatch[1];
+      try {
+        const ancestorHover = await this._browserBackend.callTool("browser_hover", {
+          element: "parent element",
+          ref: ancestorRef
+        });
+        if (!ancestorHover.isError) {
+          const ancestorCode = (0, import_response.parseResponse)(ancestorHover)?.code ?? "";
+          const testidMatch = ancestorCode.match(/getByTestId\(\s*['"]([^'"]+)['"]\s*\)/);
+          if (testidMatch) {
+            const testid = testidMatch[1];
+            const improvedCode = code.replace(
+              /await\s+page\./,
+              `await page.getByTestId("${testid}").`
+            );
+            traceDebug(`Improved selector by chaining from test-id: ${testid}`);
+            return this._modifyResultCode(result, improvedCode);
+          }
+        }
+      } catch {
+      }
+      if (indent === 0)
+        break;
+    }
+    const roleRefs = [];
+    for (const line of snapLines) {
+      if (rolePattern.test(line)) {
+        const m = line.match(/\[ref=(\w+)\]/);
+        if (m)
+          roleRefs.push(m[1]);
+      }
+    }
+    const index = roleRefs.indexOf(ref);
+    if (index >= 0) {
+      const improvedCode = code.replace(
+        /getByRole\((\s*['"](\w+)['"]\s*)\)/,
+        `getByRole($1).nth(${index})`
+      );
+      traceDebug(`Improved selector with .nth(${index})`);
+      return this._modifyResultCode(result, improvedCode);
+    }
+    return result;
+  }
+  /** Helper to modify the code in a CallToolResult. */
+  _modifyResultCode(result, newCode) {
+    const modified = { ...result, content: [...result.content] };
+    for (let i = 0; i < modified.content.length; i++) {
+      if (modified.content[i].type === "text") {
+        const text = modified.content[i].text || "";
+        if (text.includes("```javascript") || text.includes("await page.")) {
+          const codeBlockMatch = text.match(/([\s\S]*```javascript\n)([\s\S]*?)(```[\s\S]*)/);
+          if (codeBlockMatch) {
+            modified.content[i] = {
+              ...modified.content[i],
+              text: codeBlockMatch[1] + newCode + "\n" + codeBlockMatch[3]
+            };
+          } else {
+            const lines = text.split("\n");
+            const codeLineIdx = lines.findIndex((l) => l.includes("await page."));
+            if (codeLineIdx >= 0) {
+              lines[codeLineIdx] = newCode;
+              modified.content[i] = {
+                ...modified.content[i],
+                text: lines.join("\n")
+              };
+            }
+          }
+        }
+      }
+    }
+    return modified;
+  }
+  /** Convert a locator object to a Playwright code expression like getByRole('link', { name: 'X' }). */
+  _locatorToCode(parsed) {
+    const { locator } = parsed;
+    switch (locator.kind) {
+      case "test-id":
+        return `getByTestId('${locator.body}')`;
+      case "role": {
+        const name = locator.options?.name;
+        const exact = locator.options?.exact;
+        const opts = name ? `, { name: '${name}'${exact ? ", exact: true" : ""} }` : "";
+        return `getByRole('${locator.body}'${opts})`;
+      }
+      case "label":
+        return `getByLabel('${locator.body}')`;
+      case "text":
+        return `getByText('${locator.body}')`;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Listen for new pages (popups) on the browser context.
+   * When a popup opens, find the most recent click that triggered it and mark it
+   * with a popupAlias signal. Switch the current page alias to the new page.
+   */
+  _setupPopupTracking() {
+    void (async () => {
+      try {
+        const context = this._browserBackend.context;
+        if (!context)
+          return;
+        const browserContext = await context.ensureBrowserContext();
+        let initialPageSeen = false;
+        browserContext.on("page", () => {
+          if (!initialPageSeen) {
+            initialPageSeen = true;
+            return;
+          }
+          if (this._reloading) {
+            traceDebug("Ignoring spurious popup opened during reload");
+            return;
+          }
+          this._pageCount++;
+          const popupAlias = `page${this._pageCount}`;
+          this._currentPageAlias = popupAlias;
+          this._pendingPopupAlias = popupAlias;
+          traceDebug(`Popup page opened: ${popupAlias} (pending stamp)`);
+        });
+      } catch {
+      }
+    })();
+  }
+  _maybeTrackAction(toolName, args, result, timestamp, pageAliasBeforeAction) {
     if (result.isError)
       return;
     if (toolName === "browser_press_key") {
@@ -482,13 +764,28 @@ ${details}` }]
     const parsed = (0, import_response.parseResponse)(result);
     const code = parsed?.code ?? "";
     if (code || import_types.ARGS_ONLY_TOOLS.has(toolName)) {
+      const popupAlias = this._pendingPopupAlias ?? void 0;
+      this._pendingPopupAlias = null;
+      const pageAlias = popupAlias ? pageAliasBeforeAction ?? this._currentPageAlias : this._currentPageAlias;
       this._trackedActions.push({
         toolName,
         args,
         code,
-        timestamp: timestamp ?? Date.now()
+        timestamp: timestamp ?? Date.now(),
+        pageAlias,
+        popupAlias
       });
-      traceDebug(`Tracked action: ${toolName} (total: ${this._trackedActions.length})`);
+      traceDebug(`Tracked action: ${toolName} on ${pageAlias}${popupAlias ? ` \u2192 popup:${popupAlias}` : ""} (total: ${this._trackedActions.length})`);
+    }
+  }
+  /** Normalize a URL for comparison: strip trailing slash and fragment. */
+  _normalizeUrl(url) {
+    try {
+      const u = new URL(url);
+      u.hash = "";
+      return u.toString().replace(/\/$/, "");
+    } catch {
+      return url.replace(/\/$/, "");
     }
   }
   async _autoExportAndClose() {

package/node_modules/playwright/lib/mcp/test/skyRampExport.js

@@ -38,8 +38,8 @@ var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_zipBundle = require("playwright-core/lib/zipBundle");
 var import_utils = require("playwright-core/lib/utils");
-const PAGE_ALIAS = "page";
-const FRAME_PATH = [];
+const DEFAULT_PAGE_ALIAS = "page";
+const DEFAULT_FRAME_PATH = [];
 function jsonlHeader(browserName, harPath) {
   return JSON.stringify({
     browserName,
@@ -53,10 +53,18 @@ function jsonlHeader(browserName, harPath) {
   });
 }
 function extractLocatorFromCode(code) {
+  const contentFrameMatch = code.match(/await\s+page\.locator\((['"])(iframe[^\n]*?)\1\)(?:\.contentFrame\(\))+\.(.*?)\.(click|dblclick|fill|pressSequentially|check|uncheck|selectOption|hover|dragTo)\s*\(/s);
+  if (contentFrameMatch) {
+    return { locatorExpr: contentFrameMatch[3].trim(), framePath: [contentFrameMatch[2]] };
+  }
+  const chainedIframeMatch = code.match(/await\s+page\.locator\((['"])(iframe[^\n]*?)\1\)\.(get\w+\(.*?)\.(click|dblclick|fill|pressSequentially|check|uncheck|selectOption|hover|dragTo)\s*\(/s);
+  if (chainedIframeMatch) {
+    return { locatorExpr: chainedIframeMatch[3].trim(), framePath: [chainedIframeMatch[2]] };
+  }
   const match = code.match(/await\s+page\.(.*?)\.(click|dblclick|fill|pressSequentially|check|uncheck|selectOption|hover|dragTo)\s*\(/s);
   if (!match)
     return void 0;
-  return match[1].trim();
+  return { locatorExpr: match[1].trim(), framePath: [] };
 }
 function locatorToJsonl(locatorExpr) {
   const chainParts = locatorExpr.split(/\)\.(?=get)/);
@@ -169,25 +177,39 @@ function extractSelectOptions(code) {
 }
 function trackedActionToJsonl(action, pageGuid, timestamp) {
   const { toolName, args, code } = action;
+  const pageAlias = action.pageAlias ?? DEFAULT_PAGE_ALIAS;
+  const signals = action.popupAlias ? [{ name: "popup", popupAlias: action.popupAlias }] : [];
   const base = {
-    signals: [],
+    signals,
     timestamp: String(timestamp),
     pageGuid,
-    pageAlias: PAGE_ALIAS,
-    framePath: FRAME_PATH
+    pageAlias,
+    framePath: action.framePath ?? DEFAULT_FRAME_PATH
   };
   if (toolName === "browser_navigate")
     return JSON.stringify({ name: "navigate", url: args.url, ...base });
   if (toolName === "browser_navigate_back")
     return null;
+  if (toolName === "browser_wait_for") {
+    const text = args.text;
+    const textGone = args.textGone;
+    if (text)
+      return JSON.stringify({ name: "waitForSelector", selector: `text=${text}`, ...base });
+    if (textGone)
+      return JSON.stringify({ name: "waitForSelector", selector: `text=${textGone}`, state: "hidden", ...base });
+    return null;
+  }
   if (toolName === "browser_press_key")
     return JSON.stringify({ name: "press", key: args.key, selector: "", ...base });
   if (!code)
     return null;
-  const locatorStr = extractLocatorFromCode(code);
-  if (!locatorStr)
+  const extracted = extractLocatorFromCode(code);
+  if (!extracted)
     return null;
-  const parsed = locatorToJsonl(locatorStr);
+  const { locatorExpr, framePath: codeFramePath } = extracted;
+  if (codeFramePath.length > 0)
+    base.framePath = codeFramePath;
+  const parsed = locatorToJsonl(locatorExpr);
   if (!parsed)
     return null;
   const { selector, locator: locatorObj } = parsed;
@@ -236,8 +258,8 @@ function assertActionToJsonl(action, pageGuid, timestamp) {
     signals: [],
     timestamp: String(timestamp),
     pageGuid,
-    pageAlias: PAGE_ALIAS,
-    framePath: FRAME_PATH
+    pageAlias: DEFAULT_PAGE_ALIAS,
+    framePath: DEFAULT_FRAME_PATH
   };
   const parts = code.split(":");
   const selectorPart = parts[1] || "";
@@ -298,11 +320,27 @@ function fillFormToJsonl(action, pageGuid, baseTimestamp) {
       signals: [],
       timestamp: String(baseTimestamp + i),
       pageGuid,
-      pageAlias: PAGE_ALIAS,
-      framePath: FRAME_PATH
+      pageAlias: DEFAULT_PAGE_ALIAS,
+      framePath: DEFAULT_FRAME_PATH
     });
   });
 }
+function removeRedundantClicks(actions) {
+  return actions.filter((action, i) => {
+    if (action.toolName !== "browser_click")
+      return true;
+    const next = actions[i + 1];
+    if (!next || !["browser_type", "browser_fill"].includes(next.toolName))
+      return true;
+    const clickRef = action.args?.ref;
+    const fillRef = next.args?.ref;
+    if (!clickRef || !fillRef || clickRef !== fillRef)
+      return true;
+    if (next.args?.slowly || next.code.includes(".pressSequentially("))
+      return true;
+    return false;
+  });
+}
 function deduplicateRetries(actions) {
   const firstNavigate = actions.find((a) => a.toolName === "browser_navigate");
   if (!firstNavigate)
@@ -316,16 +354,52 @@ function deduplicateRetries(actions) {
   return lastRestartIdx > 0 ? actions.slice(lastRestartIdx) : actions;
 }
 function buildJsonlContent(actions, browserName, harPath) {
-  const deduplicated = deduplicateRetries(actions);
-  const pageGuid = `page@${import_crypto.default.randomBytes(16).toString("hex")}`;
+  const deduplicated = removeRedundantClicks(deduplicateRetries(actions));
   const startTime = deduplicated[0]?.timestamp ?? Date.now();
+  const pageGuids = /* @__PURE__ */ new Map();
+  const getPageGuid = (alias) => {
+    if (!pageGuids.has(alias))
+      pageGuids.set(alias, `page@${import_crypto.default.randomBytes(16).toString("hex")}`);
+    return pageGuids.get(alias);
+  };
+  const mainGuid = getPageGuid(DEFAULT_PAGE_ALIAS);
   const lines = [
     jsonlHeader(browserName, harPath),
-    JSON.stringify({ name: "openPage", url: "about:blank", signals: [], timestamp: String(startTime - 1e3), pageGuid, pageAlias: PAGE_ALIAS, framePath: FRAME_PATH })
+    JSON.stringify({ name: "openPage", url: "about:blank", signals: [], timestamp: String(startTime - 1e3), pageGuid: mainGuid, pageAlias: DEFAULT_PAGE_ALIAS, framePath: DEFAULT_FRAME_PATH })
   ];
   let actionCount = 0;
   const skipped = [];
+  const openedAliases = /* @__PURE__ */ new Set([DEFAULT_PAGE_ALIAS]);
+  let hadPopupFills = false;
   for (const action of deduplicated) {
+    const alias = action.pageAlias ?? DEFAULT_PAGE_ALIAS;
+    const pageGuid = getPageGuid(alias);
+    if (action.popupAlias && !openedAliases.has(action.popupAlias)) {
+      const popupGuid = getPageGuid(action.popupAlias);
+      lines.push(JSON.stringify({ name: "openPage", url: "about:blank", signals: [], timestamp: String(action.timestamp), pageGuid: popupGuid, pageAlias: action.popupAlias, framePath: DEFAULT_FRAME_PATH }));
+      openedAliases.add(action.popupAlias);
+    }
+    if (alias !== DEFAULT_PAGE_ALIAS && !openedAliases.has(alias)) {
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const obj = JSON.parse(lines[i]);
+          if (obj.name === "openPage" || obj.name === "closePage")
+            continue;
+          if (!obj.pageAlias || obj.pageAlias !== alias) {
+            obj.signals = [...obj.signals || [], { name: "popup", popupAlias: alias }];
+            lines[i] = JSON.stringify(obj);
+            break;
+          }
+        } catch {
+          break;
+        }
+      }
+      const popupGuid = getPageGuid(alias);
+      lines.push(JSON.stringify({ name: "openPage", url: "about:blank", signals: [], timestamp: String(action.timestamp), pageGuid: popupGuid, pageAlias: alias, framePath: DEFAULT_FRAME_PATH }));
+      openedAliases.add(alias);
+    }
+    if ((action.toolName === "browser_type" || action.toolName === "browser_fill") && alias !== DEFAULT_PAGE_ALIAS)
+      hadPopupFills = true;
     if (action.toolName === "browser_fill_form") {
       const formLines = fillFormToJsonl(action, pageGuid, action.timestamp);
       lines.push(...formLines);
@@ -340,6 +414,11 @@ function buildJsonlContent(actions, browserName, harPath) {
       }
       continue;
     }
+    if (action.toolName === "browser_navigate" && alias === DEFAULT_PAGE_ALIAS && hadPopupFills) {
+      lines.push(JSON.stringify({ name: "waitForTimeout", duration: 3e4, signals: [], timestamp: String(action.timestamp - 1), pageGuid, pageAlias: alias, framePath: DEFAULT_FRAME_PATH }));
+      actionCount++;
+      hadPopupFills = false;
+    }
     const line = trackedActionToJsonl(action, pageGuid, action.timestamp);
     if (line) {
       lines.push(line);
@@ -348,18 +427,47 @@ function buildJsonlContent(actions, browserName, harPath) {
       skipped.push(action.toolName);
     }
   }
-  lines.push(JSON.stringify({ name: "closePage", signals: [], timestamp: String(Date.now()), pageGuid, pageAlias: PAGE_ALIAS, framePath: FRAME_PATH }));
+  lines.push(JSON.stringify({ name: "closePage", signals: [], timestamp: String(Date.now()), pageGuid: mainGuid, pageAlias: DEFAULT_PAGE_ALIAS, framePath: DEFAULT_FRAME_PATH }));
   return { jsonl: lines.join("\n") + "\n", actionCount, skipped };
 }
+const CROSS_PAGE_URL_BLOCKLIST = [
+  "/app_init",
+  "notes.services.box.com"
+];
+function filterHarEntries(harContent) {
+  try {
+    const har = JSON.parse(harContent);
+    const entries = har?.log?.entries ?? [];
+    har.log.entries = entries.filter((entry) => {
+      const url = entry?.request?.url ?? "";
+      if (CROSS_PAGE_URL_BLOCKLIST.some((pattern) => url.includes(pattern)))
+        return false;
+      const text = entry?.response?.content?.text;
+      if (!text || text.trim() === "")
+        return false;
+      try {
+        JSON.parse(text);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    return JSON.stringify(har);
+  } catch {
+    return harContent;
+  }
+}
 async function writeSkyrampZip(outputZipPath, jsonlContent, harPath) {
   const zipFile = new import_zipBundle.yazl.ZipFile();
   const done = new import_utils.ManualPromise();
   zipFile.on("error", (e) => done.reject(e));
   zipFile.addBuffer(Buffer.from(jsonlContent, "utf-8"), "skyramp_playwright.txt");
-  if (await import_fs.default.promises.stat(harPath).then(() => true).catch(() => false))
-    zipFile.addFile(harPath, "skyramp_network.har");
-  else
+  if (await import_fs.default.promises.stat(harPath).then(() => true).catch(() => false)) {
+    const rawHar = await import_fs.default.promises.readFile(harPath, "utf-8");
+    zipFile.addBuffer(Buffer.from(filterHarEntries(rawHar), "utf-8"), "skyramp_network.har");
+  } else {
     zipFile.addBuffer(Buffer.from('{"log":{"version":"1.2","creator":{"name":"Playwright","version":"1.0"},"entries":[]}}', "utf-8"), "skyramp_network.har");
+  }
   zipFile.end();
   await import_fs.default.promises.mkdir(import_path.default.dirname(outputZipPath), { recursive: true });
   zipFile.outputStream.pipe(import_fs.default.createWriteStream(outputZipPath)).on("close", () => done.resolve()).on("error", (e) => done.reject(e));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.65",
+  "version": "0.1.0-rc.2",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -54,7 +54,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.18",
+    "@skyramp/skyramp": "1.3.19",
     "dockerode": "^4.0.6",
     "fast-glob": "^3.3.3",
     "playwright": "file:vendor/skyramp-playwright-1.58.2-skyramp.8.9.0.tgz",

package/node_modules/playwright/lib/mcp/terminal/help.json

@@ -1,32 +0,0 @@
-{
-  "global": "Usage: playwright-cli <command> [options]\nCommands:\n  click <ref>                             perform click on a web page\n  close                                   close the page\n  dblclick <ref>                          perform double click on a web page\n  console <level>                         returns all console messages\n  drag <startRef> <endRef>                perform drag and drop between two elements\n  evaluate <function> <ref>               evaluate javascript expression on page or element\n  upload-file                             upload one or multiple files\n  handle-dialog <accept> <promptText>     handle a dialog\n  hover <ref>                             hover over element on page\n  open <url>                              open url\n  go-back                                 go back to the previous page\n  network-requests                        returns all network requests since loading the page\n  press <key>                             press a key on the keyboard\n  resize <width> <height>                 resize the browser window\n  run-code <code>                         run playwright code snippet\n  select-option <ref> <values>            select an option in a dropdown\n  snapshot                                capture accessibility snapshot of the current page, this is better than screenshot\n  screenshot <ref>                        take a screenshot of the current page. you can't perform actions based on the screenshot, use browser_snapshot for actions.\n  type <text>                             type text into editable element\n  wait-for                                wait for text to appear or disappear or a specified time to pass\n  tab <action> <index>                    close a browser tab\n  mouse-click-xy <x> <y>                  click left mouse button at a given position\n  mouse-drag-xy <startX> <startY> <endX> <endY> drag left mouse button to a given position\n  mouse-move-xy <x> <y>                   move mouse to a given position\n  pdf-save                                save page as pdf\n  start-tracing                           start trace recording\n  stop-tracing                            stop trace recording",
-  "commands": {
-    "click": "playwright-cli click <ref>\n\nPerform click on a web page\n\nArguments:\n  <ref>\tExact target element reference from the page snapshot\nOptions:\n  --button\tbutton to click, defaults to left\n  --modifiers\tmodifier keys to press",
-    "close": "playwright-cli close \n\nClose the page\n",
-    "dblclick": "playwright-cli dblclick <ref>\n\nPerform double click on a web page\n\nArguments:\n  <ref>\tExact target element reference from the page snapshot\nOptions:\n  --button\tbutton to click, defaults to left\n  --modifiers\tmodifier keys to press",
-    "console": "playwright-cli console <level>\n\nReturns all console messages\n\nArguments:\n  <level>\tLevel of the console messages to return. Each level includes the messages of more severe levels. Defaults to \"info\".",
-    "drag": "playwright-cli drag <startRef> <endRef>\n\nPerform drag and drop between two elements\n\nArguments:\n  <startRef>\tExact source element reference from the page snapshot\n  <endRef>\tExact target element reference from the page snapshot\nOptions:\n  --headed\trun browser in headed mode",
-    "evaluate": "playwright-cli evaluate <function> <ref>\n\nEvaluate JavaScript expression on page or element\n\nArguments:\n  <function>\t() => { /* code */ } or (element) => { /* code */ } when element is provided\n  <ref>\tExact target element reference from the page snapshot",
-    "upload-file": "playwright-cli upload-file \n\nUpload one or multiple files\n\nOptions:\n  --paths\tthe absolute paths to the files to upload. can be single file or multiple files. if omitted, file chooser is cancelled.",
-    "handle-dialog": "playwright-cli handle-dialog <accept> <promptText>\n\nHandle a dialog\n\nArguments:\n  <accept>\tWhether to accept the dialog.\n  <promptText>\tThe text of the prompt in case of a prompt dialog.",
-    "hover": "playwright-cli hover <ref>\n\nHover over element on page\n\nArguments:\n  <ref>\tExact target element reference from the page snapshot",
-    "open": "playwright-cli open <url>\n\nOpen URL\n\nArguments:\n  <url>\tThe URL to navigate to\nOptions:\n  --headed\trun browser in headed mode",
-    "go-back": "playwright-cli go-back \n\nGo back to the previous page\n",
-    "network-requests": "playwright-cli network-requests \n\nReturns all network requests since loading the page\n\nOptions:\n  --includeStatic\twhether to include successful static resources like images, fonts, scripts, etc. defaults to false.",
-    "press": "playwright-cli press <key>\n\nPress a key on the keyboard\n\nArguments:\n  <key>\tName of the key to press or a character to generate, such as `ArrowLeft` or `a`",
-    "resize": "playwright-cli resize <width> <height>\n\nResize the browser window\n\nArguments:\n  <width>\tWidth of the browser window\n  <height>\tHeight of the browser window",
-    "run-code": "playwright-cli run-code <code>\n\nRun Playwright code snippet\n\nArguments:\n  <code>\tA JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction.",
-    "select-option": "playwright-cli select-option <ref> <values>\n\nSelect an option in a dropdown\n\nArguments:\n  <ref>\tExact target element reference from the page snapshot\n  <values>\tArray of values to select in the dropdown. This can be a single value or multiple values.",
-    "snapshot": "playwright-cli snapshot \n\nCapture accessibility snapshot of the current page, this is better than screenshot\n\nOptions:\n  --filename\tsave snapshot to markdown file instead of returning it in the response.",
-    "screenshot": "playwright-cli screenshot <ref>\n\nTake a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.\n\nArguments:\n  <ref>\tExact target element reference from the page snapshot.\nOptions:\n  --filename\tfile name to save the screenshot to. defaults to `page-{timestamp}.{png|jpeg}` if not specified.\n  --fullPage\twhen true, takes a screenshot of the full scrollable page, instead of the currently visible viewport.",
-    "type": "playwright-cli type <text>\n\nType text into editable element\n\nArguments:\n  <text>\tText to type into the element\nOptions:\n  --submit\twhether to submit entered text (press enter after)",
-    "wait-for": "playwright-cli wait-for \n\nWait for text to appear or disappear or a specified time to pass\n\nOptions:\n  --time\tthe time to wait in seconds\n  --text\tthe text to wait for\n  --textGone\tthe text to wait for to disappear",
-    "tab": "playwright-cli tab <action> <index>\n\nClose a browser tab\n\nArguments:\n  <action>\tAction to perform on tabs, 'list' | 'new' | 'close' | 'select'\n  <index>\tTab index. If omitted, current tab is closed.",
-    "mouse-click-xy": "playwright-cli mouse-click-xy <x> <y>\n\nClick left mouse button at a given position\n\nArguments:\n  <x>\tX coordinate\n  <y>\tY coordinate",
-    "mouse-drag-xy": "playwright-cli mouse-drag-xy <startX> <startY> <endX> <endY>\n\nDrag left mouse button to a given position\n\nArguments:\n  <startX>\tStart X coordinate\n  <startY>\tStart Y coordinate\n  <endX>\tEnd X coordinate\n  <endY>\tEnd Y coordinate",
-    "mouse-move-xy": "playwright-cli mouse-move-xy <x> <y>\n\nMove mouse to a given position\n\nArguments:\n  <x>\tX coordinate\n  <y>\tY coordinate",
-    "pdf-save": "playwright-cli pdf-save \n\nSave page as PDF\n\nOptions:\n  --filename\tfile name to save the pdf to. defaults to `page-{timestamp}.pdf` if not specified.",
-    "start-tracing": "playwright-cli start-tracing \n\nStart trace recording\n",
-    "stop-tracing": "playwright-cli stop-tracing \n\nStop trace recording\n"
-  }
-}