@skyramp/mcp 0.1.8 → 0.2.0-rc.2

package/build/services/TestExecutionService.js

@@ -156,14 +156,25 @@ function filterComments(lines) {
  * Detect session file paths referenced in test files
  * Looks for storageState patterns in TypeScript/JavaScript/Python/Java/C# test files
  * Excludes matches found in comments
+ *
+ * Also handles the codegen pattern `path.join(__dirname, '<filename>')` (TS/JS) —
+ * the filename is resolved relative to the test file's directory on the host so
+ * the existing absolute-path mount branch makes it visible at the same path
+ * inside the container (Playwright's TS loader resolves __dirname to the host
+ * workspace path at runtime).
  */
-function detectSessionFiles(testFilePath) {
+export function detectSessionFiles(testFilePath) {
     try {
         const content = fs.readFileSync(testFilePath, "utf-8");
         const lines = content.split("\n");
         const sessionFiles = [];
         // Pattern for TypeScript/JavaScript: storageState: '/path/to/file' or storageState: "/path/to/file"
         const tsJsPattern = /storageState:\s*['"]([^'"]+)['"]/g;
+        // Pattern for TypeScript/JavaScript with path.join(__dirname, 'filename') — covers
+        // both the inline form (`storageState: path.join(__dirname, '...')`) and the
+        // variable-assignment form (`const X = path.join(__dirname, '...')` then
+        // `storageState: X`) the skyramp codegen emits.
+        const tsJsPathJoinPattern = /path\.join\s*\(\s*__dirname\s*,\s*['"]([^'"]+)['"]\s*\)/g;
         // Pattern for Python: storage_state='/path/to/file' or storage_state="/path/to/file"
         const pythonPattern = /storage_state\s*=\s*['"]([^'"]+)['"]/g;
         // Pattern for Java: setStorageState(Paths.get("path")) or setStorageState("path")
@@ -173,6 +184,7 @@ function detectSessionFiles(testFilePath) {
         const csharpPattern = /StorageState(?:Path)?\s*=\s*['"]([^'"]+)['"]/g;
         // Filter out comments
         const codeLines = filterComments(lines);
+        const testFileDir = path.dirname(testFilePath);
         // Process each non-comment line
         for (const line of codeLines) {
             // Try all patterns on this line
@@ -181,6 +193,12 @@ function detectSessionFiles(testFilePath) {
             while ((match = tsJsPattern.exec(line)) !== null) {
                 sessionFiles.push(match[1]);
             }
+            tsJsPathJoinPattern.lastIndex = 0;
+            while ((match = tsJsPathJoinPattern.exec(line)) !== null) {
+                // Resolve relative to the test file's host directory so the absolute-
+                // path branch below mounts it at the same path inside the container.
+                sessionFiles.push(path.resolve(testFileDir, match[1]));
+            }
             pythonPattern.lastIndex = 0;
             while ((match = pythonPattern.exec(line)) !== null) {
                 sessionFiles.push(match[1]);
@@ -357,39 +375,79 @@ export class TestExecutionService {
                 },
             ],
         };
-        // Mount workspace files, skipping EXCLUDED_MOUNT_ITEMS completely
+        // Mount workspace files, skipping EXCLUDED_MOUNT_ITEMS completely.
+        //
+        // Each workspace entry is bind-mounted at BOTH the canonical /home/user
+        // path AND its host-absolute path. The dual mount lets the test resolve
+        // any absolute reference the codegen happens to embed (storageState,
+        // fixture paths, snapshots) — including the host workspace path that
+        // Playwright's TypeScript loader sometimes produces from `__dirname` —
+        // without needing source-code detection. EXCLUDED_MOUNT_ITEMS
+        // (node_modules) stays excluded at both targets; MOUNT_NULL_ITEMS
+        // shadows (package.json → empty JSON, etc.) and PLAYWRIGHT_CONFIG_FILES
+        // shadows (minimal config) are applied at both targets too so the
+        // protections survive regardless of which path the test resolves to.
         const workspaceFiles = fs.readdirSync(workspacePath);
         const filesToMount = workspaceFiles.filter((file) => !EXCLUDED_MOUNT_ITEMS.includes(file) && !MOUNT_NULL_ITEMS.includes(file));
-        hostConfig.Mounts?.push(...filesToMount.map((file) => ({
-            Type: "bind",
-            Target: path.join(containerMountPath, file),
-            Source: path.join(workspacePath, file),
-        })));
+        // Single Set tracks every mount target we've added so far. Used to dedupe
+        // both the workspace-mirror push (when workspacePath happens to equal
+        // containerMountPath) and the session-file push below.
+        const mountedPaths = new Set();
+        const pushMount = (mount) => {
+            if (mountedPaths.has(mount.Target))
+                return;
+            mountedPaths.add(mount.Target);
+            hostConfig.Mounts.push(mount);
+        };
+        const mirrorAtHostPath = workspacePath !== containerMountPath;
+        for (const file of filesToMount) {
+            const source = path.join(workspacePath, file);
+            pushMount({
+                Type: "bind",
+                Target: path.join(containerMountPath, file),
+                Source: source,
+            });
+            if (mirrorAtHostPath) {
+                pushMount({ Type: "bind", Target: source, Source: source });
+            }
+        }
         // Mount MOUNT_NULL_ITEMS (found recursively) to /dev/null (or empty JSON for .json files)
         const nullPaths = findExcludedPaths(workspacePath, MOUNT_NULL_ITEMS);
         for (const absolutePath of nullPaths) {
-            const target = path.join(containerMountPath, path.relative(workspacePath, absolutePath));
+            const rel = path.relative(workspacePath, absolutePath);
             const source = absolutePath.endsWith(".json") ? EMPTY_JSON_PATH : "/dev/null";
-            hostConfig.Mounts?.push({
+            pushMount({
                 Type: "bind",
                 Source: source,
-                Target: target,
+                Target: path.join(containerMountPath, rel),
             });
+            if (mirrorAtHostPath) {
+                pushMount({ Type: "bind", Source: source, Target: absolutePath });
+            }
         }
         // Mount Playwright config files with minimal config (shadows repo configs that may
         // import dotenv or other dependencies not available in the executor container)
         const playwrightConfigPaths = findExcludedPaths(workspacePath, PLAYWRIGHT_CONFIG_FILES);
         for (const absolutePath of playwrightConfigPaths) {
-            const target = path.join(containerMountPath, path.relative(workspacePath, absolutePath));
-            hostConfig.Mounts?.push({
+            const rel = path.relative(workspacePath, absolutePath);
+            pushMount({
                 Type: "bind",
                 Source: MINIMAL_PLAYWRIGHT_CONFIG_PATH,
-                Target: target,
+                Target: path.join(containerMountPath, rel),
             });
+            if (mirrorAtHostPath) {
+                pushMount({
+                    Type: "bind",
+                    Source: MINIMAL_PLAYWRIGHT_CONFIG_PATH,
+                    Target: absolutePath,
+                });
+            }
         }
-        // Detect and mount session files
+        // Detect and mount session files referenced outside the workspace
+        // (anything inside the workspace is already covered by the dual mount
+        // above; the session-file loop is the safety net for tests that point
+        // at a session in some other directory).
         const sessionFiles = detectSessionFiles(options.testFile);
-        const mountedPaths = new Set(); // Track mounted file paths to prevent duplicates
         for (const sessionFile of sessionFiles) {
             let sessionFileSource;
             let sessionFileTarget;

package/build/services/TestExecutionService.test.js

@@ -142,6 +142,49 @@ describe("buildContainerEnv", () => {
         expect(env).toContain("API_KEY=my-key");
     });
 });
+describe("detectSessionFiles", () => {
+    // Import after mocks are set up so the fs mock applies
+    let detectSessionFiles;
+    let mockReadFileSync;
+    beforeAll(async () => {
+        const mod = await import("./TestExecutionService.js");
+        detectSessionFiles = mod.detectSessionFiles;
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        mockReadFileSync = require("fs").readFileSync;
+    });
+    it("detects string-literal storageState (TS/JS)", () => {
+        mockReadFileSync.mockReturnValueOnce(`test.use({ storageState: '/abs/path/session.json' });`);
+        expect(detectSessionFiles("/ws/test.spec.ts")).toEqual([
+            "/abs/path/session.json",
+        ]);
+    });
+    it("detects skyramp codegen path.join(__dirname, '<file>') pattern and resolves to host-absolute path", () => {
+        // Reproduces SKYR-3321 generated test shape — must resolve to the host
+        // absolute path so the executor's absolute-path mount branch makes the
+        // file visible at that same path inside the container.
+        mockReadFileSync.mockReturnValueOnce(`
+import path from 'path';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SESSION_STORAGE = path.join(__dirname, 'skyramp_session_storage.json');
+test.use({ storageState: SESSION_STORAGE });
+`);
+        expect(detectSessionFiles("/Users/pedro/projects/cisco-xdr-tests/xdr_dashboard.spec.ts")).toEqual([
+            "/Users/pedro/projects/cisco-xdr-tests/skyramp_session_storage.json",
+        ]);
+    });
+    it("detects inline storageState: path.join(__dirname, '<file>')", () => {
+        mockReadFileSync.mockReturnValueOnce(`test.use({ storageState: path.join(__dirname, 'session.json') });`);
+        expect(detectSessionFiles("/ws/spec.ts")).toEqual(["/ws/session.json"]);
+    });
+    it("ignores storageState references inside comments", () => {
+        mockReadFileSync.mockReturnValueOnce(`
+// storageState: '/should/not/match.json'
+// path.join(__dirname, 'also-not.json')
+test('x', () => {});
+`);
+        expect(detectSessionFiles("/ws/spec.ts")).toEqual([]);
+    });
+});
 describe("TestExecutionService.executeTest - Docker env forwarding", () => {
     // Import after mocks are set up
     let TestExecutionService;
@@ -210,4 +253,66 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
             e.startsWith("SKYRAMP_TEST_SERVICE_URL_"));
         expect(envWithBaseUrl).toHaveLength(0);
     });
+    // Approach B: every workspace mount is mirrored at the host-absolute path so
+    // tests that embed absolute references (storageState, fixtures, snapshots)
+    // resolve correctly inside the executor regardless of which path-shape the
+    // codegen happens to emit.
+    it("mirrors each workspace file mount at both /home/user/<f> and the host-absolute path", async () => {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require("fs");
+        fs.readdirSync.mockImplementation((_path, options) => {
+            if (options?.withFileTypes) {
+                return [
+                    { name: "xdr_dashboard.spec.ts", isFile: () => true, isDirectory: () => false },
+                    { name: "skyramp_session_storage.json", isFile: () => true, isDirectory: () => false },
+                ];
+            }
+            return ["xdr_dashboard.spec.ts", "skyramp_session_storage.json"];
+        });
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/Users/pedro/projects/cisco-xdr-tests/xdr_dashboard.spec.ts",
+            workspacePath: "/Users/pedro/projects/cisco-xdr-tests",
+            language: "typescript",
+            testType: "ui",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        const targets = dockerOptions.HostConfig.Mounts.map((m) => m.Target);
+        // Canonical /home/user mount
+        expect(targets).toContain("/home/user/xdr_dashboard.spec.ts");
+        expect(targets).toContain("/home/user/skyramp_session_storage.json");
+        // Host-absolute mirror — the fix for absolute paths leaking out of `__dirname`
+        expect(targets).toContain("/Users/pedro/projects/cisco-xdr-tests/xdr_dashboard.spec.ts");
+        expect(targets).toContain("/Users/pedro/projects/cisco-xdr-tests/skyramp_session_storage.json");
+    });
+    it("does not double-mount when workspacePath equals /home/user", async () => {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require("fs");
+        fs.readdirSync.mockImplementation((_path, options) => {
+            if (options?.withFileTypes) {
+                return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
+            }
+            return ["test_file.py"];
+        });
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/home/user/test_file.py",
+            workspacePath: "/home/user",
+            language: "python",
+            testType: "smoke",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        const targetCounts = {};
+        for (const m of dockerOptions.HostConfig.Mounts) {
+            targetCounts[m.Target] = (targetCounts[m.Target] ?? 0) + 1;
+        }
+        // No mount target should appear twice (no host-absolute mirror when workspace == /home/user)
+        for (const [t, n] of Object.entries(targetCounts)) {
+            expect({ target: t, count: n }).toEqual({ target: t, count: 1 });
+        }
+    });
 });

package/build/services/TestGenerationService.js

@@ -8,7 +8,8 @@ import { getEntryPoint } from "../utils/telemetry.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
 import { logger } from "../utils/logger.js";
 import { normalizeLanguageParams } from "../utils/normalizeParams.js";
-import { stageGeneratedPaths } from "../utils/gitStaging.js";
+import { stageGeneratedPaths, resolveOutputDir } from "../utils/gitStaging.js";
+import { getTestsRepoDir } from "../utils/AnalysisStateManager.js";
 export class TestGenerationService {
     client;
     constructor() {
@@ -18,6 +19,15 @@ export class TestGenerationService {
         try {
             // Normalize language/framework to handle LLM case variations
             normalizeLanguageParams(params);
+            // In cross-repo mode, redirect outputDir to the test repo clone.
+            const resolved = resolveOutputDir(params.outputDir, getTestsRepoDir());
+            if (resolved !== params.outputDir) {
+                logger.info("Cross-repo: redirecting outputDir to test repo", {
+                    original: params.outputDir,
+                    redirected: resolved,
+                });
+                params.outputDir = resolved;
+            }
             // Log prompt parameter using reusable utility
             logger.info("Generating test", {
                 prompt: params.prompt,

package/build/tools/executeSkyrampTestTool.js

@@ -147,16 +147,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                     if (stateData && stateData.existingTests) {
                         const testIndex = stateData.existingTests.findIndex((t) => t.testFile === params.testFile);
                         if (testIndex >= 0) {
-                            stateData.existingTests[testIndex].execution = {
-                                passed: result.passed,
-                                duration: result.duration || 0,
-                                errors: result.errors || [],
-                                warnings: result.warnings || [],
-                                crashed: result.crashed || false,
-                                stdout: result.output || "",
-                                stderr: result.errors?.join("\n") || "",
-                                executionTimestamp: new Date().toISOString(),
-                            };
+                            stateData.existingTests[testIndex].execution = result;
                             await stateManager.writeData(stateData);
                             logger.info(`Updated stateFile with execution results for ${params.testFile}`);
                         }

package/build/tools/generate-tests/generateBatchScenarioRestTool.js

@@ -48,10 +48,22 @@ export const stepSchema = z.object({
         .string()
         .optional()
         .refine(isJsonObject, { message: "queryParams must be a JSON object string (e.g. '{\"limit\":\"10\"}')." })
-        .describe("JSON string of URL query parameters (e.g., '{\"q\": \"bear\", \"limit\": 10}'). "
-        + "Use this for GET request filters, search terms, pagination, sorting — any parameter that belongs in the URL query string. "
-        + "CRITICAL: For search/filter/list endpoints (e.g., GET /products/search?q=bear&limit=10), parameters MUST go here, NOT in requestBody. "
-        + "GET request bodies are non-standard and may be ignored or rejected by servers and frameworks, so always encode these parameters in the URL query string instead of the request body."),
+        .describe(`JSON string of URL query parameters. Provide a FLAT object where each key is the exact URL parameter name and each value is a string or number (single value per key).
+
+<examples>
+  <example label="simple params">{"q": "bear", "limit": 10}</example>
+  <example label="bracket-notation keys">{"filter[title][_neq]": "not-a-number"}</example>
+  <example label="multi-value as comma-separated">{"tags": "sale,new,featured"}</example>
+  <example label="JSON-encoded string value">{"filter": "{\\\"status\\\":\\\"active\\\"}"}</example>
+</examples>
+
+For multi-value params (e.g. ?tags=sale,new), provide a comma-separated string: "tags": "sale,new". Arrays are accepted but will be comma-joined into one value — note this produces a single ?tags=sale,new param, not repeated ?tags=sale&tags=new keys.
+
+If you provide nested objects, the service JSON-stringifies them as a fallback, but you should inspect the target API source to determine the correct key format and use that directly.
+
+Use this for GET request filters, search terms, pagination, sorting — any parameter that belongs in the URL query string.
+
+CRITICAL: For search/filter/list endpoints (e.g., GET /products/search?q=bear&limit=10), parameters MUST go here, NOT in requestBody. GET request bodies are non-standard and may be ignored or rejected by servers and frameworks.`),
     responseBody: z
         .string()
         .optional()

package/build/tools/generate-tests/generateIntegrationRestTool.js

@@ -28,6 +28,8 @@ const integrationTestSchema = z
         "When provided, DO NOT also pass apiSchema or endpointURL — the scenario file already contains all endpoint information."),
     ...codeRefactoringSchema.shape,
     ...baseTestSchema,
+    apiSchema: baseTestSchema.apiSchema.describe("MUST be absolute path(/path/to/openapi.json) to the OpenAPI/Swagger schema file or a URL to the OpenAPI/Swagger schema file(e.g. https://demoshop.skyramp.dev/openapi.json). DO NOT TRY TO ASSUME THE OPENAPI SCHEMA IF NOT PROVIDED. NOTE TO AI ASSISTANTS: You do not need to read the contents of this file - simply pass the file path as the backend will read and process it. " +
+        "When an OpenAPI schema is provided, this tool automatically derives a CRUD scenario flow (Create → Read → Update → Delete) directly from the schema."),
     output: baseTestSchema.output.describe("Name of the output test file. " +
         "When scenarioFile is provided and user did not specify a name, derive it: " +
         "strip the path and 'scenario_' prefix, replace hyphens/non-alphanum with underscores, append '_integration_test' + language extension. " +

package/build/tools/generate-tests/generateUIRestTool.js

@@ -96,6 +96,8 @@ This tells you exactly which frontend files changed so you record traces for the
 
 **Typical pipeline:** Use the \`browser_*\` tools (\`browser_navigate\`, \`browser_click\`, \`browser_type\`, etc.) to record user interactions, then call \`skyramp_export_zip\` to export a trace zip, then pass the absolute path to that zip as \`playwrightInput\` here.
 
+**DOM Analyzer tools for blueprint-aware recording:** alongside the basic \`browser_*\` interaction tools, the Skyramp MCP exposes \`browser_blueprint\` (canonical PageBlueprint capture), \`browser_blueprint_diff\` (structured before/after delta), \`browser_widget_contract_lookup\` (interaction recipe for custom widgets by fingerprint), and the sitemap tools \`browser_sitemap_build\` / \`browser_sitemap_query\`. These enable semantic target selection and delta-derived assertions: capture a blueprint before each meaningful action, perform the action, then capture again — the diff between the two grounds your assertions in observable state changes rather than author guesses about what "success" looks like.
+
 **CRITICAL: Do NOT use skyramp_start_trace_collection/skyramp_stop_trace_collection for UI test recording — use browser_* tools + skyramp_export_zip instead.**`,
         inputSchema: uiTestSchema,
         _meta: {