@skyramp/mcp 0.2.8 → 0.2.150-rc.ldw

package/build/services/TestExecutionService.js

@@ -9,10 +9,10 @@ import { logger } from "../utils/logger.js";
 import { TestExecutionStatus, } from "../types/TestExecution.js";
 import { TestType } from "../types/TestTypes.js";
 import { buildContainerEnv } from "./containerEnv.js";
-import { SKYRAMP_IMAGE_VERSION } from "../utils/versions.js";
+import { EXECUTOR_DOCKER_IMAGE } from "../utils/versions.js";
+export { EXECUTOR_DOCKER_IMAGE };
 const DEFAULT_TIMEOUT = 300000; // 5 minutes
 const MAX_CONCURRENT_EXECUTIONS = 5;
-export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 const DOCKER_PLATFORM = "linux/amd64";
 const EXECUTION_PROGRESS_INTERVAL = 10000; // 10 seconds between progress updates during execution
 // Temp file with valid empty JSON — used instead of /dev/null for .json config files
@@ -84,14 +84,14 @@ function setupVideoCapture(options, workspacePath, containerMountPath) {
     };
     if (!browserTest)
         return setup;
-    // Per-execution video output directory on host (cleared so a retry never
-    // reports a stale recording from a prior run).
-    const videoSubdir = getVideoSubdir(options.testFile);
+    // Each execution gets a unique video directory so there is nothing to clean up
+    // between runs. Avoids EACCES when the Docker executor (which runs as root) has
+    // left root-owned files in a previous run's directory. The timestamp keeps the
+    // name readable/ordered; the random suffix guarantees uniqueness even when two
+    // executions land in the same millisecond (retries, parallel runs).
+    const videoSubdir = `${getVideoSubdir(options.testFile)}-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
     setup.videoHostDir = path.join(workspacePath, ".skyramp", "videos", videoSubdir);
     setup.videoContainerDir = path.join(containerMountPath, ".skyramp", "videos", videoSubdir);
-    if (fs.existsSync(setup.videoHostDir)) {
-        fs.rmSync(setup.videoHostDir, { recursive: true, force: true });
-    }
     fs.mkdirSync(setup.videoHostDir, { recursive: true });
     // TypeScript/JavaScript: generate a per-execution Playwright config with video.
     if (options.language === "typescript" || options.language === "javascript") {
@@ -440,7 +440,7 @@ export class TestExecutionService {
         try {
             fs.accessSync(workspacePath, fs.constants.R_OK);
         }
-        catch (err) {
+        catch {
             throw new Error(`Workspace path does not exist or is not readable: ${workspacePath}`);
         }
         // Validate test file - use basename for safer filename extraction
@@ -470,10 +470,15 @@ export class TestExecutionService {
             testFilePath,
             options.testType,
         ];
+        const networkMode = options.dockerNetwork?.trim()
+            ? options.dockerNetwork.trim()
+            : options.useHostNetwork && process.platform === "linux"
+                ? "host"
+                : undefined;
         // Prepare host config with mounts
         const hostConfig = {
             ExtraHosts: ["host.docker.internal:host-gateway"],
-            ...(options.useHostNetwork && process.platform === "linux" ? { NetworkMode: "host" } : {}),
+            ...(networkMode ? { NetworkMode: networkMode } : {}),
             Mounts: [
                 {
                     Type: "bind",

package/build/services/TestExecutionService.test.js

@@ -303,6 +303,23 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         delete process.env.SKYRAMP_TEST_SERVICE_URL_BACKEND;
         delete process.env.SKYRAMP_TEST_SERVICE_URL_FRONTEND;
     });
+    it.each(["python", "typescript", "javascript", "java"])("passes %s integration tests through to runner.sh", async (language) => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: `/workspace/${language}_integration_test.txt`,
+            workspacePath: "/workspace",
+            language,
+            testType: "integration",
+        });
+        const command = mockRun.mock.calls[0][1];
+        expect(command[0]).toBe("/root/runner.sh");
+        expect(command[1]).toBe(language);
+        expect(command[2]).toBe(`/home/user/${language}_integration_test.txt`);
+        expect(command[3]).toBe("integration");
+        mockRun.mockClear();
+    });
     it("passes SKYRAMP_TEST_BASE_URL to Docker container Env", async () => {
         process.env.SKYRAMP_TEST_BASE_URL = "http://external-host:8000";
         const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
@@ -349,6 +366,22 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
             e.startsWith("SKYRAMP_TEST_SERVICE_URL_"));
         expect(envWithBaseUrl).toHaveLength(0);
     });
+    it("attaches executor to dockerNetwork without treating it as host networking", async () => {
+        process.env.SKYRAMP_TEST_BASE_URL = "http://localhost:3000";
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+            dockerNetwork: "checkr-demo_checkr_default",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        expect(dockerOptions.HostConfig.NetworkMode).toBe("checkr-demo_checkr_default");
+        expect(dockerOptions.Env).toContain("SKYRAMP_TEST_BASE_URL=http://host.docker.internal:3000");
+    });
     // 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
@@ -408,6 +441,44 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         }
     });
 });
+describe("TestExecutionService.executeBatch", () => {
+    let TestExecutionService;
+    beforeAll(async () => {
+        const mod = await import("./TestExecutionService.js");
+        TestExecutionService = mod.TestExecutionService;
+    });
+    it("executes tests in parallel batches", async () => {
+        const service = new TestExecutionService();
+        const order = [];
+        let resolveFirst;
+        jest.spyOn(service, "executeTest").mockImplementation(async (options) => {
+            order.push(`start:${options.testFile}`);
+            if (options.testFile === "one.py") {
+                await new Promise((resolve) => {
+                    resolveFirst = resolve;
+                });
+            }
+            order.push(`end:${options.testFile}`);
+            return {
+                testFile: options.testFile,
+                status: "pass",
+                executedAt: new Date().toISOString(),
+                duration: 1,
+                errors: [],
+                warnings: [],
+            };
+        });
+        const batchPromise = service.executeBatch([
+            { testFile: "one.py", workspacePath: "/workspace", language: "python", testType: "smoke" },
+            { testFile: "two.py", workspacePath: "/workspace", language: "python", testType: "smoke" },
+        ]);
+        await Promise.resolve();
+        expect(order).toEqual(["start:one.py", "start:two.py", "end:two.py"]);
+        resolveFirst?.();
+        await batchPromise;
+        expect(order).toEqual(["start:one.py", "start:two.py", "end:two.py", "end:one.py"]);
+    });
+});
 describe("TestExecutionService.executeTest - Video capture for browser tests", () => {
     let TestExecutionService;
     let getVideoSubdir;
@@ -521,7 +592,10 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
         });
         const dockerOptions = mockRun.mock.calls[0][3];
         const videoSubdir = getVideoSubdir("/workspace/tests/login.spec.ts");
-        const videoMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === `/home/user/.skyramp/videos/${videoSubdir}`);
+        // Each execution gets a unique per-run dir: `${videoSubdir}-<timestamp>`,
+        // so match by prefix rather than exact equality.
+        const videoMountPrefix = `/home/user/.skyramp/videos/${videoSubdir}`;
+        const videoMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target.startsWith(videoMountPrefix));
         expect(videoMount).toBeDefined();
         expect(videoMount.Type).toBe("bind");
         expect(videoMount.ReadOnly).toBe(false);

package/build/services/TestGenerationService.d.ts

@@ -1,6 +1,6 @@
 import { SkyrampClient } from "@skyramp/skyramp";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { TestType } from "../types/TestTypes.js";
+import { TestType, MOCK_TYPE } from "../types/TestTypes.js";
 export interface BaseTestParams {
     endpointURL?: string;
     method?: string;
@@ -42,7 +42,7 @@ export declare abstract class TestGenerationService {
     generateTest(params: BaseTestParams & Record<string, any>): Promise<CallToolResult>;
     protected validateInputs(params: BaseTestParams): CallToolResult;
     protected abstract buildGenerationOptions(params: BaseTestParams & Record<string, any>): any;
-    protected abstract getTestType(): TestType;
+    protected abstract getTestType(): TestType | typeof MOCK_TYPE;
     protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
     private static readonly STANDARD_HEADERS;
     private static simpleWildcardMatch;

package/build/tool-phases.js

@@ -10,6 +10,9 @@ export const TOOL_PHASE_MAP = {
     skyramp_ui_test_generation: "generating",
     skyramp_batch_scenario_test_generation: "generating",
     skyramp_mock_generation: "generating",
+    skyramp_batch_mock_generation: "generating",
+    skyramp_generate_enriched_integration_test: "generating",
+    skyramp_enrich_test_with_mocks: "generating",
     skyramp_execute_test: { before: "maintaining", after: "executing" },
     skyramp_analyze_test_health: "maintaining",
     skyramp_submit_report: "reporting",
@@ -36,4 +39,5 @@ export const TOOLS_WITHOUT_PHASE = new Set([
     "skyramp_modularization",
     "skyramp_reuse_code",
     "skyramp_enhance_assertions",
+    "skyramp_preflight_mock_check",
 ]);

package/build/tools/code-refactor/enhanceAssertionsTool.js

@@ -12,6 +12,37 @@ const TESTBOT_UI_CHECKS = `
 - If no suitable selector exists in the generated file for an assertion you need to add, go back and call \`browser_assert\` on the live page to record it with a valid selector, then re-export and regenerate.
 - **After executing a UI test that documents a bug from \`issuesFound\`**: if it passed when you expected it to fail, the assertions are too weak — add a stronger \`expect()\` that directly targets the buggy behavior. This counts as the single allowed retry under the 2-attempt cap — do NOT re-run more than once.
 `;
+function buildAssertionInstructions(testFile, testType, enhanceType) {
+    if (testType === TestType.UI) {
+        let instructions = getUIAssertionsPrompt(testFile, enhanceType);
+        if (isTestbotEnabled()) {
+            instructions += TESTBOT_UI_CHECKS;
+        }
+        return instructions;
+    }
+    if (testType === TestType.CONTRACT) {
+        return getContractProviderAssertionsPrompt(testFile, enhanceType);
+    }
+    if (testType === TestType.INTEGRATION) {
+        return getIntegrationAssertionsPrompt(testFile, enhanceType);
+    }
+    throw new Error(`Unsupported testType for ${TOOL_NAME}: ${testType}`);
+}
+function buildAutoApplyInstructions(testFile, testType, enhanceType) {
+    const typeSpecificInstructions = buildAssertionInstructions(testFile, testType, enhanceType);
+    return [
+        `Enhance response body assertions in: \`${testFile}\``,
+        `Test type: ${testType} | Context: ${enhanceType}`,
+        ``,
+        `Read the file, apply the type-specific assertion guidance below, and write the file back directly.`,
+        `Add assertions after each send_request/sendRequest status-code assertion.`,
+        `Use SDK helper: Python \`skyramp.get_response_value(response, "json.path")\`, JS \`getValue(response, "json.path")\`.`,
+        `Do NOT restructure, reformat, add comments, or change imports. Only add assertion lines.`,
+        ``,
+        `Type-specific assertion guidance:`,
+        typeSpecificInstructions,
+    ].join("\n");
+}
 const enhanceAssertionsSchema = {
     testFile: z
         .string()
@@ -24,6 +55,12 @@ const enhanceAssertionsSchema = {
         .describe("The context of the enhancement. " +
         "Use 'generation' after generating a new test file (applies to every test function). " +
         "Use 'maintenance' during drift UPDATE (applies only to new or diff-affected functions)."),
+    autoApply: z
+        .boolean()
+        .default(false)
+        .describe("When true, returns a compact instruction set (10 lines) that tells the agent to " +
+        "read the test file, enhance assertions per standard rules, and write it back directly. " +
+        "When false (default), returns the full verbose instruction set."),
 };
 export function registerEnhanceAssertionsTool(server) {
     server.registerTool(TOOL_NAME, {
@@ -34,26 +71,13 @@ export function registerEnhanceAssertionsTool(server) {
 - After updating an existing supported test file during maintenance`,
         inputSchema: enhanceAssertionsSchema,
     }, async (params) => {
-        const { testFile, testType, enhanceType } = params;
+        const { testFile, testType, enhanceType, autoApply } = params;
         // Stage so testbot includes the generated files in its output commit.
         await stageGeneratedPaths(testFile);
         const enhanceCtx = enhanceType;
-        let instructions;
-        if (testType === TestType.UI) {
-            instructions = getUIAssertionsPrompt(testFile, enhanceCtx);
-            if (isTestbotEnabled()) {
-                instructions += TESTBOT_UI_CHECKS;
-            }
-        }
-        else if (testType === TestType.CONTRACT) {
-            instructions = getContractProviderAssertionsPrompt(testFile, enhanceCtx);
-        }
-        else if (testType === TestType.INTEGRATION) {
-            instructions = getIntegrationAssertionsPrompt(testFile, enhanceCtx);
-        }
-        else {
-            throw new Error(`Unsupported testType for ${TOOL_NAME}: ${testType}`);
-        }
+        const instructions = autoApply
+            ? buildAutoApplyInstructions(testFile, testType, enhanceCtx)
+            : buildAssertionInstructions(testFile, testType, enhanceCtx);
         const result = {
             content: [
                 {
@@ -63,7 +87,12 @@ export function registerEnhanceAssertionsTool(server) {
             ],
             isError: false,
         };
-        AnalyticsService.pushMCPToolEvent(TOOL_NAME, undefined, params).catch(() => { });
+        AnalyticsService.pushMCPToolEvent(TOOL_NAME, undefined, {
+            testFile: params.testFile,
+            testType: params.testType,
+            enhanceType: params.enhanceType,
+            autoApply: params.autoApply,
+        }).catch(() => { });
         return result;
     });
 }

package/build/tools/enrichTestWithMocksTool.d.ts

@@ -0,0 +1,28 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
+/**
+ * skyramp_enrich_test_with_mocks
+ *
+ * Injects mock imports and apply_mock() calls into a generated test file.
+ * The mock files are generated by skyramp_mock_generation — this tool wires
+ * them into the test so the mocks are applied before the test runs.
+ *
+ * No data duplication — the test imports from the generated mock files.
+ */
+export declare function registerEnrichTestWithMocksTool(server: McpServer): void;
+declare function injectMockImports(original: string, testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage): string;
+declare function isSupportedMockEnrichmentLanguage(language: ProgrammingLanguage | string): language is ProgrammingLanguage;
+type MockEntry = {
+    serviceName: string;
+    moduleName: string;
+    relativePath: string;
+    importPath: string;
+    importLabel: string;
+    mockFile: string;
+    className: string;
+    classReference: string;
+    targetUrl?: string;
+    protocol: MockProtocol;
+};
+declare function buildMockImportBlock(testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage, mockEntries?: MockEntry[]): string;
+export { injectMockImports, buildMockImportBlock, isSupportedMockEnrichmentLanguage };