@skyramp/mcp 0.3.0 → 0.3.1-ldw-beta

package/build/tools/localDevWorkerComposeTool.d.ts

@@ -0,0 +1,24 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface WorkerComposeResult {
+    baseComposeFile: string;
+    overrideFile: string;
+    dockerNetwork: string;
+    workerPort: number;
+    composeFilePrefix: string;
+}
+/**
+ * Generate the worker compose override and return the resolved network name and
+ * the `-f` prefix for `docker compose` commands. Throws on a missing compose file
+ * or if Docker is not running.
+ */
+export declare function setupLocalDevWorker(repositoryPath: string, composeFile?: string): WorkerComposeResult;
+/**
+ * Deterministically set up the Skyramp worker as a Docker Compose service for
+ * the local-dev workflow.
+ *
+ * This replaces the SDK's imperative worker spawn (which raced onto the wrong
+ * Docker network and leaked on teardown — Local-Dev Skill Findings #1, #9, #10).
+ * The worker becomes a compose service via a generated override file, so it joins
+ * the SUT's network declaratively and is removed by `docker compose down`.
+ */
+export declare function registerLocalDevWorkerComposeTool(server: McpServer): void;

package/build/tools/localDevWorkerComposeTool.js

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import * as path from "path";
+import * as fs from "fs";
+import { execSync } from "child_process";
+import yaml from "js-yaml";
+import { AnalyticsService } from "../services/AnalyticsService.js";
+import { WORKER_DOCKER_IMAGE, WORKER_CONTROL_PORT } from "../utils/versions.js";
+import { logger } from "../utils/logger.js";
+const TOOL_NAME = "skyramp_setup_local_dev_worker";
+// Relative path (under the repo) where the generated worker override is written.
+const OVERRIDE_REL_PATH = ".skyramp/skyramp.worker.compose.yml";
+const BASE_COMPOSE_CANDIDATES = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+];
+/**
+ * Docker Compose project name derivation: lowercase the directory basename and
+ * strip characters outside [a-z0-9_-] (Compose's normalization). COMPOSE_PROJECT_NAME
+ * overrides it when set. The default network is then `<project>_<networkKey>`, or
+ * `<project>_default` when the compose file declares no named networks.
+ */
+function deriveProjectName(composeDir, env = process.env) {
+    const override = env.COMPOSE_PROJECT_NAME?.trim();
+    if (override)
+        return override;
+    return path
+        .basename(composeDir)
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]/g, "");
+}
+/** Resolve the base compose file: explicit path wins, else discover at repo root. */
+function resolveBaseCompose(repositoryPath, composeFile) {
+    if (composeFile) {
+        const abs = path.isAbsolute(composeFile)
+            ? composeFile
+            : path.join(repositoryPath, composeFile);
+        return fs.existsSync(abs) ? abs : undefined;
+    }
+    for (const candidate of BASE_COMPOSE_CANDIDATES) {
+        const abs = path.join(repositoryPath, candidate);
+        if (fs.existsSync(abs))
+            return abs;
+    }
+    return undefined;
+}
+/**
+ * Build the worker override compose document. The worker joins the same named
+ * network(s) the base declares (so it shares the SUT's network for DNS-alias
+ * hijacking at mock-apply time); when the base declares none, the worker joins
+ * the implicit `default` network like every other service. Only the control
+ * port (35142) is published to the host — mock ports stay internal to the
+ * docker network.
+ */
+function buildOverrideDoc(networkKeys) {
+    const workerService = {
+        image: WORKER_DOCKER_IMAGE,
+        volumes: [
+            "skyramp:/etc/skyramp",
+            "/var/run/docker.sock:/var/run/docker.sock",
+        ],
+        ports: [`127.0.0.1:${WORKER_CONTROL_PORT}:${WORKER_CONTROL_PORT}`],
+        restart: "always",
+    };
+    const doc = {
+        services: { skyramp: workerService },
+        volumes: { skyramp: null },
+    };
+    if (networkKeys.length > 0) {
+        workerService.networks = networkKeys;
+        // Reference each base network by key so Compose merges (does not redefine) it.
+        doc.networks = Object.fromEntries(networkKeys.map((k) => [k, {}]));
+    }
+    return doc;
+}
+/**
+ * Resolve the actual Docker network name Compose uses for `key`:
+ * - an explicit `name:` is used verbatim (NOT project-scoped),
+ * - `external: true` networks are pre-existing and not project-scoped
+ *   (use `external.name` for the legacy form, else the key),
+ * - otherwise Compose prefixes the project: `<project>_<key>`.
+ */
+function resolveNetworkName(project, key, def) {
+    const d = def ?? {};
+    if (typeof d.name === "string" && d.name.length > 0)
+        return d.name;
+    if (d.external) {
+        if (typeof d.external === "object" && d.external.name) {
+            return d.external.name;
+        }
+        return key;
+    }
+    return `${project}_${key}`;
+}
+/**
+ * Verify that the Docker daemon is reachable.
+ * Throws with a clear, actionable message so the agent stops immediately
+ * instead of spending turns manually debugging Docker connectivity.
+ *
+ * Does NOT switch Docker contexts — that can break a working setup when the
+ * active context differs from `default` but Docker is accessible via symlink.
+ */
+function checkDockerReady() {
+    try {
+        execSync("docker info", { stdio: "pipe", timeout: 15_000 });
+        return; // Docker is reachable.
+    }
+    catch {
+        // Docker not reachable on current context/config.
+    }
+    throw new Error("Docker daemon is not running or not reachable. " +
+        "Start Docker Desktop and retry. " +
+        "Do NOT attempt to debug Docker connectivity, try alternative socket paths, " +
+        "switch Docker contexts, or run `open -a Docker` — " +
+        "report this as a blocking environment error and stop.");
+}
+/**
+ * Generate the worker compose override and return the resolved network name and
+ * the `-f` prefix for `docker compose` commands. Throws on a missing compose file
+ * or if Docker is not running.
+ */
+export function setupLocalDevWorker(repositoryPath, composeFile) {
+    // Fail fast if Docker is not available — prevents the agent from proceeding
+    // with false confidence and then spending turns debugging Docker manually.
+    // Skipped when SKIP_DOCKER_CHECK=1 (unit tests that only validate YAML generation).
+    if (process.env.SKIP_DOCKER_CHECK !== "1") {
+        checkDockerReady();
+    }
+    const baseComposeFile = resolveBaseCompose(repositoryPath, composeFile);
+    if (!baseComposeFile) {
+        throw new Error(composeFile
+            ? `Compose file not found: ${composeFile}`
+            : `No docker-compose file found at ${repositoryPath} (looked for: ${BASE_COMPOSE_CANDIDATES.join(", ")}). Pass composeFile for a non-default location.`);
+    }
+    const parsed = yaml.load(fs.readFileSync(baseComposeFile, "utf-8"), {
+        schema: yaml.JSON_SCHEMA,
+    });
+    const networksObj = parsed?.networks ?? {};
+    const networkKeys = Object.keys(networksObj);
+    // Compose derives project name from the working directory (typically repo root),
+    // not from the compose file's directory. The plan instructs agents to run
+    // `docker compose` from repositoryPath.
+    const project = deriveProjectName(repositoryPath);
+    // The network the SDK client + executor target. First declared named network,
+    // else the implicit default network. Honor explicit `name:`/`external:` so the
+    // returned name matches the network Compose actually creates/uses.
+    const primaryKey = networkKeys[0] ?? "default";
+    const dockerNetwork = resolveNetworkName(project, primaryKey, networksObj[primaryKey]);
+    const overrideFile = path.join(repositoryPath, OVERRIDE_REL_PATH);
+    fs.mkdirSync(path.dirname(overrideFile), { recursive: true });
+    const overrideDoc = buildOverrideDoc(networkKeys);
+    const header = "# Generated by skyramp_setup_local_dev_worker — runs the Skyramp mock worker\n" +
+        "# as a compose service so it shares the SUT's network and is torn down with\n" +
+        "# the project. Layer it: docker compose -f <base> -f this up. Safe to delete.\n";
+    fs.writeFileSync(overrideFile, header + yaml.dump(overrideDoc, { lineWidth: -1 }), "utf-8");
+    return {
+        baseComposeFile,
+        overrideFile,
+        dockerNetwork,
+        workerPort: WORKER_CONTROL_PORT,
+        composeFilePrefix: `-f ${baseComposeFile} -f ${overrideFile}`,
+    };
+}
+/**
+ * Deterministically set up the Skyramp worker as a Docker Compose service for
+ * the local-dev workflow.
+ *
+ * This replaces the SDK's imperative worker spawn (which raced onto the wrong
+ * Docker network and leaked on teardown — Local-Dev Skill Findings #1, #9, #10).
+ * The worker becomes a compose service via a generated override file, so it joins
+ * the SUT's network declaratively and is removed by `docker compose down`.
+ */
+export function registerLocalDevWorkerComposeTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: `Set up the Skyramp mock worker as a Docker Compose service for the local-dev workflow (run this in the Deploy phase, before bringing the stack up).
+
+Writes a compose override file (.skyramp/skyramp.worker.compose.yml) that declares the worker as a service on the SUT's docker network, then returns the docker-compose \`-f\` prefix and the resolved docker network name.
+
+Why: running the worker as a compose service makes it join the SUT's network declaratively (so the app can reach its mocks) and tears it down with \`docker compose down\` — replacing the fragile runtime worker spawn that landed on the wrong network and leaked on teardown.
+
+Use the returned values like this:
+- Bring up: \`docker compose <composeFilePrefix> up -d --build <sut-service> <real-deps...> skyramp\` (stop mocked-service containers first).
+- Tear down: \`docker compose <composeFilePrefix> down -v\`.
+- Pass \`dockerNetwork\` (and \`dockerWorkerPort\`=workerPort) to every test generation call so the generated client — emitted with runtime="docker", docker_network, docker_skyramp_port — connects to this worker.`,
+        inputSchema: {
+            repositoryPath: z
+                .string()
+                .refine((value) => path.isAbsolute(value), {
+                message: "repositoryPath must be an absolute path",
+            })
+                .describe("Absolute path to the repository (where docker-compose runs)."),
+            composeFile: z
+                .string()
+                .optional()
+                .describe("Path to the base docker-compose file (absolute, or relative to repositoryPath). Omit to auto-discover docker-compose.yml/.yaml or compose.yml/.yaml at the repo root. Provide this when the compose file lives in a subdirectory or has a non-default name."),
+        },
+    }, async (args) => {
+        try {
+            const result = setupLocalDevWorker(args.repositoryPath, args.composeFile);
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, undefined, {}).catch(() => { });
+            logger.info("Generated local-dev worker compose override", {
+                overrideFile: result.overrideFile,
+                dockerNetwork: result.dockerNetwork,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+                structuredContent: { ...result },
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                isError: true,
+                content: [{ type: "text", text: message }],
+            };
+        }
+    });
+}

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

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

package/build/tools/localDevWorkerComposeTool.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, afterEach } from "@jest/globals";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import yaml from "js-yaml";
+import { setupLocalDevWorker } from "./localDevWorkerComposeTool.js";
+import { WORKER_DOCKER_IMAGE } from "../utils/versions.js";
+/** Create a project dir (named, for deterministic project-name derivation) with a compose file. */
+function makeRepo(projectName, composeBody, fileName = "docker-compose.yml") {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-worker-"));
+    const repo = path.join(root, projectName);
+    fs.mkdirSync(repo, { recursive: true });
+    fs.writeFileSync(path.join(repo, fileName), composeBody);
+    return { root, repo };
+}
+const NAMED_NETWORK_COMPOSE = `services:
+  monolith:
+    image: monolith
+    networks: [checkr_default]
+networks:
+  checkr_default:
+    driver: bridge
+`;
+const DEFAULT_NETWORK_COMPOSE = `services:
+  monolith:
+    image: monolith
+`;
+// Network with an explicit `name:` — Compose uses that verbatim (not project-scoped).
+const EXPLICIT_NAME_COMPOSE = `services:
+  monolith:
+    image: monolith
+    networks: [app]
+networks:
+  app:
+    name: my_custom_net
+`;
+// External network — pre-existing, not project-scoped.
+const EXTERNAL_NETWORK_COMPOSE = `services:
+  monolith:
+    image: monolith
+    networks: [shared]
+networks:
+  shared:
+    external: true
+`;
+describe("setupLocalDevWorker", () => {
+    const created = [];
+    beforeAll(() => {
+        // Skip Docker daemon check in unit tests — these tests validate YAML
+        // generation logic, not Docker connectivity.
+        process.env.SKIP_DOCKER_CHECK = "1";
+    });
+    afterAll(() => {
+        delete process.env.SKIP_DOCKER_CHECK;
+    });
+    afterEach(() => {
+        while (created.length)
+            fs.rmSync(created.pop(), { recursive: true, force: true });
+        delete process.env.COMPOSE_PROJECT_NAME;
+    });
+    function loadOverride(file) {
+        return yaml.load(fs.readFileSync(file, "utf-8"));
+    }
+    it("attaches the worker to the base's named network and resolves <project>_<key>", () => {
+        const { root, repo } = makeRepo("demoapp", NAMED_NETWORK_COMPOSE);
+        created.push(root);
+        const result = setupLocalDevWorker(repo);
+        expect(result.dockerNetwork).toBe("demoapp_checkr_default");
+        expect(result.workerPort).toBe(35142);
+        expect(result.composeFilePrefix).toBe(`-f ${result.baseComposeFile} -f ${result.overrideFile}`);
+        const doc = loadOverride(result.overrideFile);
+        const worker = doc.services.skyramp;
+        expect(worker.image).toBe(WORKER_DOCKER_IMAGE);
+        expect(worker.ports).toEqual(["127.0.0.1:35142:35142"]); // control port bound to localhost only
+        expect(worker.volumes).toContain("/var/run/docker.sock:/var/run/docker.sock");
+        expect(worker.networks).toEqual(["checkr_default"]);
+        expect(doc.networks).toHaveProperty("checkr_default");
+        expect(doc.volumes).toHaveProperty("skyramp");
+    });
+    it("uses an explicit network name: verbatim (not project-scoped)", () => {
+        const { root, repo } = makeRepo("demoapp", EXPLICIT_NAME_COMPOSE);
+        created.push(root);
+        const result = setupLocalDevWorker(repo);
+        expect(result.dockerNetwork).toBe("my_custom_net");
+        expect(loadOverride(result.overrideFile).services.skyramp.networks).toEqual(["app"]);
+    });
+    it("uses the key (not project-scoped) for an external network", () => {
+        const { root, repo } = makeRepo("demoapp", EXTERNAL_NETWORK_COMPOSE);
+        created.push(root);
+        const result = setupLocalDevWorker(repo);
+        expect(result.dockerNetwork).toBe("shared");
+    });
+    it("joins the implicit default network when the base declares none", () => {
+        const { root, repo } = makeRepo("plainapp", DEFAULT_NETWORK_COMPOSE);
+        created.push(root);
+        const result = setupLocalDevWorker(repo);
+        expect(result.dockerNetwork).toBe("plainapp_default");
+        const doc = loadOverride(result.overrideFile);
+        // No named networks → worker has no explicit networks list (joins default).
+        expect(doc.services.skyramp.networks).toBeUndefined();
+        expect(doc.networks).toBeUndefined();
+    });
+    it("honors COMPOSE_PROJECT_NAME for the network name", () => {
+        const { root, repo } = makeRepo("ignored-basename", NAMED_NETWORK_COMPOSE);
+        created.push(root);
+        process.env.COMPOSE_PROJECT_NAME = "custom";
+        const result = setupLocalDevWorker(repo);
+        expect(result.dockerNetwork).toBe("custom_checkr_default");
+    });
+    it("resolves a non-root composeFile and builds the right -f prefix", () => {
+        const { root, repo } = makeRepo("subdirapp", NAMED_NETWORK_COMPOSE, "docker-compose.yml");
+        created.push(root);
+        // Move the compose into a subdir to simulate a non-default location.
+        const subdir = path.join(repo, "infra");
+        fs.mkdirSync(subdir);
+        const moved = path.join(subdir, "compose.yml");
+        fs.renameSync(path.join(repo, "docker-compose.yml"), moved);
+        const result = setupLocalDevWorker(repo, "infra/compose.yml");
+        expect(result.baseComposeFile).toBe(moved);
+        expect(result.composeFilePrefix).toContain(`-f ${moved}`);
+        // Project name comes from the working directory (repo root), not the compose file's directory.
+        expect(result.dockerNetwork).toBe("subdirapp_checkr_default");
+    });
+    it("throws a clear error when no compose file is found", () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-worker-"));
+        created.push(root);
+        expect(() => setupLocalDevWorker(root)).toThrow(/No docker-compose file found/);
+    });
+});

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

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

package/build/tools/localDevWorkflowFixes.test.js

@@ -0,0 +1,255 @@
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { RuntimeEnvironment, TestType } from "../types/TestTypes.js";
+const generateRestMock = jest.fn();
+const generateGrpcMock = jest.fn();
+jest.unstable_mockModule("../services/AnalyticsService.js", () => ({
+    AnalyticsService: {
+        pushMCPToolEvent: jest.fn(() => Promise.resolve(undefined)),
+        pushTestGenerationToolEvent: jest.fn(() => Promise.resolve(undefined)),
+    },
+}));
+jest.unstable_mockModule("../utils/gitStaging.js", () => ({
+    resolveOutputDir: jest.fn((outputDir) => outputDir),
+    stageGeneratedPaths: jest.fn(),
+}));
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({
+        generateRestMock,
+        generateGrpcMock,
+        generateKafkaMock: jest.fn(),
+    })),
+}));
+const { executeBatchMockGeneration, MockProtocol, registerBatchMockTool } = await import("./generate-tests/batchMockGenerationTool.js");
+const { MockGenerationService } = await import("./generate-tests/generateMockRestTool.js");
+const { registerEnhanceAssertionsTool } = await import("./code-refactor/enhanceAssertionsTool.js");
+const { registerPreflightMockCheckTool } = await import("./preflightMockCheckTool.js");
+const { AnalyticsService } = await import("../services/AnalyticsService.js");
+function registerToolForTest(register) {
+    let registered;
+    const server = {
+        registerTool: jest.fn((_name, config, handler) => {
+            registered = { config, handler };
+        }),
+    };
+    register(server);
+    if (!registered)
+        throw new Error("tool was not registered");
+    return registered;
+}
+function registerEnhanceToolForTest() {
+    return registerToolForTest(registerEnhanceAssertionsTool);
+}
+function registerPreflightToolForTest() {
+    return registerToolForTest(registerPreflightMockCheckTool);
+}
+function registerBatchMockToolForTest() {
+    return registerToolForTest(registerBatchMockTool);
+}
+describe("MockGenerationService", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-single-mock-"));
+        generateGrpcMock.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("omits responseData for single gRPC status error mocks", async () => {
+        generateGrpcMock.mockResolvedValue("success: generated mock");
+        const result = await new MockGenerationService().generateTest({
+            outputDir: tmpDir,
+            force: true,
+            protocol: MockProtocol.Grpc,
+            endpointURL: "profile-service:50051",
+            protoPath: "/repo/proto/profile.proto",
+            grpcServiceName: "ProfileService",
+            method: "GetProfile",
+            grpcStatusCode: 5,
+            grpcStatusMessage: "profile not found",
+        });
+        expect(result.isError).toBe(false);
+        expect(generateGrpcMock).toHaveBeenCalledWith(expect.objectContaining({
+            grpcStatusCode: 5,
+            grpcStatusMessage: "profile not found",
+        }));
+        expect(generateGrpcMock.mock.calls[0][0]).not.toHaveProperty("responseData");
+    });
+});
+describe("executeBatchMockGeneration", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-batch-mocks-"));
+        generateRestMock.mockReset();
+        generateGrpcMock.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("passes per-mock output names and directories to the generator", async () => {
+        const alternateDir = path.join(tmpDir, "alternate");
+        generateRestMock.mockResolvedValue("success: generated mock");
+        const result = await executeBatchMockGeneration({
+            outputDir: tmpDir,
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "PUT",
+                    output: "billing_preferences_success_mock.py",
+                },
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "PUT",
+                    outputDir: alternateDir,
+                    output: "billing_preferences_error_mock.py",
+                },
+            ],
+        });
+        expect(result.isError).toBe(false);
+        expect(generateRestMock).toHaveBeenCalledTimes(2);
+        expect(generateRestMock.mock.calls[0][0]).toMatchObject({
+            outputDir: tmpDir,
+            output: "billing_preferences_success_mock.py",
+        });
+        expect(generateRestMock.mock.calls[1][0]).toMatchObject({
+            outputDir: alternateDir,
+            output: "billing_preferences_error_mock.py",
+        });
+        expect(fs.existsSync(alternateDir)).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("billing_preferences_error_mock.py");
+    });
+    it("passes gRPC status error fields to the generator", async () => {
+        generateGrpcMock.mockResolvedValue("success: generated mock");
+        const result = await executeBatchMockGeneration({
+            outputDir: tmpDir,
+            mocks: [
+                {
+                    protocol: MockProtocol.Grpc,
+                    endpointURL: "profile-service:50051",
+                    protoPath: "/repo/proto/profile.proto",
+                    grpcServiceName: "ProfileService",
+                    method: "GetProfile",
+                    grpcStatusCode: 5,
+                    grpcStatusMessage: "profile not found",
+                },
+            ],
+        });
+        expect(result.isError).toBe(false);
+        expect(generateGrpcMock).toHaveBeenCalledWith(expect.objectContaining({
+            grpcStatusCode: 5,
+            grpcStatusMessage: "profile not found",
+        }));
+        expect(generateGrpcMock.mock.calls[0][0]).not.toHaveProperty("responseData");
+    });
+    it("marks partial failures as tool errors", async () => {
+        generateRestMock.mockResolvedValue("success: generated mock");
+        const result = await executeBatchMockGeneration({
+            outputDir: tmpDir,
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "PUT",
+                    output: "billing_preferences_success_mock.py",
+                },
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://billing-service:4000/v1/preferences",
+                    method: "",
+                    output: "billing_preferences_error_mock.py",
+                },
+            ],
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("Succeeded:** 1");
+        expect(text).toContain("Failed:** 1");
+    });
+});
+describe("skyramp_preflight_mock_check", () => {
+    const loopbackRestMock = {
+        protocol: MockProtocol.Rest,
+        endpointURL: "http://localhost:4000/v1/users",
+        method: "GET",
+    };
+    it("defaults to Docker local-dev blockers", async () => {
+        const tool = registerPreflightToolForTest();
+        const result = await tool.handler({ mocks: [loopbackRestMock] });
+        expect(result.structuredContent.hasBlockers).toBe(true);
+        expect(result.structuredContent.warnings[0].code).toBe("REST_LOOPBACK_URL");
+    });
+    it("allows callers to disable Docker local-dev checks", async () => {
+        const tool = registerPreflightToolForTest();
+        const result = await tool.handler({
+            mocks: [loopbackRestMock],
+            dockerLocalDev: false,
+        });
+        expect(result.structuredContent.hasBlockers).toBe(false);
+        expect(result.structuredContent.warnings).toHaveLength(0);
+    });
+});
+describe("skyramp_batch_mock_generation schema", () => {
+    it("uses the shared runtime schema and normalizes aliases", () => {
+        const tool = registerBatchMockToolForTest();
+        expect(tool.config.inputSchema.runtime.safeParse("local").data).toBe(RuntimeEnvironment.LOCAL);
+        expect(tool.config.inputSchema.runtime.safeParse("docker").data).toBe(RuntimeEnvironment.DOCKER);
+        expect(tool.config.inputSchema.runtime.safeParse("k8s").data).toBe(RuntimeEnvironment.KUBERNETES);
+        expect(tool.config.inputSchema.runtime.safeParse("kubernetes").data).toBe(RuntimeEnvironment.KUBERNETES);
+        expect(tool.config.inputSchema.runtime.safeParse("dockre").success).toBe(false);
+    });
+});
+describe("skyramp_enhance_assertions autoApply", () => {
+    beforeEach(() => {
+        delete process.env.SKYRAMP_FEATURE_TESTBOT;
+        jest.clearAllMocks();
+    });
+    it("includes integration-specific assertion guidance", async () => {
+        const tool = registerEnhanceToolForTest();
+        const result = await tool.handler({
+            testFile: "/repo/tests/account_integration_test.py",
+            testType: TestType.INTEGRATION,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(result.content[0].text).toContain("Type-specific assertion guidance");
+        expect(result.content[0].text).toContain("Chained values across steps");
+    });
+    it("records autoApply analytics with native boolean value", async () => {
+        const tool = registerEnhanceToolForTest();
+        await tool.handler({
+            testFile: "/repo/tests/account_integration_test.py",
+            testType: TestType.INTEGRATION,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(AnalyticsService.pushMCPToolEvent).toHaveBeenCalledWith("skyramp_enhance_assertions", undefined, expect.objectContaining({ autoApply: true }));
+    });
+    it("includes provider contract-specific assertion guidance", async () => {
+        const tool = registerEnhanceToolForTest();
+        const result = await tool.handler({
+            testFile: "/repo/tests/account_contract_test.py",
+            testType: TestType.CONTRACT,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(result.content[0].text).toContain("Chained values from inline request data");
+        expect(result.content[0].text).toContain("Do not reference `beforeAll` / `afterAll`");
+    });
+    it("includes UI-specific and Testbot-specific assertion guidance", async () => {
+        process.env.SKYRAMP_FEATURE_TESTBOT = "1";
+        const tool = registerEnhanceToolForTest();
+        const result = await tool.handler({
+            testFile: "/repo/tests/account_ui.spec.ts",
+            testType: TestType.UI,
+            enhanceType: "generation",
+            autoApply: true,
+        });
+        expect(result.content[0].text).toContain("Critical UI Assertions");
+        expect(result.content[0].text).toContain("Additional Testbot-Specific Checks");
+    });
+});

package/build/tools/one-click/oneClickTool.d.ts

@@ -1,4 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare enum CallingAgentIde {
+    Cursor = "cursor",
+    Claude = "claude"
+}
 /** User params passed to workflow builder (optional fields may be undefined) */
 export type OneClickParams = {
     workflow: string;
@@ -7,5 +11,14 @@ export type OneClickParams = {
     apiSchema?: string;
     topN?: number;
     token?: string;
+    baseBranch?: string;
+    servicesToMock?: string;
+    realServices?: string;
+    mockProtocols?: string;
+    proxyUrl?: string;
+    proxyKubeconfig?: string;
+    proxyNamespace?: string;
+    callingAgent?: CallingAgentIde;
+    rawCallingAgent?: string;
 };
 export declare function registerOneClickTool(server: McpServer): void;