@skyramp/mcp 0.4.4-rc.1 → 0.4.4

package/build/services/FleetExecutionService.js

@@ -0,0 +1,391 @@
+import Docker from "dockerode";
+import fs from "fs";
+import path from "path";
+import { Writable } from "stream";
+import { stripVTControlCharacters } from "util";
+import { EXECUTOR_DOCKER_IMAGE } from "../utils/versions.js";
+import { logger } from "../utils/logger.js";
+import { dockerImageExistsLocally, isPlatformUnavailableError, pullDockerImage, } from "../utils/docker.js";
+/**
+ * A path inside the container's work directory.
+ *
+ * Everything the run reads or writes lives under the mount, so this is the only place a
+ * container path is spelled out -- which is the point of the table above. Writing them
+ * longhand per platform put the separator back in the call sites it was meant to keep it
+ * out of.
+ */
+export function workPath(l, ...parts) {
+    return [l.work, ...parts].join(l.sep);
+}
+export const LAYOUT = {
+    linux: {
+        work: "/work",
+        certs: "/certs",
+        overrideDir: "/opt/skyramp-override",
+        poolDir: "/pool",
+        imageClasses: "/app/classes",
+        imageLibDir: "/app/lib",
+        classpathSep: ":",
+        sep: "/",
+    },
+    windows: {
+        work: "C:\\work",
+        certs: "C:\\certs",
+        overrideDir: "C:\\opt\\skyramp-override",
+        poolDir: "C:\\pool",
+        imageClasses: "C:/app/classes",
+        imageLibDir: "C:/app/lib",
+        classpathSep: ";",
+        sep: "\\",
+    },
+};
+/**
+ * Which platform the executor runs as. The Docker daemon that will run the container
+ * decides, not the image name: a released executor is one tag carrying both operating
+ * systems, and a daemon pulls and starts the image for its own.
+ *
+ * Asked of `docker`, the client that creates the container. The image check and pull go
+ * through the default client (docker.ts), which is the same daemon for every caller today:
+ * skyramp_execute_fleet passes no client. A daemon whose OS cannot be read fails the run
+ * here with that error as the cause: guessing linux on a Windows daemon would fail later
+ * with a mount or pull error that says nothing about why. An explicit platform must match
+ * the daemon; a mismatch would pull or start an image the engine cannot run.
+ */
+export async function resolvePlatform(docker, explicit) {
+    let os;
+    try {
+        os = (await docker.info())?.OSType;
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`cannot read the Docker daemon's OS to choose the executor platform: ${reason}`, { cause: err });
+    }
+    if (os !== "linux" && os !== "windows") {
+        throw new Error(`the Docker daemon reported OS ${JSON.stringify(os)}; the executor runs on linux or windows`);
+    }
+    if (explicit && explicit !== os) {
+        throw new Error(`platform "${explicit}" does not match the Docker daemon, which runs ${os} containers`);
+    }
+    return os;
+}
+/** A simple (unqualified) Java class name. */
+export const JAVA_CLASS_NAME = /^[A-Za-z_$][\w$]*$/;
+/**
+ * The generated fleet manager: the one class in the directory that JUnit runs. The journey
+ * and the load class travel with it because they sit beside it, and they are compiled but
+ * never selected -- the journey is an input the fleet ships to the worker, and the load
+ * class only supplies the scenario.
+ */
+export function findEntryClass(directory, explicit) {
+    if (explicit) {
+        // It reaches a shell script and a file path, so it must be a class name and nothing else.
+        if (!JAVA_CLASS_NAME.test(explicit)) {
+            throw new Error(`entryClass ${explicit} is not a Java class name`);
+        }
+        return explicit;
+    }
+    const candidates = fs
+        .readdirSync(directory)
+        .filter((f) => f.endsWith("FleetTest.java"))
+        .map((f) => f.replace(/\.java$/, ""))
+        .sort();
+    if (candidates.length === 0) {
+        throw new Error(`no *FleetTest.java in ${directory}: generate a ui-load trio there, or name the class with entryClass`);
+    }
+    if (candidates.length > 1) {
+        throw new Error(`several fleet classes in ${directory} (${candidates.join(", ")}): name one with entryClass`);
+    }
+    return candidates[0];
+}
+/**
+ * A fleet file that pins its worker image is refused.
+ *
+ * The library picks the image from the commit it was built from, and that pairing is what a
+ * run through this tool exercises. A pinned image proves the image is good and hides the
+ * case where the library asks for one that does not exist.
+ */
+export function assertNoPinnedImage(fleetFile) {
+    const source = fs.readFileSync(fleetFile, "utf8");
+    // The builder call, not the word: a comment that mentions the option pins nothing.
+    const pinned = ["workerImage", "workerTag"].filter((k) => new RegExp(`\\.\\s*${k}\\s*\\(`).test(source));
+    if (pinned.length > 0) {
+        throw new Error(`${path.basename(fleetFile)} pins ${pinned.join(" and ")}: the run would not exercise the ` +
+            `library's own image choice. Regenerate with a plain host.`);
+    }
+}
+/**
+ * The fleet reaches the worker it deployed at an address derived from the Docker daemon:
+ * the daemon's host for a remote engine, `localhost` for a local socket. Inside this
+ * container `localhost` is the container, so a local-socket fleet cannot reach the worker it
+ * just deployed and would hang until the timeout instead of failing.
+ */
+export function assertRemoteDaemon(fleetFile) {
+    const source = fs.readFileSync(fleetFile, "utf8");
+    if (!/dockerHost\(\s*"(tcp|http|https):\/\//.test(source)) {
+        throw new Error(`${path.basename(fleetFile)} deploys through a local Docker socket, which this tool cannot ` +
+            `run: the fleet would look for its worker on localhost, which inside the executor ` +
+            `container is the container itself. Point the host at a remote engine ` +
+            `(dockerHost tcp://…:2376 with tls), or run this trio with gradle on the host.`);
+    }
+}
+/**
+ * The image the run happens in.
+ *
+ * The released executor is named by version, and a branch build of it carries no commit in
+ * its name the way the worker images do -- `RUNNER_IMAGE` defaults to a constant tag. So a
+ * caller testing an unreleased library either names its image here, or mounts the jar.
+ */
+export function resolveExecutorImage(explicit) {
+    return (explicit || process.env.SKYRAMP_EXECUTOR_IMAGE || EXECUTOR_DOCKER_IMAGE);
+}
+/** javac, then the JUnit console runner, both against the image's classpath. */
+export function buildCommand(entryClass, overrideJar, platform = "linux") {
+    const l = LAYOUT[platform];
+    const sep = l.classpathSep;
+    const classes = workPath(l, "build", "classes");
+    const junitRunnerGlob = `${l.imageLibDir}/junit-platform-console-standalone-*.jar`;
+    // javac expands a trailing `*` itself, so the compile classpath can stay short.
+    const classpath = [
+        ...(overrideJar ? [overrideJar] : []),
+        l.imageClasses,
+        `${l.imageLibDir}/*`,
+    ].join(sep);
+    // The runner's own --class-path does NOT: it parses each entry as a path, and `*` is an
+    // illegal character in a Windows path, so the shorthand is rejected there (and merely
+    // tolerated on Linux). Both platforms therefore hand it expanded jars.
+    const runPrefix = [
+        classes,
+        ...(overrideJar ? [overrideJar] : []),
+        l.imageClasses,
+    ].join(sep);
+    if (platform === "windows") {
+        // PowerShell, because the base image has no POSIX shell. $LASTEXITCODE is propagated
+        // by hand: a native command failing does not end a PowerShell script on its own, and a
+        // run that failed must not exit 0.
+        const script = [
+            "$ErrorActionPreference = 'Stop'",
+            `New-Item -ItemType Directory -Force ${classes} | Out-Null`,
+            `& javac.exe -cp '${classpath}' -d ${classes} (Get-ChildItem ${l.work}\\*.java).FullName`,
+            "if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }",
+            `$runner = (Get-ChildItem ${junitRunnerGlob} | Select-Object -First 1).FullName`,
+            `$cp = '${runPrefix}${sep}' + ((Get-ChildItem ${l.imageLibDir}/*.jar).FullName -join '${sep}')`,
+            `& java.exe -jar $runner --class-path $cp --select-class ${entryClass} ` +
+                "--details=tree --disable-ansi-colors",
+            "exit $LASTEXITCODE",
+        ].join("\n");
+        return {
+            argv: ["powershell", "-NoLogo", "-NonInteractive", "-Command", script],
+            script,
+        };
+    }
+    const script = [
+        "set -e",
+        `mkdir -p ${classes}`,
+        `javac -cp '${classpath}' -d ${classes} ${l.work}/*.java`,
+        `runcp="${runPrefix}${sep}$(ls ${l.imageLibDir}/*.jar | tr '\\n' '${sep}')"`,
+        `java -jar $(ls ${junitRunnerGlob} | head -1) ` +
+            `--class-path "$runcp" --select-class ${entryClass} ` +
+            `--details=tree --disable-ansi-colors`,
+    ].join("\n");
+    return { argv: ["sh", "-c", script], script };
+}
+/** The lines the fleet printed, which is what a reader wants out of the JUnit noise. */
+export function extractReport(output) {
+    const keep = /^\s*(verdict|counts|rate|latency|vitals|per-region|step|action|generator|host error|warning):/;
+    const lines = output.split("\n").filter((l) => keep.test(l));
+    return lines.map((l) => l.trim()).join("\n");
+}
+/**
+ * Where a path inside the container lands on the host.
+ *
+ * The work directory is a bind mount of `directory`, so anything written under it appears
+ * there. Deriving the host path from the container path keeps the two ends of
+ * SKYRAMP_FLEET_REPORT_JSON as one fact: the value handed to the JVM is the value read
+ * back, rather than a second hardcoded guess that happens to agree.
+ *
+ * Returns undefined when the path is not under the work directory -- a caller may point
+ * the variable anywhere, and nothing outside the mount is visible from here.
+ */
+export function hostPathForContainerPath(directory, workDir, containerPath) {
+    const split = (p) => p.split(/[\\/]+/).filter(Boolean);
+    const work = split(workDir);
+    const target = split(containerPath);
+    // Windows paths are case-insensitive, and the layout mixes `C:\work` with `C:/app/...`.
+    const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+    if (target.length <= work.length)
+        return undefined;
+    if (!work.every((seg, i) => same(seg, target[i])))
+        return undefined;
+    const host = path.join(directory, ...target.slice(work.length));
+    // `..` segments survive the split and path.join resolves them, so check where it landed.
+    const rel = path.relative(directory, host);
+    if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel))
+        return undefined;
+    return host;
+}
+function mount(source, target, readOnly = false) {
+    return {
+        Type: "bind",
+        Source: source,
+        Target: target,
+        ReadOnly: readOnly,
+    };
+}
+/**
+ * Mounts a host file by its directory, and returns where the file lands in the container.
+ *
+ * Directories only, because Windows containers cannot bind-mount a single file. The same
+ * code path serves Linux, so the two platforms do not diverge on this.
+ */
+function mountFileDir(mounts, l, hostFile, containerDir) {
+    mounts.push(mount(path.dirname(hostFile), containerDir, true));
+    return [containerDir, path.basename(hostFile)].join(l.sep);
+}
+/**
+ * Compiles and runs a generated fleet trio in the executor image, and returns what the run
+ * reported. The container is the same one every other generated test runs in; only the
+ * command and the mounts differ.
+ */
+export async function executeFleet(options, docker = new Docker()) {
+    const directory = path.resolve(options.directory);
+    if (!fs.existsSync(directory)) {
+        throw new Error(`directory not found: ${directory}`);
+    }
+    const entryClass = findEntryClass(directory, options.entryClass);
+    const fleetFile = path.join(directory, `${entryClass}.java`);
+    if (!fs.existsSync(fleetFile)) {
+        throw new Error(`entry class ${entryClass} has no file at ${fleetFile}`);
+    }
+    assertNoPinnedImage(fleetFile);
+    assertRemoteDaemon(fleetFile);
+    const credentials = options.credentials
+        ? path.resolve(options.credentials)
+        : path.join(directory, "credentials.csv");
+    if (options.credentials && !fs.existsSync(credentials)) {
+        throw new Error(`credential pool not found: ${credentials}`);
+    }
+    const executorImage = resolveExecutorImage(options.executorImage);
+    const platform = await resolvePlatform(docker, options.platform);
+    const l = LAYOUT[platform];
+    const mounts = [mount(directory, l.work)];
+    const derived = {
+        SKYRAMP_FLEET_REPORT_JSON: workPath(l, "build", "fleet-result.json"),
+    };
+    if (fs.existsSync(credentials)) {
+        derived.SKYRAMP_CREDENTIALS =
+            path.dirname(credentials) === directory
+                ? workPath(l, path.basename(credentials))
+                : mountFileDir(mounts, l, credentials, l.poolDir);
+    }
+    const certs = path.resolve(options.certsDir);
+    if (!fs.existsSync(certs)) {
+        throw new Error(`certificate directory not found: ${certs}`);
+    }
+    mounts.push(mount(certs, l.certs, true));
+    derived.SKYRAMP_DOCKER_CERTS = l.certs;
+    let overrideJar;
+    if (options.libraryJar) {
+        const jar = path.resolve(options.libraryJar);
+        if (!fs.existsSync(jar)) {
+            throw new Error(`library jar not found: ${jar}`);
+        }
+        overrideJar = mountFileDir(mounts, l, jar, l.overrideDir);
+    }
+    // One rule for every variable the tool derives: the caller's env wins.
+    const env = { ...derived, ...(options.env ?? {}) };
+    // Read back exactly where the run was told to write, including a caller's override.
+    const jsonPath = hostPathForContainerPath(directory, l.work, env.SKYRAMP_FLEET_REPORT_JSON);
+    // The work directory outlives the run, so a previous run's result would otherwise be read
+    // as this one's when this one fails before writing.
+    if (jsonPath !== undefined)
+        fs.rmSync(jsonPath, { force: true });
+    const imagePlatform = `${platform}/amd64`;
+    if (!(await dockerImageExistsLocally(executorImage))) {
+        logger.info("Pulling executor image for the fleet run", {
+            image: executorImage,
+            platform: imagePlatform,
+        });
+        try {
+            await pullDockerImage(executorImage, imagePlatform);
+        }
+        catch (err) {
+            if (!isPlatformUnavailableError(err))
+                throw err;
+            throw new Error(`executor image ${executorImage} has no ${platform} image, so it cannot run on this ` +
+                `${platform} Docker daemon. Use an executor release that carries ${platform}, or ` +
+                `set executorImage (or SKYRAMP_EXECUTOR_IMAGE) to one built for it.`, { cause: err });
+        }
+    }
+    const container = await docker.createContainer({
+        Image: executorImage,
+        Cmd: buildCommand(entryClass, overrideJar, platform).argv,
+        WorkingDir: l.work,
+        Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
+        Tty: false,
+        platform: imagePlatform,
+        HostConfig: { Mounts: mounts, AutoRemove: false },
+    });
+    let output = "";
+    let exitCode = null;
+    let timedOut = false;
+    try {
+        const sink = new Writable({
+            write(chunk, _enc, cb) {
+                output += stripVTControlCharacters(chunk.toString());
+                cb();
+            },
+        });
+        const stream = await container.attach({
+            stream: true,
+            stdout: true,
+            stderr: true,
+        });
+        container.modem.demuxStream(stream, sink, sink);
+        const timeoutMs = (options.timeoutSec ?? 600) * 1000;
+        await container.start();
+        const timer = setTimeout(() => {
+            timedOut = true;
+            container.kill().catch((e) => {
+                logger.error(`could not kill the timed-out fleet container: ${e}`);
+            });
+        }, timeoutMs);
+        try {
+            const status = await container.wait();
+            exitCode =
+                typeof status?.StatusCode === "number" ? status.StatusCode : null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    finally {
+        await container.remove({ force: true }).catch((e) => {
+            logger.error(`could not remove the fleet container: ${e}`);
+        });
+    }
+    let result;
+    if (jsonPath === undefined) {
+        logger.warning(`SKYRAMP_FLEET_REPORT_JSON is ${env.SKYRAMP_FLEET_REPORT_JSON}, which is outside the ` +
+            `mounted directory (${l.work}); the structured result cannot be read back`);
+    }
+    else if (fs.existsSync(jsonPath)) {
+        try {
+            result = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
+        }
+        catch (e) {
+            // An unreadable artifact is not a failed run: the report text still stands.
+            logger.error(`fleet result JSON at ${jsonPath} could not be parsed: ${e}`);
+        }
+    }
+    return {
+        passed: exitCode === 0 && !timedOut,
+        executorImage,
+        platform,
+        entryClass,
+        exitCode,
+        report: extractReport(output),
+        output,
+        result,
+        timedOut: timedOut || undefined,
+    };
+}

package/build/services/ModularizationService.d.ts

@@ -1,4 +1,4 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolResult } from "@modelcontextprotocol/server";
 export interface ModularizationParams {
     testFile: string;
     testType?: string;

package/build/services/TestExecutionService.d.ts

@@ -69,6 +69,13 @@ export declare class TestExecutionService {
      * @param onProgress Optional callback for progress updates
      */
     executeTest(options: TestExecutionOptions, onProgress?: ProgressCallback): Promise<TestExecutionResult>;
+    /**
+     * Refuse a Docker daemon that runs Windows containers. The executor here is a Linux image
+     * started with Linux commands and mounts, and on a Windows engine a copy of the same tag
+     * may be the Windows image a fleet run pulled, which would fail inside the container. An
+     * unreadable daemon is not refused: the checks that follow report it as before.
+     */
+    private assertLinuxDaemon;
     /**
      * Ensure Docker image is available
      * @param onProgress Optional callback for progress updates during pull

package/build/services/TestExecutionService.js

@@ -474,6 +474,7 @@ export class TestExecutionService {
         const startTime = Date.now();
         const executedAt = new Date().toISOString();
         logger.debug(`Executing test: ${options.testFile}`);
+        await this.assertLinuxDaemon();
         // Check and ensure Docker image is ready with progress reporting
         await onProgress?.({
             phase: "docker-check",
@@ -1036,6 +1037,26 @@ export class TestExecutionService {
             };
         }
     }
+    /**
+     * Refuse a Docker daemon that runs Windows containers. The executor here is a Linux image
+     * started with Linux commands and mounts, and on a Windows engine a copy of the same tag
+     * may be the Windows image a fleet run pulled, which would fail inside the container. An
+     * unreadable daemon is not refused: the checks that follow report it as before.
+     */
+    async assertLinuxDaemon() {
+        let os;
+        try {
+            os = (await this.docker.info())?.OSType;
+        }
+        catch {
+            return;
+        }
+        if (os === "windows") {
+            throw new Error("skyramp_execute_test runs tests in Linux containers, but this Docker daemon runs " +
+                "Windows containers. Switch Docker to Linux containers, or run the test on a " +
+                "Linux Docker host.");
+        }
+    }
     /**
      * Ensure Docker image is available
      * @param onProgress Optional callback for progress updates during pull

package/build/services/TestGenerationService.d.ts

@@ -1,5 +1,5 @@
 import { SkyrampClient } from "@skyramp/skyramp";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolResult } from "@modelcontextprotocol/server";
 import { TestType, MOCK_TYPE } from "../types/TestTypes.js";
 export interface BaseTestParams {
     endpointURL?: string;

package/build/tool-phases.js

@@ -9,12 +9,14 @@ export const TOOL_PHASE_MAP = {
     skyramp_integration_test_generation: "generating",
     skyramp_e2e_test_generation: "generating",
     skyramp_ui_test_generation: "generating",
+    skyramp_ui_load_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_execute_fleet: { before: "maintaining", after: "executing" },
     skyramp_analyze_test_health: "maintaining",
     skyramp_submit_report: "reporting",
 };

package/build/tools/auth/loginTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerLoginTool(server: McpServer): void;

package/build/tools/auth/loginTool.js

@@ -9,11 +9,11 @@ export function registerLoginTool(server) {
 
 Logging into Skyramp provides access to additional platform features and services.
 `,
-        inputSchema: {
+        inputSchema: z.object({
             prompt: z
                 .string()
                 .describe("The prompt user provided to login to Skyramp"),
-        },
+        }),
         _meta: {
             keywords: ["login", "authenticate", "skyramp login"],
         },

package/build/tools/auth/logoutTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerLogoutTool(server: McpServer): void;

package/build/tools/auth/logoutTool.js

@@ -8,11 +8,11 @@ export function registerLogoutTool(server) {
         description: `Logout from Skyramp platform
 
 Logout from Skyramp platform to end your authenticated session.`,
-        inputSchema: {
+        inputSchema: z.object({
             prompt: z
                 .string()
                 .describe("The prompt user provided to logout from Skyramp"),
-        },
+        }),
         _meta: {
             keywords: ["logout", "sign out", "skyramp logout"],
         },

package/build/tools/code-refactor/alignAssertionsTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerAlignAssertionsTool(server: McpServer): void;

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

@@ -32,7 +32,7 @@ export function registerAlignAssertionsTool(server) {
 - For each ${ASSERTION_ENHANCEABLE_TEST_TYPES.join(", ")} test, new or maintained.
 
 Returns the full procedure for that file: read it, then follow every step, including its own verification and completion-line steps.`,
-        inputSchema: alignAssertionsSchema,
+        inputSchema: z.object(alignAssertionsSchema),
     }, async (params) => {
         const { testFile, testType } = params;
         const pathError = requireAbsoluteTestFile(testFile);

package/build/tools/code-refactor/assertionSkillTools.d.ts

@@ -1,3 +1,3 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerAssertionSnapshotTool(server: McpServer): void;
 export declare function registerAssertionVerifyTool(server: McpServer): void;

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

@@ -34,7 +34,7 @@ const sharedSchema = {
 export function registerAssertionSnapshotTool(server) {
     server.registerTool(SNAPSHOT_TOOL_NAME, {
         description: `Record the assertion baseline for a test file BEFORE its assertions are enhanced. Returns no instructions — the \`enhance-assertions\` skill carries those. Call this first, apply the rules, then call ${VERIFY_TOOL_NAME}.`,
-        inputSchema: sharedSchema,
+        inputSchema: z.object(sharedSchema),
     }, async (params) => {
         const refusal = await prepareAssertionCall(params);
         if (refusal)
@@ -59,7 +59,7 @@ export function registerAssertionSnapshotTool(server) {
 export function registerAssertionVerifyTool(server) {
     server.registerTool(VERIFY_TOOL_NAME, {
         description: `Deterministically verify the assertion enhancement of a test file against the baseline ${SNAPSHOT_TOOL_NAME} recorded. Returns PASS, or FAIL with per-violation remediations. Fix every violation and call again until it passes.`,
-        inputSchema: sharedSchema,
+        inputSchema: z.object(sharedSchema),
     }, async (params) => {
         const refusal = await prepareAssertionCall(params);
         if (refusal)

package/build/tools/code-refactor/codeReuseTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerCodeReuseTool(server: McpServer): void;

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

@@ -35,7 +35,7 @@ const codeReuseSchema = z.object({
         .default(false)
         .describe("Verify a previously refactored test instead of returning the reuse prompt. POM path (browser tests): checks the test's POM calls against source; requires the discovery pass — this tool called for the same testFile without `verify` — to have run first. SkyrampUtils path (every other test type): stages the shared utils file for the output commit, checks its invariants, and — when skyramp_modularization recorded a baseline for this spec — compares the delivered assertion count and page.on('pageerror') guard against that hand-out, rejecting a net loss (API helpers: one helper per method+path, status-code-only assertions, method+resource names; browser helpers: actions and structural waits only, intent names, one helper per action sequence; every family: one name is defined once per module, with one parameter count across modules). For a UI test it also checks the repository's own helper modules the test imports: each imported name resolves with an argument count the signature accepts, and every change this run made to such a module adds a helper or a defaulted parameter. Call it after the reuse edits are written; skyramp_enhance_assertions and skyramp_execute_test refuse until it has passed."),
     testType: z
-        .nativeEnum(TestType)
+        .enum(TestType)
         .optional()
         .describe("The type of the test being refactored (shared TestType vocabulary). The tool routes on it server-side: browser types (ui, e2e) may take the POM path; every other type takes the SkyrampUtils path. Omit when unknown."),
     inHouse: z
@@ -406,7 +406,7 @@ export function registerCodeReuseTool(server) {
 
       Applicability is decided by the caller: when a generation result was produced with \`codeReuse: true\`, it directs you here — ALWAYS follow through (a no-op result is a normal outcome, never a failure). Multi-step tests (UI, E2E, INTEGRATION, LOAD) are the ones that benefit; simple single-request tests (smoke, contract, fuzz) do not request code reuse.
       The tool will provide step-by-step instructions that MUST be followed exactly.${pomAwareModeDescription()}`,
-        inputSchema: codeReuseSchema.shape,
+        inputSchema: codeReuseSchema,
         _meta: {
             keywords: [
                 "code reuse",

package/build/tools/code-refactor/enhanceAssertionsTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerEnhanceAssertionsTool(server: McpServer): void;

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

@@ -59,7 +59,7 @@ export function registerEnhanceAssertionsTool(server) {
 - After generating a new supported test file
 - After updating an existing supported test file during maintenance
 - Optionally with \`verify: true\` for early feedback — the same deterministic checks run automatically inside skyramp_execute_test, which returns per-violation feedback instead of executing until they pass.`,
-        inputSchema: enhanceAssertionsSchema,
+        inputSchema: z.object(enhanceAssertionsSchema),
     }, async (params) => {
         // stateFile is threaded through `params` into the shared helpers.
         const { testFile, testType, enhanceType, autoApply, verify } = params;

package/build/tools/code-refactor/modularizationTool.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare function registerModularizationTool(server: McpServer): void;

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

@@ -16,7 +16,7 @@ const modularizationSchema = {
         .string()
         .describe("The test file to process with modularization principles applied"),
     language: z
-        .nativeEnum(ProgrammingLanguage)
+        .enum(ProgrammingLanguage)
         .optional()
         .describe("The programming language of the test file. Inferred from file extension if not provided."),
     testType: z
@@ -45,7 +45,7 @@ export function registerModularizationTool(server) {
 After modularization, if errors remain, ${fixErrorsInstruction()}.
 
 **CRITICAL**: This tool expects you to complete the modularization by writing the refactored code back to the file.`,
-        inputSchema: modularizationSchema,
+        inputSchema: z.object(modularizationSchema),
         _meta: {
             keywords: [
                 "modularization",

package/build/tools/enrichTestWithMocksTool.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
 /**
  * skyramp_enrich_test_with_mocks

package/build/tools/enrichTestWithMocksTool.js

@@ -17,7 +17,7 @@ const enrichSchema = {
         "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)
+        .enum(ProgrammingLanguage)
         .optional()
         .describe("Programming language of the generated test. Optional for backward compatibility; inferred from testFile when omitted. Mock enrichment supports Python, TypeScript, JavaScript, and Java tests."),
     traceComments: z
@@ -41,7 +41,7 @@ export function registerEnrichTestWithMocksTool(server) {
             "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,
+        inputSchema: z.object(enrichSchema),
     }, async (params) => {
         try {
             const { testFile, scenarioName, mockFiles, traceComments, language } = params;