@skyramp/mcp 0.3.0 → 0.3.1-ldw-beta

package/build/services/TestExecutionService.js

@@ -9,11 +9,11 @@ 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";
 import { walkDir } from "../utils/fileWalk.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
@@ -454,10 +454,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

@@ -83,14 +83,23 @@ describe("rewriteLocalhostForDocker", () => {
 describe("buildContainerEnv", () => {
     const baseOptions = { token: "test-token", language: "python" };
     const emptyHostEnv = {};
-    it("always includes SKYRAMP_TEST_TOKEN and SKYRAMP_IN_DOCKER", () => {
+    it("includes SKYRAMP_TEST_TOKEN when token is provided", () => {
         const env = buildContainerEnv(baseOptions, undefined, emptyHostEnv);
         expect(env).toContain("SKYRAMP_TEST_TOKEN=test-token");
         expect(env).toContain("SKYRAMP_IN_DOCKER=true");
     });
-    it("defaults token to empty string when not provided", () => {
+    it("omits SKYRAMP_TEST_TOKEN when token is not provided", () => {
         const env = buildContainerEnv({ language: "typescript" }, undefined, emptyHostEnv);
-        expect(env).toContain("SKYRAMP_TEST_TOKEN=");
+        expect(env.some((e) => e.startsWith("SKYRAMP_TEST_TOKEN="))).toBe(false);
+        expect(env).toContain("SKYRAMP_IN_DOCKER=true");
+    });
+    it("omits SKYRAMP_TEST_TOKEN when token is empty string (E7: unauthenticated endpoint)", () => {
+        // When unauthenticated: true, executeSkyrampTestTool resolves effectiveToken to "".
+        // containerEnv must NOT inject SKYRAMP_TEST_TOKEN="" because the generated test
+        // would then send an empty Authorization header, hitting the SUT's auth middleware
+        // and causing encoding errors (ASCII-8BIT → UTF-8).
+        const env = buildContainerEnv({ language: "python", token: "" }, undefined, emptyHostEnv);
+        expect(env.some((e) => e.startsWith("SKYRAMP_TEST_TOKEN="))).toBe(false);
     });
     it("adds PYTEST_ADDOPTS for python language", () => {
         const env = buildContainerEnv(baseOptions, undefined, emptyHostEnv);
@@ -303,6 +312,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 +375,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 +450,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;

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;
@@ -50,7 +50,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/services/TestGenerationService.js

@@ -2,7 +2,7 @@ import path from "path";
 import fs from "fs";
 import { SkyrampClient } from "@skyramp/skyramp";
 import { analyzeOpenAPIWithGivenEndpoint } from "../utils/analyze-openapi.js";
-import { isAuthorizationHeaderName, KNOWN_AUTH_HEADERS, getWorkspaceAuthConfig, getDefaultAuthHeader, getAuthScheme, WorkspaceAuthType, } from "../utils/workspaceAuth.js";
+import { isAuthorizationHeaderName, KNOWN_AUTH_HEADERS, resolveAuthFromWorkspace, } from "../utils/workspaceAuth.js";
 import { getPathParameterValidationError, OUTPUT_DIR_FIELD_NAME, PATH_PARAMS_FIELD_NAME, QUERY_PARAMS_FIELD_NAME, FORM_PARAMS_FIELD_NAME, validateParams, validatePath, validateRequestData, } from "../utils/utils.js";
 import { getEntryPoint } from "../utils/telemetry.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
@@ -316,29 +316,15 @@ The generated test file remains unchanged and ready to use as-is.
     async executeGeneration(generateOptions) {
         try {
             // Auto-resolve auth from workspace config when authHeader was not explicitly provided.
-            // undefined = omit (auto-resolve); "" = explicit skip-auth for unauthenticated endpoints.
+            // undefined = auto-resolve; "" = caller explicitly said skip-auth.
             if (generateOptions.authHeader === undefined) {
                 try {
                     const repoPath = generateOptions.outputDir || process.cwd();
-                    const wsAuth = await getWorkspaceAuthConfig(repoPath);
-                    let resolvedHeader = wsAuth.authHeader ?? getDefaultAuthHeader(wsAuth.authType);
-                    if (!resolvedHeader && wsAuth.authScheme !== undefined) {
-                        resolvedHeader = "Authorization";
-                    }
-                    if (wsAuth.authType === WorkspaceAuthType.ApiKey && !resolvedHeader) {
-                        logger.warning("workspace.yml has authType: apiKey but no authHeader is set — " +
-                            "requests will be sent without an auth header and will likely receive 401/403. " +
-                            "Add authHeader: <X-Your-Key-Header> to .skyramp/workspace.yml.");
-                    }
-                    if (resolvedHeader && wsAuth.authType !== WorkspaceAuthType.None) {
-                        logger.info("authHeader not provided — resolved from workspace config", {
-                            authHeader: resolvedHeader,
-                            authType: wsAuth.authType,
-                        });
-                        generateOptions.authHeader = resolvedHeader;
-                        if (isAuthorizationHeaderName(resolvedHeader)) {
-                            generateOptions.authScheme =
-                                generateOptions.authScheme ?? wsAuth.authScheme ?? getAuthScheme(wsAuth.authType);
+                    const resolved = await resolveAuthFromWorkspace(repoPath, generateOptions.authHeader, generateOptions.authScheme);
+                    if (resolved) {
+                        generateOptions.authHeader = resolved.authHeader;
+                        if (resolved.authScheme !== undefined) {
+                            generateOptions.authScheme = resolved.authScheme;
                         }
                     }
                 }

package/build/services/containerEnv.js

@@ -14,7 +14,9 @@ export function rewriteLocalhostForDocker(url) {
  */
 export function buildContainerEnv(options, saveStoragePath, hostEnv = process.env) {
     const env = [
-        `SKYRAMP_TEST_TOKEN=${options.token || ""}`,
+        // Omit entirely when empty so os.getenv() returns None in the test —
+        // unauthenticated endpoints won't send an empty auth header (E7).
+        ...(options.token ? [`SKYRAMP_TEST_TOKEN=${options.token}`] : []),
         "SKYRAMP_IN_DOCKER=true",
     ];
     // Skyramp-generated tests are standalone HTTP tests that never need host repo

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",
@@ -29,6 +32,7 @@ export const TOOLS_WITHOUT_PHASE = new Set([
     "skyramp_init_scan",
     "skyramp_init_workspace",
     "skyramp_one_click_tool",
+    "skyramp_setup_local_dev_worker",
     "skyramp_actions",
     "skyramp_start_trace_collection",
     "skyramp_stop_trace_collection",
@@ -36,4 +40,6 @@ export const TOOLS_WITHOUT_PHASE = new Set([
     "skyramp_modularization",
     "skyramp_reuse_code",
     "skyramp_enhance_assertions",
+    "skyramp_preflight_mock_check",
+    "skyramp_query_proxy_mocks",
 ]);

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: Boolean(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 };