@skyramp/mcp 0.0.65 → 0.1.0-rc.2

package/build/utils/trace-parser.js

@@ -53,10 +53,10 @@ function parseSkyrampTrace(data) {
             path: entry.path || entry.Path || entry.url || entry.request?.url || "/",
             statusCode: entry.statusCode || entry.StatusCode || entry.status || entry.response?.status || 0,
             requestHeaders: entry.request?.headers ? sanitizeHeaders(entry.request.headers) : undefined,
-            requestBody: entry.request?.body || entry.requestBody || entry.RequestBody,
+            requestBody: summarizeBody(entry.request?.body ?? entry.requestBody ?? entry.RequestBody),
             queryParams,
             responseHeaders: entry.response?.headers ? sanitizeHeaders(entry.response.headers) : undefined,
-            responseBody: summarizeBody(entry.response?.body || entry.responseBody || entry.ResponseBody),
+            responseBody: summarizeBody(entry.response?.body ?? entry.responseBody ?? entry.ResponseBody),
             timestamp: entry.timestamp || entry.Timestamp || entry.request?.timestamp || "",
         };
     });
@@ -105,7 +105,7 @@ function parseHarTrace(harData) {
             path: url.pathname,
             statusCode: res.status || 0,
             requestHeaders: sanitizeHeaders(reqHeaders),
-            requestBody: reqBody,
+            requestBody: summarizeBody(reqBody),
             queryParams: Object.keys(queryParams).length > 0 ? queryParams : undefined,
             responseHeaders: sanitizeHeaders(resHeaders),
             responseBody: summarizeBody(resBody),
@@ -156,6 +156,8 @@ export async function parseTraceFile(filePath) {
     return { entries, userFlows, format };
 }
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", "coverage", "__pycache__", ".venv", "venv"]);
+/** Known test-artifact directories where testbot-generated traces are written. */
+const TRACE_SCAN_DIRS = [".skyramp", "tests", "test", "e2e", "playwright"];
 /**
  * Recursively scan a directory for files matching a predicate, up to maxDepth levels.
  */
@@ -180,6 +182,22 @@ function scanDir(dir, predicate, maxDepth, results) {
         }
     }
 }
+/**
+ * Scan only known test-artifact directories for trace files.
+ * Root-level files are checked at depth 0; named test-artifact subdirs are scanned
+ * at full depth. This prevents picking up committed demo assets (e.g. frontend/public/traces/).
+ */
+function scanTraceArtifactDirs(repositoryPath, predicate, results) {
+    // Root-level files only (depth 0)
+    scanDir(repositoryPath, predicate, 0, results);
+    // Named test-artifact subdirectories (full depth)
+    for (const dir of TRACE_SCAN_DIRS) {
+        const full = path.join(repositoryPath, dir);
+        if (fs.existsSync(full)) {
+            scanDir(full, predicate, 5, results);
+        }
+    }
+}
 /**
  * Discover trace JSON files in a repository path.
  */
@@ -191,12 +209,12 @@ export function discoverTraceFiles(repositoryPath) {
         if (fs.existsSync(full))
             found.push(full);
     }
-    // Recursive scan: any *trace*.json|har, but exclude scenario files and test output files
+    // Recursive scan scoped to test-artifact dirs: any *trace*.json|har, excluding scenario/test output files
     const isTraceJson = (name) => /\.(json|har)$/i.test(name) &&
         /trace/i.test(name) &&
         !/^scenario_/i.test(name) &&
         !/_test\.(json|har)$/i.test(name);
-    scanDir(repositoryPath, isTraceJson, 5, found);
+    scanTraceArtifactDirs(repositoryPath, isTraceJson, found);
     // Deduplicate and sort for deterministic ordering
     return [...new Set(found)].sort();
 }
@@ -209,6 +227,6 @@ export function discoverPlaywrightZips(repositoryPath) {
     const isPlaywrightZip = (name) => /\.zip$/i.test(name) && (/playwright/i.test(name) ||
         /_trace\.zip$/i.test(name) ||
         name.toLowerCase() === "trace.zip");
-    scanDir(repositoryPath, isPlaywrightZip, 5, found);
+    scanTraceArtifactDirs(repositoryPath, isPlaywrightZip, found);
     return [...new Set(found)].sort();
 }

package/build/utils/trace-parser.test.js

@@ -0,0 +1,140 @@
+/**
+ * Unit tests for trace-parser.ts — specifically the scanTraceArtifactDirs scoping
+ * introduced to prevent demo/fixture files (e.g. frontend/public/traces/) from being
+ * misidentified as testbot-generated traces.
+ */
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { discoverTraceFiles, discoverPlaywrightZips } from "./trace-parser.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function mkdirp(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function touch(file) {
+    mkdirp(path.dirname(file));
+    fs.writeFileSync(file, "");
+}
+function withTempRepo(fn) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "trace-parser-test-"));
+    try {
+        fn(dir);
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+// ---------------------------------------------------------------------------
+// discoverPlaywrightZips — scoping tests
+// ---------------------------------------------------------------------------
+describe("discoverPlaywrightZips — scanTraceArtifactDirs scoping", () => {
+    it("does NOT discover playwright zip in frontend/public/traces/ (demo fixture dir)", () => {
+        withTempRepo(repo => {
+            touch(path.join(repo, "frontend", "public", "traces", "ui_test_playwright.zip"));
+            expect(discoverPlaywrightZips(repo)).toEqual([]);
+        });
+    });
+    it("discovers playwright zip in tests/ (test-artifact dir)", () => {
+        withTempRepo(repo => {
+            const zip = path.join(repo, "tests", "ui_test_playwright.zip");
+            touch(zip);
+            expect(discoverPlaywrightZips(repo)).toContain(zip);
+        });
+    });
+    it("discovers playwright zip in .skyramp/ (test-artifact dir)", () => {
+        withTempRepo(repo => {
+            const zip = path.join(repo, ".skyramp", "recording_playwright.zip");
+            touch(zip);
+            expect(discoverPlaywrightZips(repo)).toContain(zip);
+        });
+    });
+    it("discovers playwright zip in e2e/ (test-artifact dir)", () => {
+        withTempRepo(repo => {
+            const zip = path.join(repo, "e2e", "flow_playwright.zip");
+            touch(zip);
+            expect(discoverPlaywrightZips(repo)).toContain(zip);
+        });
+    });
+    it("discovers playwright zip in playwright/ (test-artifact dir)", () => {
+        withTempRepo(repo => {
+            const zip = path.join(repo, "playwright", "trace.zip");
+            touch(zip);
+            expect(discoverPlaywrightZips(repo)).toContain(zip);
+        });
+    });
+    it("does NOT discover zip in src/ (not a test-artifact dir)", () => {
+        withTempRepo(repo => {
+            touch(path.join(repo, "src", "recordings", "ui_playwright.zip"));
+            expect(discoverPlaywrightZips(repo)).toEqual([]);
+        });
+    });
+    it("does NOT discover zip in deeply nested non-test dir", () => {
+        withTempRepo(repo => {
+            touch(path.join(repo, "frontend", "src", "assets", "demo_playwright.zip"));
+            expect(discoverPlaywrightZips(repo)).toEqual([]);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// discoverTraceFiles — scoping tests
+// ---------------------------------------------------------------------------
+describe("discoverTraceFiles — scanTraceArtifactDirs scoping", () => {
+    it("does NOT discover trace.json nested under frontend/public/traces/", () => {
+        withTempRepo(repo => {
+            touch(path.join(repo, "frontend", "public", "traces", "backend_trace.json"));
+            const found = discoverTraceFiles(repo);
+            // fixed-name root candidates don't match "backend_trace.json", and scan won't reach frontend/
+            expect(found.some(f => f.includes("frontend"))).toBe(false);
+        });
+    });
+    it("discovers trace.json in tests/ dir", () => {
+        withTempRepo(repo => {
+            const f = path.join(repo, "tests", "backend_trace.json");
+            touch(f);
+            expect(discoverTraceFiles(repo)).toContain(f);
+        });
+    });
+    it("discovers trace.json in .skyramp/ dir", () => {
+        withTempRepo(repo => {
+            const f = path.join(repo, ".skyramp", "skyramp_trace.json");
+            touch(f);
+            expect(discoverTraceFiles(repo)).toContain(f);
+        });
+    });
+    it("discovers root-level trace.json", () => {
+        withTempRepo(repo => {
+            const f = path.join(repo, "trace.json");
+            touch(f);
+            expect(discoverTraceFiles(repo)).toContain(f);
+        });
+    });
+    it("discovers root-level skyramp_traces.json via fixed-name check", () => {
+        withTempRepo(repo => {
+            const f = path.join(repo, "skyramp_traces.json");
+            touch(f);
+            expect(discoverTraceFiles(repo)).toContain(f);
+        });
+    });
+    it("does NOT discover scenario_ json files (excluded by predicate)", () => {
+        withTempRepo(repo => {
+            touch(path.join(repo, "tests", "scenario_orders_trace.json"));
+            expect(discoverTraceFiles(repo)).toEqual([]);
+        });
+    });
+    it("does NOT discover _test.json files (excluded by predicate)", () => {
+        withTempRepo(repo => {
+            touch(path.join(repo, "tests", "orders_trace_test.json"));
+            expect(discoverTraceFiles(repo)).toEqual([]);
+        });
+    });
+    it("results are deduplicated when fixed-name and scan both find the same root file", () => {
+        withTempRepo(repo => {
+            const f = path.join(repo, "trace.json");
+            touch(f);
+            const found = discoverTraceFiles(repo);
+            expect(found.filter(x => x === f)).toHaveLength(1);
+        });
+    });
+});

package/node_modules/playwright/lib/mcp/browser/browserServerBackend.js

@@ -74,6 +74,9 @@ ${String(error)}` }],
     }
     return responseObject;
   }
+  get context() {
+    return this._context;
+  }
   serverClosed() {
     void this._context?.dispose().catch(import_log.logUnhandledError);
   }

package/node_modules/playwright/lib/mcp/browser/tab.js

@@ -253,7 +253,14 @@ class Tab extends import_events.EventEmitter {
         if (param.element)
           locator = locator.describe(param.element);
         const { resolvedSelector } = await locator._resolveSelector();
-        return { locator, resolved: (0, import_utils.asLocator)("javascript", resolvedSelector) };
+        let fixedSelector = resolvedSelector;
+        if (!resolvedSelector.includes("internal:control=enter-frame") && /^(css=)?iframe\b[^>]*\s+>>\s+/.test(resolvedSelector)) {
+          fixedSelector = resolvedSelector.replace(
+            /^(css=)?(iframe\b[^>]*)\s+>>\s+/,
+            "css=$2 >> internal:control=enter-frame >> "
+          );
+        }
+        return { locator, resolved: (0, import_utils.asLocator)("javascript", fixedSelector) };
       } catch (e) {
         throw new Error(`Ref ${param.ref} not found in the current page snapshot. Try capturing new snapshot.`);
       }

package/node_modules/playwright/lib/mcp/browser/tools/keyboard.js

@@ -69,14 +69,15 @@ const pressSequentially = (0, import_tool.defineTabTool)({
 const typeSchema = import_snapshot.elementSchema.extend({
   text: import_mcpBundle.z.string().describe("Text to type into the element"),
   submit: import_mcpBundle.z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
-  slowly: import_mcpBundle.z.boolean().optional().describe("Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.")
+  slowly: import_mcpBundle.z.boolean().optional().describe("DO NOT USE \u2014 causes silent failures in contenteditable and rich text editors. Use default fast fill instead."),
+  clear: import_mcpBundle.z.boolean().optional().describe("Ignored \u2014 browser_type always replaces existing content. Do not pass this parameter.")
 });
 const type = (0, import_tool.defineTabTool)({
   capability: "core",
   schema: {
     name: "browser_type",
     title: "Type text",
-    description: "Type text into editable element",
+    description: "Type text into an editable element. Auto-focuses and replaces existing content. NEVER call browser_click on the field first \u2014 clicking before typing injects extra network requests that corrupt the trace.",
     inputSchema: typeSchema,
     type: "input"
   },

package/node_modules/playwright/lib/mcp/browser/tools/navigate.js

@@ -28,7 +28,7 @@ const navigate = (0, import_tool.defineTool)({
   schema: {
     name: "browser_navigate",
     title: "Navigate to a URL",
-    description: "Navigate to a URL",
+    description: "Navigate to a URL. Prefer direct navigation to known URLs over clicking menus or carousels \u2014 menus may open unwanted popups and carousel items cause strict-mode violations. To reload the current page, navigate to the same URL \u2014 the backend converts this to page.reload(). After navigating to a folder where content was just created/edited, always call browser_wait_for with the file name before interacting with it.",
     inputSchema: import_mcpBundle.z.object({
       url: import_mcpBundle.z.string().describe("The URL to navigate to")
     }),

package/node_modules/playwright/lib/mcp/browser/tools/snapshot.js

@@ -30,7 +30,7 @@ const snapshot = (0, import_tool.defineTool)({
   schema: {
     name: "browser_snapshot",
     title: "Page snapshot",
-    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    description: "Capture the ARIA accessibility tree of the current page. Returns element refs required by all interaction tools (browser_click, browser_type, browser_hover, etc.). Call before any interaction and after every action that changes the page to get fresh refs. If any interaction tool fails with a stale ref error, call this first to refresh.",
     inputSchema: import_mcpBundle.z.object({
       filename: import_mcpBundle.z.string().optional().describe("Save snapshot to markdown file instead of returning it in the response.")
     }),
@@ -55,7 +55,7 @@ const click = (0, import_tool.defineTabTool)({
   schema: {
     name: "browser_click",
     title: "Click",
-    description: "Perform click on a web page",
+    description: "Click an element on the page. Always click the actual interactive element (button, link, input) \u2014 never a container or wrapper div. NEVER click a text field before typing \u2014 browser_type auto-focuses; a prior click injects extra network requests that corrupt the trace. NEVER click a row or link in a file list to access contextual actions \u2014 use browser_hover on the row instead.",
     inputSchema: clickSchema,
     type: "input"
   },
@@ -111,7 +111,7 @@ const hover = (0, import_tool.defineTabTool)({
   schema: {
     name: "browser_hover",
     title: "Hover mouse",
-    description: "Hover over element on page",
+    description: "Hover over an element. Required pattern for contextual actions (More Options, Delete, Rename, \u22EF) on list/grid rows: (1) call browser_hover on the row element, (2) call browser_snapshot to reveal hover-only controls, (3) click the target button. NEVER click the row itself \u2014 that navigates into the item.",
     inputSchema: elementSchema,
     type: "input"
   },
@@ -132,7 +132,7 @@ const selectOption = (0, import_tool.defineTabTool)({
   schema: {
     name: "browser_select_option",
     title: "Select option",
-    description: "Select an option in a dropdown",
+    description: "Select an option in a native <select> dropdown only. For custom dropdowns (Radix, MUI, etc.) that appear as combobox in the snapshot, do NOT use this tool \u2014 instead: (1) click the combobox to open it, (2) call browser_snapshot to see the listbox options, (3) click the desired option.",
     inputSchema: selectOptionSchema,
     type: "input"
   },

package/node_modules/playwright/lib/mcp/browser/tools/tabs.js

@@ -29,10 +29,10 @@ const browserTabs = (0, import_tool.defineTool)({
   schema: {
     name: "browser_tabs",
     title: "Manage tabs",
-    description: "List, create, close, or select a browser tab.",
+    description: 'List, create, close, or switch to a browser tab. When a click opens a new tab, use action "select" with the tab index to switch to it. Do NOT call browser_navigate after switching \u2014 the tab is already on the right page.',
     inputSchema: import_mcpBundle.z.object({
-      action: import_mcpBundle.z.enum(["list", "new", "close", "select"]).describe("Operation to perform"),
-      index: import_mcpBundle.z.number().optional().describe("Tab index, used for close/select. If omitted for close, current tab is closed.")
+      action: import_mcpBundle.z.enum(["list", "new", "close", "select", "switch"]).describe('Operation to perform. "select" and "switch" are equivalent \u2014 both switch to a tab by index.'),
+      index: import_mcpBundle.z.number().optional().describe("Tab index, used for close/select/switch. If omitted for close, current tab is closed.")
     }),
     type: "action"
   },
@@ -50,7 +50,8 @@ const browserTabs = (0, import_tool.defineTool)({
         await context.closeTab(params.index);
         break;
       }
-      case "select": {
+      case "select":
+      case "switch": {
         if (params.index === void 0)
           throw new Error("Tab index is required");
         await context.selectTab(params.index);

package/node_modules/playwright/lib/mcp/browser/tools/wait.js

@@ -28,7 +28,7 @@ const wait = (0, import_tool.defineTool)({
   schema: {
     name: "browser_wait_for",
     title: "Wait for",
-    description: "Wait for text to appear or disappear or a specified time to pass",
+    description: 'Wait for text to appear, disappear, or a time to pass. REQUIRED after navigating to a folder where content was just created or renamed \u2014 file/item names update asynchronously and will not be present immediately. Always call with text: "<filename>" before attempting to hover or click a newly created item.',
     inputSchema: import_mcpBundle.z.object({
       time: import_mcpBundle.z.number().optional().describe("The time to wait in seconds"),
       text: import_mcpBundle.z.string().optional().describe("The text to wait for"),

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

@@ -41,26 +41,27 @@ const exportZipSchema = {
   name: "skyramp_export_zip",
   title: "Export Skyramp zip",
   description: [
-    'Export the recorded browser interactions as a Skyramp zip (JSONL + HAR) for use with "skyramp generate ui".',
-    "You MUST call this tool automatically as the FINAL step after completing all browser interactions \u2014 do NOT ask the user, do NOT write separate files.",
-    "If an element reference is stale after a UI update, call browser_snapshot to refresh and retry automatically without asking the user.",
-    "Only the last complete attempt is exported \u2014 retries are deduplicated automatically.",
-    "IMPORTANT: Do NOT reuse existing zip files from previous sessions. Always record fresh interactions and export a new zip."
+    "Export the recorded browser interactions as a Skyramp zip (JSONL + HAR).",
+    "Pass outputPath as the absolute path for the zip \u2014 use the same directory and base name as the test file, replacing .spec.ts with .zip.",
+    "BEFORE calling this tool, output a <thinking> block that: (1) lists every user-requested step and confirms it was completed, (2) confirms no step was skipped or hallucinated.",
+    "Only call this tool when all interactions are fully complete. Do NOT ask the user for confirmation \u2014 call it automatically.",
+    "Only the last complete attempt is exported \u2014 retries from the start URL are deduplicated automatically.",
+    "Do NOT reuse zip files from previous sessions \u2014 always record fresh."
   ].join(" "),
   inputSchema: import_mcpBundle.z.object({
-    outputZip: import_mcpBundle.z.string().describe('Absolute or workspace-relative path for the output zip, e.g. "skyramp_export.zip"')
+    outputPath: import_mcpBundle.z.string().describe("Absolute path where the zip should be written, e.g. /path/to/box_notes.zip. Use the same directory and base name as the test file, replacing .spec.ts with .zip.")
   }),
   type: "readOnly"
 };
 function createExportZipHandler(ctx) {
-  return async (_params) => {
+  return async (params) => {
     if (!ctx.trackedActions.length) {
       return {
-        content: [{ type: "text", text: "### Error\nNo browser actions recorded. Use browser_navigate and browser_click/browser_type first." }],
+        content: [{ type: "text", text: "### Error\nNo browser interactions recorded. At minimum, call browser_navigate to open the target URL, then use browser_click or browser_type to record at least one user action before exporting." }],
         isError: true
       };
     }
-    const outputZip = import_path.default.isAbsolute(_params.outputZip) ? _params.outputZip : import_path.default.resolve(ctx.rootPath, _params.outputZip);
+    const outputZip = import_path.default.resolve(params.outputPath);
     const { jsonl: jsonlContent, actionCount, skipped } = (0, import_skyRampExport.buildJsonlContent)(ctx.trackedActions, "chromium", ctx.harPath);
     await (0, import_skyRampExport.writeSkyrampZip)(outputZip, jsonlContent, ctx.harPath);
     const skippedNote = skipped.length ? `