@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

package/build/services/TestExecutionService.test.js

@@ -408,6 +408,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 +559,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,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;
     });
 }

package/build/tools/enrichTestWithMocksTool.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ProgrammingLanguage } 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 buildMockImportBlock(testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage): string;
+export { injectMockImports, buildMockImportBlock };

package/build/tools/enrichTestWithMocksTool.js

@@ -0,0 +1,413 @@
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+import * as fs from "fs";
+import * as path from "path";
+import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
+const TOOL_NAME = "skyramp_enrich_test_with_mocks";
+const enrichSchema = {
+    testFile: z
+        .string()
+        .describe("Absolute path to the generated test file to enrich (e.g., /repo/tests/skyramp/order_happy_path_integration_test.py)"),
+    scenarioName: z
+        .string()
+        .describe("Human-readable scenario name (e.g., order-happy-path, payment-timeout). Used as the SCENARIO_NAME constant."),
+    mockFiles: z
+        .array(z.string())
+        .describe("Absolute paths to the generated mock files (from skyramp_mock_generation) that this test needs. " +
+        "The tool will inject import statements and apply_mock() calls for each file. " +
+        'Example: ["/repo/tests/skyramp/mocks/validate_POST_mock.py", "/repo/tests/skyramp/mocks/payment_authorizations_POST_mock.py"]'),
+    language: z
+        .nativeEnum(ProgrammingLanguage)
+        .optional()
+        .describe("Programming language of the generated test. Optional for backward compatibility; inferred from testFile when omitted. Mock enrichment currently supports Python tests only."),
+    traceComments: z
+        .array(z.string())
+        .optional()
+        .describe("Optional trace comments showing how mock values flow to assertions (e.g., 'pricing-service returns discount=true → creator sets order.discount_applied=true → assert True')"),
+};
+/**
+ * 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 function registerEnrichTestWithMocksTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: "Enrich a generated INTEGRATION test file by injecting imports from generated mock files. " +
+            "Call this after skyramp_mock_generation and skyramp_integration_test_generation. " +
+            "The tool adds import statements and apply_mock() calls so the test uses the " +
+            "generated mocks directly — no data duplication. " +
+            "NOTE: Do NOT call this for contract tests — consumer contract tests already have mocks wired inline by the generation tool.",
+        inputSchema: enrichSchema,
+    }, async (params) => {
+        try {
+            const { testFile, scenarioName, mockFiles, traceComments, language } = params;
+            if (!fs.existsSync(testFile)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `**Error:** Test file not found: ${testFile}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Validate mock files exist
+            const missingFiles = mockFiles.filter((f) => !fs.existsSync(f));
+            if (missingFiles.length > 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `**Error:** Mock files not found:\n` +
+                                missingFiles.map((f) => `  - ${f}`).join("\n") +
+                                `\n\nGenerate them first with \`skyramp_mock_generation\`.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+            if (resolvedLanguage !== ProgrammingLanguage.PYTHON) {
+                return unsupportedLanguageResult(testFile, resolvedLanguage);
+            }
+            const original = fs.readFileSync(testFile, "utf-8");
+            const enriched = injectMockImports(original, testFile, scenarioName, mockFiles, traceComments, resolvedLanguage);
+            fs.writeFileSync(testFile, enriched);
+            logger.info(`Enriched test file with mock imports: ${testFile}`, {
+                scenarioName,
+                mockFileCount: mockFiles.length,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `**Test enriched with mock imports for scenario "${scenarioName}".**\n`,
+                            `**File:** ${testFile}`,
+                            `**Mock files imported:** ${mockFiles.length}`,
+                            ...mockFiles.map((f) => `  • ${path.basename(f)}`),
+                            `\nThe test now imports and applies mocks from the generated files.`,
+                            "Before execution, stop real services selected for mocking, then execute the test with `skyramp_execute_test`.",
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to enrich test: ${error.message}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Failed to enrich test:** ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function injectMockImports(original, testFile, scenarioName, mockFiles, traceComments, language) {
+    const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+    assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+    const generatedBlock = buildMockImportBlock(testFile, scenarioName, mockFiles, traceComments, resolvedLanguage);
+    const existingBlockRange = findGeneratedMockBlockRange(original);
+    if (existingBlockRange) {
+        const suffix = original.slice(existingBlockRange.end);
+        const separator = suffix.length > 0 && !suffix.startsWith("\n") ? "\n" : "";
+        original =
+            original.slice(0, existingBlockRange.start) +
+                generatedBlock +
+                separator +
+                suffix;
+    }
+    // Find insertion point: after the last import line
+    const lines = original.split("\n");
+    let insertIdx = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("import ") ||
+            line.startsWith("from ") ||
+            line.startsWith("# Import") ||
+            (line === "" &&
+                i > 0 &&
+                (lines[i - 1].trim().startsWith("import") ||
+                    lines[i - 1].trim().startsWith("from")))) {
+            insertIdx = i + 1;
+        }
+    }
+    // If no imports found, insert after initial comments
+    if (insertIdx === 0) {
+        for (let i = 0; i < lines.length; i++) {
+            if (!lines[i].startsWith("#") && lines[i].trim() !== "") {
+                insertIdx = i;
+                break;
+            }
+        }
+    }
+    // Insert the mock block once. If a previous generated block existed, it was
+    // replaced before splitting into lines so stale imports/mappings do not survive.
+    if (!existingBlockRange) {
+        lines.splice(insertIdx, 0, "", generatedBlock, "");
+    }
+    // Wire apply_all_mocks(client) after the generated Skyramp client exists.
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Match Python test function definitions (def test_integration(): or def test_*():)
+        if (/^def test_\w+\(/.test(line.trim())) {
+            const functionEnd = findPythonFunctionEnd(lines, i + 1);
+            const applyCallIndex = lines.findIndex((l, idx) => idx >= i &&
+                idx < functionEnd &&
+                (l.trim() === "apply_all_mocks(client)" ||
+                    l.trim() === "apply_all_mocks()"));
+            if (applyCallIndex !== -1) {
+                // Existing generated tests may already call apply_all_mocks(client).
+            }
+            else {
+                const clientEnd = findSkyrampClientConstructionEnd(lines, i + 1, functionEnd);
+                if (clientEnd !== -1) {
+                    lines.splice(clientEnd + 1, 0, "    apply_all_mocks(client)", "");
+                }
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function resolveMockEnrichmentLanguage(testFile, language) {
+    if (language)
+        return language;
+    const extension = path.extname(testFile).toLowerCase();
+    switch (extension) {
+        case ".py":
+            return ProgrammingLanguage.PYTHON;
+        case ".ts":
+        case ".tsx":
+            return ProgrammingLanguage.TYPESCRIPT;
+        case ".js":
+        case ".jsx":
+            return ProgrammingLanguage.JAVASCRIPT;
+        case ".java":
+            return ProgrammingLanguage.JAVA;
+        default:
+            throw new Error(`Cannot infer mock enrichment language from test file extension: ${testFile}`);
+    }
+}
+function assertSupportedMockEnrichmentLanguage(testFile, language) {
+    if (language === ProgrammingLanguage.PYTHON)
+        return;
+    throw new Error(unsupportedLanguageMessage(testFile, language));
+}
+function unsupportedLanguageMessage(testFile, language) {
+    return `Mock enrichment is currently supported only for Python tests; received language "${language}" for test file "${testFile}".`;
+}
+function unsupportedLanguageResult(testFile, language) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `**Error:** ${unsupportedLanguageMessage(testFile, language)}`,
+            },
+        ],
+        isError: true,
+    };
+}
+function findGeneratedMockBlockRange(source) {
+    const marker = "# ─── Mock Scenario:";
+    const start = source.indexOf(marker);
+    if (start === -1)
+        return null;
+    const segment = source.slice(start);
+    const lines = segment.split("\n");
+    const applyIdx = lines.findIndex((line) => line.trim() === "def apply_all_mocks(client):");
+    if (applyIdx === -1)
+        return null;
+    let endLine = lines.length;
+    for (let i = applyIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === "" || /^\s/.test(line))
+            continue;
+        endLine = i;
+        break;
+    }
+    while (endLine < lines.length) {
+        const line = lines[endLine].trim();
+        if (line === "" || line.startsWith("# Mock trace:")) {
+            endLine += 1;
+            continue;
+        }
+        break;
+    }
+    const replacementText = lines.slice(0, endLine).join("\n");
+    return { start, end: start + replacementText.length };
+}
+function findPythonFunctionEnd(lines, bodyStart) {
+    for (let i = bodyStart; i < lines.length; i++) {
+        if (/^def\s+\w+\(/.test(lines[i]) || /^class\s+\w+/.test(lines[i])) {
+            return i;
+        }
+    }
+    return lines.length;
+}
+function findSkyrampClientConstructionEnd(lines, start, end) {
+    for (let i = start; i < end; i++) {
+        if (!/^\s*client\s*=\s*skyramp\.Client\s*\(/.test(lines[i])) {
+            continue;
+        }
+        let depth = 0;
+        for (let j = i; j < end; j++) {
+            depth += countChar(lines[j], "(") - countChar(lines[j], ")");
+            if (depth <= 0) {
+                return j;
+            }
+        }
+        return i;
+    }
+    return -1;
+}
+function countChar(value, char) {
+    return [...value].filter((current) => current === char).length;
+}
+function buildMockImportBlock(testFile, scenarioName, mockFiles, traceComments, language) {
+    const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+    assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+    const lines = [];
+    const testDir = path.dirname(testFile);
+    lines.push(`# ─── Mock Scenario: ${scenarioName} ──────────────────────────────────────`);
+    lines.push(`SCENARIO_NAME = "${scenarioName}"`);
+    lines.push(``);
+    // Generate path-based mock module loaders so dotted filenames still import correctly.
+    const mockEntries = [];
+    const usedModuleNames = new Set();
+    for (const mockFile of mockFiles) {
+        const relativePath = path.relative(testDir, mockFile).replace(/\\/g, "/");
+        const baseName = path.basename(mockFile, ".py");
+        const moduleName = uniquePythonIdentifier(baseName, usedModuleNames);
+        const serviceName = baseName.replace(/_mock$/, "").replace(/_/g, "-");
+        // Read each mock file once for both URL and protocol extraction.
+        const commandLine = extractMockCommandLine(mockFile);
+        const targetUrl = extractBaseUrlFromCommandLine(commandLine);
+        const protocol = extractProtocolFromCommandLine(commandLine, mockFile);
+        mockEntries.push({
+            serviceName,
+            moduleName,
+            relativePath,
+            targetUrl,
+            protocol,
+        });
+    }
+    lines.push(`import importlib.util`);
+    lines.push(`import os`);
+    lines.push(`from pathlib import Path`);
+    lines.push(``);
+    lines.push(`def _load_mock_factory(relative_path, module_name):`);
+    lines.push(`    mock_path = Path(__file__).parent / relative_path`);
+    lines.push(`    spec = importlib.util.spec_from_file_location(module_name, mock_path)`);
+    lines.push(`    if spec is None or spec.loader is None:`);
+    lines.push(`        raise ImportError(f"Could not load mock module: {mock_path}")`);
+    lines.push(`    module = importlib.util.module_from_spec(spec)`);
+    lines.push(`    spec.loader.exec_module(module)`);
+    lines.push(`    return module.get_all_mocks`);
+    // Generate MOCK_SERVICES dictionary
+    lines.push(``);
+    lines.push(`MOCK_SERVICES = {`);
+    for (const entry of mockEntries) {
+        lines.push(`    "${entry.serviceName}": {"factory": _load_mock_factory("${entry.relativePath}", "${entry.moduleName}"), "protocol": "${entry.protocol}"},`);
+    }
+    lines.push(`}`);
+    // Always define MOCK_TARGET_URLS so apply_all_mocks can reference it unconditionally.
+    // REST targets normalize to URL origins, while gRPC/Kafka targets preserve host:port.
+    lines.push(``);
+    lines.push(`MOCK_TARGET_URLS = {`);
+    for (const entry of mockEntries) {
+        if (entry.targetUrl) {
+            lines.push(`    "${entry.serviceName}": "${entry.targetUrl}",`);
+        }
+    }
+    lines.push(`}`);
+    // Generate apply_all_mocks() function.
+    lines.push(``);
+    lines.push(`def apply_all_mocks(client):`);
+    lines.push(`    """Apply all generated mocks together after protocol-specific normalization."""`);
+    lines.push(`    client.remove_all_mocks()`);
+    lines.push(``);
+    lines.push(`    all_mocks = []`);
+    lines.push(`    for service_name, mock_config in MOCK_SERVICES.items():`);
+    lines.push(`        get_mocks_fn = mock_config["factory"]`);
+    lines.push(`        mocks = get_mocks_fn()`);
+    lines.push(`        target_url = MOCK_TARGET_URLS.get(service_name)`);
+    lines.push(`        if target_url:`);
+    lines.push(`            for mock in mocks:`);
+    lines.push(`                mock.url = target_url`);
+    lines.push(`        all_mocks.extend(mocks)`);
+    lines.push(``);
+    lines.push(`    if all_mocks:`);
+    lines.push(`        client.apply_mock(all_mocks)`);
+    if (traceComments?.length) {
+        lines.push(``);
+        for (const comment of traceComments) {
+            lines.push(`# Mock trace: ${comment}`);
+        }
+    }
+    return lines.join("\n");
+}
+function extractMockCommandLine(mockFile) {
+    if (!fs.existsSync(mockFile))
+        return undefined;
+    return fs
+        .readFileSync(mockFile, "utf-8")
+        .split("\n")
+        .map((line) => line.replace(/^\s*#\s?/, "").trim())
+        .find((line) => line.startsWith("Command: skyramp generate mock "));
+}
+function extractProtocolFromCommandLine(commandLine, mockFile) {
+    const protocolMatch = commandLine?.match(/skyramp generate mock (rest|grpc|kafka)\b/);
+    if (protocolMatch?.[1])
+        return protocolMatch[1];
+    const baseName = path.basename(mockFile).toLowerCase();
+    if (baseName.includes("kafka"))
+        return MockProtocol.Kafka;
+    if (baseName.includes("grpc"))
+        return MockProtocol.Grpc;
+    return MockProtocol.Rest;
+}
+function extractBaseUrlFromCommandLine(commandLine) {
+    if (!commandLine)
+        return undefined;
+    const commandMatch = commandLine.match(/skyramp generate mock (?:rest|grpc|kafka)\s+([^\s\\]+)/);
+    if (!commandMatch || commandMatch[1].startsWith("--"))
+        return undefined;
+    return normalizeMockCommandTarget(commandMatch[1]);
+}
+function uniquePythonIdentifier(raw, used) {
+    const base = raw.replace(/\W|^(?=\d)/g, "_");
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${base}_${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function normalizeMockCommandTarget(target) {
+    if (!target)
+        return undefined;
+    try {
+        const endpointUrl = new URL(target);
+        if (endpointUrl.origin !== "null")
+            return endpointUrl.origin;
+    }
+    catch {
+        // Fall through to host:port handling below.
+    }
+    // gRPC and Kafka mock targets are usually service host:port values without a URL scheme.
+    return /^[A-Za-z0-9_.-]+:\d+$/.test(target) ? target : undefined;
+}
+// Exported for testing
+export { injectMockImports, buildMockImportBlock };

package/build/tools/enrichTestWithMocksTool.test.d.ts

@@ -0,0 +1 @@
+export {};