@skyramp/mcp 0.2.8 → 0.2.10-rc.1

package/build/utils/sourceRouteExtractor.test.js

@@ -562,4 +562,177 @@ export default function App() {
         expect(routes[0].componentFile).toMatch(/src\/pages\/Cart\/index\.tsx$/);
         cleanup(repo);
     });
+    // ── Nested React Router routes ────────────────────────────────────────────
+    it("composes nested JSX <Route> child paths with their parent", () => {
+        // React Router v6 child paths are relative to the parent route. Without
+        // composition the extractor emits bare segments ("settings") that aren't
+        // navigable URLs.
+        const repo = makeTmpRepo([
+            {
+                path: "src/App.tsx",
+                content: `
+import { Routes, Route } from 'react-router-dom';
+import Dashboard from './pages/Dashboard';
+import Settings from './pages/Settings';
+import Users from './pages/Users';
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/dashboard" element={<Dashboard />}>
+        <Route path="settings" element={<Settings />} />
+        <Route path="users" element={<Users />} />
+      </Route>
+    </Routes>
+  );
+}
+`,
+            },
+        ]);
+        const routes = extractSourceRoutes(repo);
+        expect(routes.map((r) => r.path).sort()).toEqual([
+            "/dashboard",
+            "/dashboard/settings",
+            "/dashboard/users",
+        ]);
+        cleanup(repo);
+    });
+    it("composes relative child paths under a root layout route", () => {
+        // Canonical RR v6 shape: a path-bearing parent that itself has children,
+        // with relative child paths. The parent must not count its own path twice.
+        const repo = makeTmpRepo([
+            {
+                path: "src/App.tsx",
+                content: `
+import { Routes, Route } from 'react-router-dom';
+import Layout from './Layout';
+import Dashboard from './pages/Dashboard';
+import Settings from './pages/Settings';
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/" element={<Layout />}>
+        <Route path="dashboard" element={<Dashboard />}>
+          <Route path="settings" element={<Settings />} />
+        </Route>
+      </Route>
+    </Routes>
+  );
+}
+`,
+            },
+        ]);
+        const routes = extractSourceRoutes(repo);
+        expect(routes.find((r) => r.componentName === "Dashboard").path).toBe("/dashboard");
+        expect(routes.find((r) => r.componentName === "Settings").path).toBe("/dashboard/settings");
+        cleanup(repo);
+    });
+    it("resolves a JSX index route to its parent's path", () => {
+        // <Route index> has no path attribute; it renders at the parent's path.
+        const repo = makeTmpRepo([
+            {
+                path: "src/App.tsx",
+                content: `
+import { Routes, Route } from 'react-router-dom';
+import Dashboard from './pages/Dashboard';
+import DashboardHome from './pages/DashboardHome';
+
+export default function App() {
+  return (
+    <Routes>
+      <Route path="/dashboard" element={<Dashboard />}>
+        <Route index element={<DashboardHome />} />
+      </Route>
+    </Routes>
+  );
+}
+`,
+            },
+        ]);
+        const routes = extractSourceRoutes(repo);
+        const home = routes.find((r) => r.componentName === "DashboardHome");
+        expect(home).toBeDefined();
+        expect(home.path).toBe("/dashboard");
+        cleanup(repo);
+    });
+    it("extracts createBrowserRouter data-router routes with composed nested paths", () => {
+        // The data-router API uses object literals with `element:` (JSX) and nests
+        // via `children:` — neither the JSX-element path nor the Vue object path
+        // handled these, so the whole tree was missed (root-only fallback).
+        const repo = makeTmpRepo([
+            {
+                path: "src/router.tsx",
+                content: `
+import { createBrowserRouter } from 'react-router-dom';
+import Root from './Root';
+import Dashboard from './pages/Dashboard';
+import Settings from './pages/Settings';
+import Profile from './pages/Profile';
+
+export const router = createBrowserRouter([
+  {
+    path: '/',
+    element: <Root />,
+    children: [
+      { path: 'dashboard', element: <Dashboard /> },
+      {
+        path: 'settings',
+        element: <Settings />,
+        children: [
+          { path: 'profile', element: <Profile /> },
+        ],
+      },
+    ],
+  },
+]);
+`,
+            },
+        ]);
+        const routes = extractSourceRoutes(repo);
+        expect(routes.map((r) => r.path).sort()).toEqual([
+            "/",
+            "/dashboard",
+            "/settings",
+            "/settings/profile",
+        ]);
+        expect(routes.find((r) => r.path === "/settings/profile").componentName).toBe("Profile");
+        cleanup(repo);
+    });
+    it("extracts createStaticRouter (SSR) routes with composed nested paths", () => {
+        // SSR apps build routes with createStaticRouter — same route-array shape as
+        // createBrowserRouter, so nested composition must work identically.
+        const repo = makeTmpRepo([
+            {
+                path: "src/router.tsx",
+                content: `
+import { createStaticRouter } from 'react-router-dom/server';
+import Root from './Root';
+import Reports from './pages/Reports';
+import Detail from './pages/Detail';
+
+export const router = createStaticRouter([
+  {
+    path: '/',
+    element: <Root />,
+    children: [
+      { path: 'reports', element: <Reports />,
+        children: [
+          { path: ':id', element: <Detail /> },
+        ],
+      },
+    ],
+  },
+]);
+`,
+            },
+        ]);
+        const routes = extractSourceRoutes(repo);
+        expect(routes.map((r) => r.path).sort()).toEqual([
+            "/",
+            "/reports",
+            "/reports/:id",
+        ]);
+        cleanup(repo);
+    });
 });

package/build/utils/utils.d.ts

@@ -1,6 +1,17 @@
 import { CallToolResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
 export declare function readDiffFile(diffFilePath: string | undefined): string | undefined;
 export declare function toolError(message: string): CallToolResult;
+/**
+ * Does `candidate` (an LLM- or caller-supplied name/path) identify `fullPath` (a known,
+ * absolute test file path)? Exact match first, then a real path-segment boundary match
+ * for a relative candidate (e.g. "tests/foo.py" against ".../repo/tests/foo.py") — never
+ * a bare substring/suffix check. Only falls back to basename equality when `candidate`
+ * carries no path info at all, since that's the one case where the caller genuinely gave
+ * us nothing more specific to disambiguate with (bare filenames can still collide across
+ * different directories that happen to share one — this is the caller's ambiguity, not
+ * something a smarter match here can resolve).
+ */
+export declare function testFileMatches(fullPath: string, candidate: string): boolean;
 /**
  * Happy-path counterpart to `toolError`. Wraps a single text payload in the
  * MCP tool-result shape so handlers don't have to construct

package/build/utils/utils.js

@@ -18,6 +18,25 @@ export function toolError(message) {
         isError: true,
     };
 }
+/**
+ * Does `candidate` (an LLM- or caller-supplied name/path) identify `fullPath` (a known,
+ * absolute test file path)? Exact match first, then a real path-segment boundary match
+ * for a relative candidate (e.g. "tests/foo.py" against ".../repo/tests/foo.py") — never
+ * a bare substring/suffix check. Only falls back to basename equality when `candidate`
+ * carries no path info at all, since that's the one case where the caller genuinely gave
+ * us nothing more specific to disambiguate with (bare filenames can still collide across
+ * different directories that happen to share one — this is the caller's ambiguity, not
+ * something a smarter match here can resolve).
+ */
+export function testFileMatches(fullPath, candidate) {
+    if (fullPath === candidate)
+        return true;
+    if (path.isAbsolute(candidate))
+        return false;
+    if (candidate.includes("/"))
+        return fullPath.endsWith("/" + candidate);
+    return path.basename(fullPath) === candidate;
+}
 /**
  * Happy-path counterpart to `toolError`. Wraps a single text payload in the
  * MCP tool-result shape so handlers don't have to construct

package/build/utils/utils.test.js

@@ -1,5 +1,27 @@
 // @ts-ignore
-import { validateParams, generateSkyrampHeader } from "./utils.js";
+import { validateParams, generateSkyrampHeader, testFileMatches } from "./utils.js";
+describe("testFileMatches", () => {
+    it("matches identical absolute paths", () => {
+        expect(testFileMatches("/repo/tests/orders_test.py", "/repo/tests/orders_test.py")).toBe(true);
+    });
+    it("does not match two different absolute paths, even with the same basename", () => {
+        expect(testFileMatches("/repo/frontend/tests/utils_test.py", "/repo/backend/tests/utils_test.py")).toBe(false);
+    });
+    it("matches a relative candidate against a real path-segment boundary", () => {
+        expect(testFileMatches("/repo/backend/tests/orders_test.py", "tests/orders_test.py")).toBe(true);
+    });
+    it("does not match a relative candidate that is only a substring, not a path-segment boundary", () => {
+        // "ers_test.py" is a suffix of the basename but not preceded by a path separator.
+        expect(testFileMatches("/repo/backend/tests/orders_test.py", "ers_test.py")).toBe(false);
+    });
+    it("falls back to basename equality only when the candidate has no path info at all", () => {
+        expect(testFileMatches("/repo/backend/tests/orders_test.py", "orders_test.py")).toBe(true);
+    });
+    it("bare-basename fallback is ambiguous across two files that share a basename (documented limitation)", () => {
+        expect(testFileMatches("/repo/frontend/tests/utils_test.py", "utils_test.py")).toBe(true);
+        expect(testFileMatches("/repo/backend/tests/utils_test.py", "utils_test.py")).toBe(true);
+    });
+});
 describe("validateParams", () => {
     it("should return null for valid comma-separated key=value pairs", () => {
         const result = validateParams("foo=bar,baz=qux", "testField");

package/build/utils/versions.d.ts

@@ -1,3 +1,3 @@
-export declare const SKYRAMP_IMAGE_VERSION = "v1.3.29";
-export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.29";
-export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.29";
+export declare const SKYRAMP_IMAGE_VERSION = "v1.3.32";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.32";
+export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.32";

package/build/utils/versions.js

@@ -1,3 +1,3 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.29";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.32";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;

package/build/workspace/workspace.d.ts

@@ -99,22 +99,22 @@ export declare const workspaceConfigSchema: z.ZodObject<{
     }>>;
     metadata: z.ZodOptional<z.ZodObject<{
         schemaVersion: z.ZodString;
-        mcpVersion: z.ZodString;
+        mcpVersion: z.ZodOptional<z.ZodString>;
         executorVersion: z.ZodString;
-        createdAt: z.ZodString;
-        updatedAt: z.ZodString;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        createdAt: string;
         schemaVersion: string;
-        mcpVersion: string;
         executorVersion: string;
-        updatedAt: string;
+        createdAt?: string | undefined;
+        mcpVersion?: string | undefined;
+        updatedAt?: string | undefined;
     }, {
-        createdAt: string;
         schemaVersion: string;
-        mcpVersion: string;
         executorVersion: string;
-        updatedAt: string;
+        createdAt?: string | undefined;
+        mcpVersion?: string | undefined;
+        updatedAt?: string | undefined;
     }>>;
     services: z.ZodOptional<z.ZodArray<z.ZodObject<{
         serviceName: z.ZodString;
@@ -203,11 +203,11 @@ export declare const workspaceConfigSchema: z.ZodObject<{
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     metadata?: {
-        createdAt: string;
         schemaVersion: string;
-        mcpVersion: string;
         executorVersion: string;
-        updatedAt: string;
+        createdAt?: string | undefined;
+        mcpVersion?: string | undefined;
+        updatedAt?: string | undefined;
     } | undefined;
     workspace?: {
         repoName?: string | undefined;
@@ -236,11 +236,11 @@ export declare const workspaceConfigSchema: z.ZodObject<{
     }[] | undefined;
 }, {
     metadata?: {
-        createdAt: string;
         schemaVersion: string;
-        mcpVersion: string;
         executorVersion: string;
-        updatedAt: string;
+        createdAt?: string | undefined;
+        mcpVersion?: string | undefined;
+        updatedAt?: string | undefined;
     } | undefined;
     workspace?: {
         repoName?: string | undefined;
@@ -277,11 +277,11 @@ export type MetadataSection = NonNullable<WorkspaceConfig["metadata"]>;
 /** Validates a workspace configuration object against the Zod schema. */
 export declare function validateWorkspaceConfig(config: unknown): z.SafeParseReturnType<{
     metadata?: {
-        createdAt: string;
         schemaVersion: string;
-        mcpVersion: string;
         executorVersion: string;
-        updatedAt: string;
+        createdAt?: string | undefined;
+        mcpVersion?: string | undefined;
+        updatedAt?: string | undefined;
     } | undefined;
     workspace?: {
         repoName?: string | undefined;
@@ -310,11 +310,11 @@ export declare function validateWorkspaceConfig(config: unknown): z.SafeParseRet
     }[] | undefined;
 }, {
     metadata?: {
-        createdAt: string;
         schemaVersion: string;
-        mcpVersion: string;
         executorVersion: string;
-        updatedAt: string;
+        createdAt?: string | undefined;
+        mcpVersion?: string | undefined;
+        updatedAt?: string | undefined;
     } | undefined;
     workspace?: {
         repoName?: string | undefined;

package/build/workspace/workspace.js

@@ -78,10 +78,14 @@ export const workspaceConfigSchema = z
     metadata: z
         .object({
         schemaVersion: z.string(),
-        mcpVersion: z.string(),
+        // mcpVersion is no longer written by skyramp_init_workspace (SKYR-3818), but
+        // remains an optional, recognized key: testbot reads it from pre-existing
+        // workspaces as a fallback MCP-version pin (testbot.git src/config.ts), and
+        // older files still carry it. Optional so configs without it validate.
+        mcpVersion: z.string().optional(),
         executorVersion: z.string(),
-        createdAt: z.string(),
-        updatedAt: z.string(),
+        createdAt: z.string().optional(),
+        updatedAt: z.string().optional(),
     })
         .strict()
         .optional(),
@@ -121,7 +125,6 @@ export function createDefaultConfig() {
         workspace: {},
         metadata: {
             schemaVersion: "v1",
-            mcpVersion: "",
             executorVersion: "",
             createdAt: now,
             updatedAt: now,

package/build/workspace/workspace.test.js

@@ -7,9 +7,11 @@ import { serviceSchema, WorkspaceConfigManager, validateWorkspaceConfig, createD
 describe("workspace module (ported from @skyramp/skyramp, SKYR-3794)", () => {
     describe("serviceSchema", () => {
         it("accepts an optional repository and rejects a non-string repository", () => {
-            expect(serviceSchema.safeParse({ serviceName: "api", repository: "org/api" }).success).toBe(true);
+            expect(serviceSchema.safeParse({ serviceName: "api", repository: "org/api" })
+                .success).toBe(true);
             expect(serviceSchema.safeParse({ serviceName: "api" }).success).toBe(true);
-            expect(serviceSchema.safeParse({ serviceName: "api", repository: 123 }).success).toBe(false);
+            expect(serviceSchema.safeParse({ serviceName: "api", repository: 123 })
+                .success).toBe(false);
         });
         it("rejects unknown fields (strict)", () => {
             expect(serviceSchema.safeParse({ serviceName: "api", bogus: true }).success).toBe(false);
@@ -41,15 +43,72 @@ describe("workspace module (ported from @skyramp/skyramp, SKYR-3794)", () => {
         it("keeps a same-named service from a different repo distinct, and upserts in place", async () => {
             const mgr = new WorkspaceConfigManager(repoDir);
             await mgr.initialize();
-            await mgr.addService({ serviceName: "svc", testDirectory: "tests/primary" });
-            await mgr.addService({ serviceName: "svc", repository: "letsramp/api-insight", testDirectory: "tests/py" });
-            await mgr.addService({ serviceName: "svc", testDirectory: "tests/primary-v2" }); // upsert primary
+            await mgr.addService({
+                serviceName: "svc",
+                testDirectory: "tests/primary",
+            });
+            await mgr.addService({
+                serviceName: "svc",
+                repository: "letsramp/api-insight",
+                testDirectory: "tests/py",
+            });
+            await mgr.addService({
+                serviceName: "svc",
+                testDirectory: "tests/primary-v2",
+            }); // upsert primary
             const cfg = read();
             expect(cfg.services).toHaveLength(2);
             expect(cfg.services.find((s) => !s.repository).testDirectory).toBe("tests/primary-v2");
-            expect(cfg.services.find((s) => s.repository === "letsramp/api-insight").testDirectory).toBe("tests/py");
+            expect(cfg.services.find((s) => s.repository === "letsramp/api-insight")
+                .testDirectory).toBe("tests/py");
             // repoName auto-detected from the git remote.
             expect(cfg.workspace.repoName).toBe("letsramp/primary");
         });
     });
+    describe("mcpVersion: no longer written, still accepted (SKYR-3818)", () => {
+        let repoDir;
+        beforeEach(() => {
+            repoDir = fs.mkdtempSync(path.join(os.tmpdir(), "ws-mcpver-"));
+            execFileSync("git", ["init", "-q"], { cwd: repoDir });
+            execFileSync("git", ["remote", "add", "origin", "https://github.com/letsramp/primary.git"], { cwd: repoDir });
+        });
+        afterEach(() => {
+            fs.rmSync(repoDir, { recursive: true, force: true });
+        });
+        // Writes a workspace.yml that carries metadata.mcpVersion, emulating a workspace
+        // initialized by an older MCP version (which still stamped the field).
+        const writeLegacyConfig = () => {
+            const dir = path.join(repoDir, WORKSPACE_DIR);
+            fs.mkdirSync(dir, { recursive: true });
+            const now = new Date().toISOString();
+            const legacy = {
+                workspace: { repoName: "letsramp/primary" },
+                metadata: {
+                    schemaVersion: "v1",
+                    mcpVersion: "0.0.64",
+                    executorVersion: "1.2.3",
+                    createdAt: now,
+                    updatedAt: now,
+                },
+                services: [],
+            };
+            fs.writeFileSync(path.join(dir, WORKSPACE_FILENAME), yaml.dump(legacy), "utf8");
+        };
+        const readRaw = () => yaml.load(fs.readFileSync(path.join(repoDir, WORKSPACE_DIR, WORKSPACE_FILENAME), "utf8"), { schema: yaml.JSON_SCHEMA });
+        it("does not write mcpVersion into a freshly initialized workspace", async () => {
+            const mgr = new WorkspaceConfigManager(repoDir);
+            await mgr.initialize();
+            const onDisk = readRaw();
+            expect(onDisk.metadata.mcpVersion).toBeUndefined();
+        });
+        it("preserves mcpVersion from a pre-existing workspace.yml on read (testbot fallback)", async () => {
+            writeLegacyConfig();
+            const mgr = new WorkspaceConfigManager(repoDir);
+            const cfg = await mgr.read();
+            // Kept as an optional recognized key — not stripped — so testbot's
+            // config.ts MCP-version fallback keeps working for existing workspaces.
+            expect(cfg.metadata?.mcpVersion).toBe("0.0.64");
+            expect(cfg.metadata?.executorVersion).toBe("1.2.3");
+        });
+    });
 });

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

@@ -61,9 +61,14 @@ const uploadFile = (0, import_tool.defineTool)({
     const files = params.paths ?? [];
     response.addCode(`await fileChooser.setFiles(${JSON.stringify(files)})`);
     tab.clearModalState(fileChooserModal);
-    await tab.waitForCompletion(async () => {
-      await fileChooserModal.fileChooser.setFiles(files);
-    });
+    try {
+      await tab.waitForCompletion(async () => {
+        await fileChooserModal.fileChooser.setFiles(files);
+      });
+    } catch (e) {
+      tab.setModalState(fileChooserModal);
+      throw e;
+    }
   }
 });
 var files_default = [

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

@@ -30,7 +30,7 @@ const wait = (0, import_tool.defineTool)({
     title: "Wait for",
     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"),
+      time: import_mcpBundle.z.number().positive().max(30).optional().describe("The time to wait, in SECONDS (not milliseconds), max 30. e.g. 3 = three seconds. Prefer text/textGone waits over a fixed time."),
       text: import_mcpBundle.z.string().optional().describe("The text to wait for"),
       textGone: import_mcpBundle.z.string().optional().describe("The text to wait for to disappear")
     }),

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

@@ -54,6 +54,12 @@ const exportZipSchema = {
   }),
   type: "readOnly"
 };
+function summarizeDropped(dropped) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of dropped)
+    counts.set(d.toolName, (counts.get(d.toolName) ?? 0) + 1);
+  return [...counts.entries()].map(([tool, n]) => n > 1 ? `${tool} \xD7${n}` : tool).join(", ");
+}
 function createExportZipHandler(ctx) {
   return async (params) => {
     if (!ctx.trackedActions.length) {
@@ -86,6 +92,9 @@ Requested path: ${outputZip}` }],
     await (0, import_skyRampExport.writeSkyrampZip)(outputZip, jsonlContent, ctx.harPath);
     const skippedNote = skipped.length ? `
 Skipped (not exportable): ${[...new Set(skipped)].join(", ")}` : "";
+    const dropped = ctx.droppedActions ?? [];
+    const droppedNote = dropped.length ? `
+Failed & dropped (not recorded): ${summarizeDropped(dropped)}` : "";
     return {
       content: [{
         type: "text",
@@ -93,7 +102,7 @@ Skipped (not exportable): ${[...new Set(skipped)].join(", ")}` : "";
 Skyramp zip written to ${outputZip}
 
 Contains:
-- skyramp_playwright.txt (${actionCount} actions)${skippedNote}`
+- skyramp_playwright.txt (${actionCount} actions)${skippedNote}${droppedNote}`
       }]
     };
   };

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

@@ -74,6 +74,7 @@ class TraceRecordingBackend {
   // per-type baseline filename counter
   constructor(options) {
     this._trackedActions = [];
+    this._droppedActions = [];
     this._initialized = false;
     this._pageCount = 0;
     // number of popup pages seen
@@ -92,6 +93,9 @@ class TraceRecordingBackend {
   get trackedActions() {
     return this._trackedActions;
   }
+  get droppedActions() {
+    return this._droppedActions;
+  }
   async initialize(clientInfo) {
     const userDataDir = this._options.userDataDir || process.env.PLAYWRIGHT_USER_DATA_DIR || void 0;
     const loadExtension = this._options.loadExtension ?? splitExtensionPaths(process.env.PLAYWRIGHT_LOAD_EXTENSION);
@@ -185,12 +189,14 @@ class TraceRecordingBackend {
       this._consumeRecorderSelectors();
       const handler = (0, import_exportTool.createExportZipHandler)({
         trackedActions: this._trackedActions,
+        droppedActions: this._droppedActions,
         harPath: this._harPath,
         outputDir: this._outputDir
       });
       const exportResult = await handler(parsed);
       if (!exportResult.isError) {
         this._trackedActions = [];
+        this._droppedActions = [];
         const ra = this._browserBackend.context?.recorderActions;
         if (ra)
           ra.length = 0;
@@ -1691,8 +1697,13 @@ Cell row ${params.row}, column ${params.column} has "${actual}", expected "${par
     };
   }
   _maybeTrackAction(toolName, args, result, timestamp, pageAliasBeforeAction) {
-    if (result.isError)
+    if (result.isError) {
+      const errParsed = (0, import_response.parseResponse)(result);
+      const errText = (errParsed?.error ?? errParsed?.text ?? "unknown error").replace(/\s+/g, " ").trim().slice(0, 300);
+      this._droppedActions.push({ toolName, error: errText });
+      traceDebug(`Dropped failed action: ${toolName} args=${JSON.stringify(args).slice(0, 200)} \u2014 ${errText} (dropped total: ${this._droppedActions.length})`);
       return;
+    }
     const parsed = (0, import_response.parseResponse)(result);
     const code = parsed?.code ?? "";
     if (code || import_types.ARGS_ONLY_TOOLS.has(toolName)) {
@@ -1771,15 +1782,28 @@ Cell row ${params.row}, column ${params.column} has "${actual}", expected "${par
     else
       traceDebug("Flutter placeholder clicked but semantics not confirmed active");
   }
-  /** Clean up temp directory and optionally recreate it for next session. */
-  _cleanupTempDir(recreate = false) {
+  /**
+   * Clean up temp files. When `reuse` is true (between recordings in the same
+   * session), the temp directory and `_harPath` are kept STABLE and only their
+   * contents are cleared; when false (session end), the directory is removed.
+   *
+   * SKYR-3830: `recordHar.path` is baked by value into the context factory's
+   * config at initialize(). Reassigning `_harPath` to a fresh temp dir here
+   * desynced it from that baked path, so every recording after the first wrote
+   * its HAR to the original (now-deleted) path while export read the new
+   * `_harPath` — yielding an empty HAR and zero `waitForResponse` anchors.
+   * Keeping the path stable lets the next context's recordHar overwrite the
+   * HAR in place on close, so subsequent exports capture network again.
+   */
+  _cleanupTempDir(reuse = false) {
     try {
-      import_fs.default.rmSync(this._tempDir, { recursive: true, force: true });
-      traceDebug(`Cleaned up temp directory: ${this._tempDir}`);
-      if (recreate) {
-        this._tempDir = import_fs.default.mkdtempSync(import_path.default.join(import_os.default.tmpdir(), "skyramp-trace-"));
-        this._harPath = import_path.default.join(this._tempDir, "skyramp_network.har");
-        traceDebug(`Created new temp directory: ${this._tempDir}`);
+      if (reuse) {
+        for (const entry of import_fs.default.readdirSync(this._tempDir))
+          import_fs.default.rmSync(import_path.default.join(this._tempDir, entry), { recursive: true, force: true });
+        traceDebug(`Cleared temp directory for reuse: ${this._tempDir}`);
+      } else {
+        import_fs.default.rmSync(this._tempDir, { recursive: true, force: true });
+        traceDebug(`Cleaned up temp directory: ${this._tempDir}`);
       }
     } catch (e) {
       traceDebug(`Failed to clean up temp directory ${this._tempDir}: ${e}`);

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

@@ -251,7 +251,7 @@ function trackedActionToJsonl(action, pageGuid, timestamp) {
     if (textGone)
       return JSON.stringify({ name: "waitForSelector", selector: `text=${textGone}`, state: "hidden", ...base });
     if (typeof time === "number")
-      return JSON.stringify({ name: "waitForTimeout", duration: time * 1e3, ...base });
+      return JSON.stringify({ name: "waitForTimeout", duration: Math.min(3e4, time * 1e3), ...base });
     return null;
   }
   if (toolName === "browser_press_key")
@@ -261,6 +261,12 @@ function trackedActionToJsonl(action, pageGuid, timestamp) {
       return null;
     return JSON.stringify({ ...args, ...base });
   }
+  if (toolName === "browser_evaluate") {
+    const fn = typeof args.function === "string" ? args.function : "";
+    if (!fn || args.ref && args.element)
+      return null;
+    return JSON.stringify({ name: "evaluate", expression: fn, ...base });
+  }
   if (!code)
     return null;
   const extracted = extractLocatorFromCode(code);