@skyramp/mcp 0.2.8 → 0.2.150-rc.local.de

package/build/services/TestExecutionService.test.js

@@ -1,22 +1,41 @@
 // @ts-nocheck - Jest ESM type inference issues
 import { jest } from "@jest/globals";
-import { buildContainerEnv, rewriteLocalhostForDocker } from "./containerEnv.js";
+import { buildContainerEnv, rewriteLocalhostForDocker, } from "./containerEnv.js";
 // Mock dockerode before importing TestExecutionService
 const mockRun = jest.fn();
 const mockListImages = jest.fn();
+const mockListContainers = jest.fn();
+const mockGetContainer = jest.fn();
 jest.unstable_mockModule("dockerode", () => ({
     default: jest.fn().mockImplementation(() => ({
         run: mockRun,
         listImages: mockListImages,
+        listContainers: mockListContainers,
+        getContainer: mockGetContainer,
     })),
 }));
+const mockExec = jest.fn((_command, _options, callback) => {
+    callback(null);
+    return { pid: 123 };
+});
+jest.unstable_mockModule("child_process", () => ({
+    exec: mockExec,
+}));
 // Get actual fs for spreading, then mock specific methods
 const actualFs = await import("fs");
 const mockAccessSync = jest.fn();
 const mockExistsSync = jest.fn().mockReturnValue(true);
-const mockReaddirSync = jest.fn().mockImplementation((_path, options) => {
+const mockReaddirSync = jest
+    .fn()
+    .mockImplementation((_path, options) => {
     if (options?.withFileTypes) {
-        return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
+        return [
+            {
+                name: "test_file.py",
+                isFile: () => true,
+                isDirectory: () => false,
+            },
+        ];
     }
     return ["test_file.py"];
 });
@@ -45,6 +64,10 @@ jest.unstable_mockModule("fs", () => ({
     mkdirSync: mockMkdirSync,
     rmSync: mockRmSync,
 }));
+const mockReadWorkspaceConfigRaw = jest.fn();
+jest.unstable_mockModule("../utils/workspaceAuth.js", () => ({
+    readWorkspaceConfigRaw: mockReadWorkspaceConfigRaw,
+}));
 // Mock logger
 jest.unstable_mockModule("../utils/logger.js", () => ({
     logger: {
@@ -293,9 +316,12 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
     beforeEach(() => {
         jest.clearAllMocks();
         // Simulate image already cached
-        mockListImages.mockResolvedValue([
-            { RepoTags: [EXECUTOR_DOCKER_IMAGE] },
-        ]);
+        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
+        mockListContainers.mockResolvedValue([]);
+        mockGetContainer.mockReturnValue({
+            remove: jest.fn().mockResolvedValue(undefined),
+        });
+        mockReadWorkspaceConfigRaw.mockResolvedValue(null);
     });
     afterEach(() => {
         // Clean up env vars we set during tests
@@ -318,6 +344,21 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         const dockerOptions = mockRun.mock.calls[0][3];
         expect(dockerOptions.Env).toContain("SKYRAMP_TEST_BASE_URL=http://external-host:8000");
     });
+    it("labels executor containers as owned by this tool", async () => {
+        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",
+        });
+        const dockerOptions = mockRun.mock.calls[0][3];
+        expect(dockerOptions.Labels).toEqual({
+            "dev.skyramp.mcp.execution": "true",
+        });
+    });
     it("passes multiple SKYRAMP_TEST_SERVICE_URL_* to Docker container Env", async () => {
         process.env.SKYRAMP_TEST_SERVICE_URL_BACKEND = "http://host1:8000";
         process.env.SKYRAMP_TEST_SERVICE_URL_FRONTEND = "http://host2:5173";
@@ -349,6 +390,52 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
             e.startsWith("SKYRAMP_TEST_SERVICE_URL_"));
         expect(envWithBaseUrl).toHaveLength(0);
     });
+    it("removes only stopped execution containers owned by this tool", async () => {
+        const removeOwned = jest.fn().mockResolvedValue(undefined);
+        const removeUnowned = jest.fn().mockResolvedValue(undefined);
+        mockListContainers.mockResolvedValue([
+            {
+                Id: "owned-stopped-1",
+                Image: EXECUTOR_DOCKER_IMAGE,
+                Names: ["/skyramp_executor_1"],
+                State: "exited",
+                Labels: { "dev.skyramp.mcp.execution": "true" },
+            },
+            {
+                Id: "owned-running-1",
+                Image: EXECUTOR_DOCKER_IMAGE,
+                Names: ["/skyramp_executor_2"],
+                State: "running",
+                Labels: { "dev.skyramp.mcp.execution": "true" },
+            },
+            {
+                Id: "unowned-worker-1",
+                Image: "skyramp/worker:local-mockfix",
+                Names: ["/skyramp_worker"],
+                State: "exited",
+            },
+            { Id: "postgres-1", Image: "postgres:15-alpine", Names: ["/db"] },
+        ]);
+        mockGetContainer.mockImplementation((id) => ({
+            remove: id === "owned-stopped-1" ? removeOwned : removeUnowned,
+        }));
+        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",
+        });
+        expect(mockGetContainer).toHaveBeenCalledWith("owned-stopped-1");
+        expect(mockGetContainer).not.toHaveBeenCalledWith("owned-running-1");
+        expect(mockGetContainer).not.toHaveBeenCalledWith("unowned-worker-1");
+        expect(mockGetContainer).not.toHaveBeenCalledWith("postgres-1");
+        expect(removeOwned).toHaveBeenCalledWith();
+        expect(removeUnowned).not.toHaveBeenCalled();
+        expect(mockRun).toHaveBeenCalledTimes(1);
+    });
     // 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
@@ -357,8 +444,16 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         mockReaddirSync.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 },
+                    {
+                        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"];
@@ -384,7 +479,13 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
     it("does not double-mount when workspacePath equals /home/user", async () => {
         mockReaddirSync.mockImplementation((_path, options) => {
             if (options?.withFileTypes) {
-                return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
+                return [
+                    {
+                        name: "test_file.py",
+                        isFile: () => true,
+                        isDirectory: () => false,
+                    },
+                ];
             }
             return ["test_file.py"];
         });
@@ -408,6 +509,304 @@ 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 serially", async () => {
+        const service = new TestExecutionService();
+        const order = [];
+        jest.spyOn(service, "executeTest").mockImplementation(async (options) => {
+            order.push(`start:${options.testFile}`);
+            await Promise.resolve();
+            order.push(`end:${options.testFile}`);
+            return {
+                testFile: options.testFile,
+                status: "pass",
+                executedAt: new Date().toISOString(),
+                duration: 1,
+                errors: [],
+                warnings: [],
+            };
+        });
+        await service.executeBatch([
+            { testFile: "one.py", workspacePath: "/workspace", language: "python", testType: "smoke" },
+            { testFile: "two.py", workspacePath: "/workspace", language: "python", testType: "smoke" },
+        ]);
+        expect(order).toEqual(["start:one.py", "end:one.py", "start:two.py", "end:two.py"]);
+    });
+});
+describe("TestExecutionService.executeTest - SUT preparation", () => {
+    let TestExecutionService;
+    let EXECUTOR_DOCKER_IMAGE;
+    const originalFetch = global.fetch;
+    beforeAll(async () => {
+        const mod = await import("./TestExecutionService.js");
+        TestExecutionService = mod.TestExecutionService;
+        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        global.fetch = originalFetch;
+        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
+        mockListContainers.mockResolvedValue([]);
+        mockGetContainer.mockReturnValue({
+            remove: jest.fn().mockResolvedValue(undefined),
+        });
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStartCommand: "docker compose up -d app",
+                    },
+                },
+            ],
+        });
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+        global.fetch = originalFetch;
+    });
+    it("runs serverStartCommand before non-contract test execution", async () => {
+        mockExec.mockImplementationOnce((_command, _options, callback) => {
+            callback(new Error("exit 13"));
+            return { pid: 123 };
+        });
+        const service = new TestExecutionService();
+        await expect(service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        })).rejects.toThrow("SUT setup command failed before test execution");
+        expect(mockExec.mock.calls.map(([command]) => command)).toEqual([
+            "docker compose up -d app",
+        ]);
+        expect(mockRun).not.toHaveBeenCalled();
+    });
+    it("rejects non-Docker serverStartCommand for docker runtime services", async () => {
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStartCommand: "node server.js",
+                    },
+                },
+            ],
+        });
+        const service = new TestExecutionService();
+        await expect(service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        })).rejects.toThrow("serverStartCommand must be a Docker command");
+        expect(mockExec).not.toHaveBeenCalled();
+        expect(mockRun).not.toHaveBeenCalled();
+    });
+    it("rejects newline-separated shell commands for docker runtime services", async () => {
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStartCommand: "docker compose up -d app\nnode server.js",
+                    },
+                },
+            ],
+        });
+        const service = new TestExecutionService();
+        await expect(service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        })).rejects.toThrow("serverStartCommand must be a Docker command");
+        expect(mockExec).not.toHaveBeenCalled();
+        expect(mockRun).not.toHaveBeenCalled();
+    });
+    it("probes the service base URL before running the test", async () => {
+        const mockFetch = jest.fn().mockResolvedValue({ ok: true });
+        global.fetch = mockFetch;
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "http://127.0.0.1:8080/health" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                    },
+                },
+            ],
+        });
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        });
+        expect(mockFetch).toHaveBeenCalledWith("http://127.0.0.1:8080/health", expect.objectContaining({ method: "GET" }));
+        expect(mockRun).toHaveBeenCalledTimes(1);
+    });
+    it("runs serverStopCommand after test execution when configured", async () => {
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStartCommand: "docker compose up -d app",
+                        serverStopCommand: "docker compose stop app",
+                    },
+                },
+            ],
+        });
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        });
+        expect(mockExec.mock.calls.map(([command]) => command)).toEqual([
+            "docker compose up -d app",
+            "docker compose stop app",
+        ]);
+        expect(mockRun).toHaveBeenCalledTimes(1);
+    });
+    it("treats serverStopCommand failure as non-fatal after test execution", async () => {
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStartCommand: "docker compose up -d app",
+                        serverStopCommand: "docker compose stop app",
+                    },
+                },
+            ],
+        });
+        mockExec
+            .mockImplementationOnce((_command, _options, callback) => {
+            callback(null);
+            return { pid: 123 };
+        })
+            .mockImplementationOnce((_command, _options, callback) => {
+            callback(new Error("stop failed"));
+            return { pid: 123 };
+        });
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        });
+        expect(mockExec.mock.calls.map(([command]) => command)).toEqual([
+            "docker compose up -d app",
+            "docker compose stop app",
+        ]);
+        expect(mockRun).toHaveBeenCalledTimes(1);
+    });
+    it("does not run serverStopCommand when serverStartCommand is absent", async () => {
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStopCommand: "docker compose stop app",
+                    },
+                },
+            ],
+        });
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        });
+        expect(mockExec).not.toHaveBeenCalled();
+        expect(mockRun).toHaveBeenCalledTimes(1);
+    });
+    it("runs serverStopCommand when readiness probing times out", async () => {
+        jest.useFakeTimers();
+        const mockFetch = jest.fn().mockRejectedValue(new Error("not ready"));
+        global.fetch = mockFetch;
+        mockReadWorkspaceConfigRaw.mockResolvedValue({
+            services: [
+                {
+                    testDirectory: "tests",
+                    language: "python",
+                    api: { baseUrl: "http://127.0.0.1:8080/health" },
+                    runtimeDetails: {
+                        runtime: "docker",
+                        serverStartCommand: "docker compose up -d app",
+                        serverStopCommand: "docker compose stop app",
+                    },
+                },
+            ],
+        });
+        const service = new TestExecutionService();
+        const resultPromise = expect(service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "smoke",
+        })).rejects.toThrow("SUT did not become reachable");
+        await jest.advanceTimersByTimeAsync(16000);
+        await resultPromise;
+        expect(mockExec.mock.calls.map(([command]) => command)).toEqual([
+            "docker compose up -d app",
+            "docker compose stop app",
+        ]);
+        expect(mockRun).not.toHaveBeenCalled();
+    });
+    it("skips serverStartCommand for contract test execution", async () => {
+        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
+        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
+        const service = new TestExecutionService();
+        await service.executeTest({
+            testFile: "/workspace/tests/test_file.py",
+            workspacePath: "/workspace",
+            language: "python",
+            testType: "contract",
+        });
+        expect(mockExec).not.toHaveBeenCalled();
+        expect(mockRun).toHaveBeenCalledTimes(1);
+    });
+});
 describe("TestExecutionService.executeTest - Video capture for browser tests", () => {
     let TestExecutionService;
     let getVideoSubdir;
@@ -421,11 +820,20 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
     beforeEach(() => {
         jest.clearAllMocks();
         mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
+        mockListContainers.mockResolvedValue([]);
+        mockGetContainer.mockReturnValue({
+            remove: jest.fn().mockResolvedValue(undefined),
+        });
+        mockReadWorkspaceConfigRaw.mockResolvedValue(null);
         mockExistsSync.mockReturnValue(true);
         mockReaddirSync.mockImplementation((_path, options) => {
             if (options?.withFileTypes) {
                 return [
-                    { name: "test.spec.ts", isFile: () => true, isDirectory: () => false },
+                    {
+                        name: "test.spec.ts",
+                        isFile: () => true,
+                        isDirectory: () => false,
+                    },
                     { name: "test.py", isFile: () => true, isDirectory: () => false },
                 ];
             }
@@ -457,7 +865,8 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
         mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
         let capturedConfigContent = "";
         mockWriteFileSync.mockImplementation((filePath, content) => {
-            if (filePath.includes("skyramp-playwright-") && filePath.endsWith(".config.ts")) {
+            if (filePath.includes("skyramp-playwright-") &&
+                filePath.endsWith(".config.ts")) {
                 capturedConfigContent = content;
             }
         });
@@ -521,7 +930,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);
@@ -547,7 +959,8 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
         mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
         let usedGeneratedConfig = false;
         mockWriteFileSync.mockImplementation((filePath, content) => {
-            if (filePath.includes("skyramp-playwright-") && content.includes('video: "on"')) {
+            if (filePath.includes("skyramp-playwright-") &&
+                content.includes('video: "on"')) {
                 usedGeneratedConfig = true;
             }
         });
@@ -569,13 +982,25 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
             // Mock video directory scan
             if (dir.includes(".skyramp/videos") && dir.includes(videoSubdir)) {
                 if (options?.withFileTypes) {
-                    return [{ name: "video.webm", isFile: () => true, isDirectory: () => false }];
+                    return [
+                        {
+                            name: "video.webm",
+                            isFile: () => true,
+                            isDirectory: () => false,
+                        },
+                    ];
                 }
                 return ["video.webm"];
             }
             // Default workspace files
             if (options?.withFileTypes) {
-                return [{ name: "test.spec.ts", isFile: () => true, isDirectory: () => false }];
+                return [
+                    {
+                        name: "test.spec.ts",
+                        isFile: () => true,
+                        isDirectory: () => false,
+                    },
+                ];
             }
             return ["test.spec.ts"];
         });
@@ -604,7 +1029,13 @@ describe("TestExecutionService.executeTest - Video capture for browser tests", (
             }
             // Default workspace files
             if (options?.withFileTypes) {
-                return [{ name: "test.spec.ts", isFile: () => true, isDirectory: () => false }];
+                return [
+                    {
+                        name: "test.spec.ts",
+                        isFile: () => true,
+                        isDirectory: () => false,
+                    },
+                ];
             }
             return ["test.spec.ts"];
         });

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

@@ -24,6 +24,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,9 +40,35 @@ 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);
+        if (autoApply) {
+            const compactInstructions = [
+                `Enhance response body assertions in: \`${testFile}\``,
+                `Test type: ${testType} | Context: ${enhanceType}`,
+                ``,
+                `Read the file, add assertions after each send_request/sendRequest status-code assertion, write it back.`,
+                `Use SDK helper: Python \`skyramp.get_response_value(response, "json.path")\`, JS \`getValue(response, "json.path")\`.`,
+                ``,
+                `Rules (apply all that fit):`,
+                `1. Echo-back: assert exact request values returned unchanged (not null-checks)`,
+                `2. Error responses: assert every body field (error code, message, detail)`,
+                `3. Server-generated: assert format (UUID regex, acc_ prefix, ISO timestamp)`,
+                `4. Known values: assert exact enum/status for this flow`,
+                `5. Arrays: assert length, item fields, next-index undefined`,
+                `6. Computed: assert with formula if derivable from request/response`,
+                `7. Chained: use prior response IDs, never hardcode`,
+                ``,
+                `Do NOT restructure, reformat, add comments, or change imports. Only add assertion lines.`,
+            ].join("\n");
+            const result = {
+                content: [{ type: "text", text: compactInstructions }],
+                isError: false,
+            };
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, undefined, { testFile: params.testFile, testType: params.testType, enhanceType: params.enhanceType, autoApply: String(params.autoApply) }).catch(() => { });
+            return result;
+        }
         const enhanceCtx = enhanceType;
         let instructions;
         if (testType === TestType.UI) {
@@ -63,7 +95,7 @@ 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: String(params.autoApply) }).catch(() => { });
         return result;
     });
 }