@skyramp/mcp 0.2.6 → 0.2.7

package/build/services/AnalyticsService.test.js

@@ -0,0 +1,86 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+// AnalyticsService resolves the MCP version with
+// `fileURLToPath(import.meta.url)` at module scope. Under ts-jest's old
+// CommonJS transform that top-level import.meta failed to compile with TS1343,
+// so this module — and therefore this test — could not exist. The native-ESM
+// Jest config (SKYR-3799) is what makes it loadable.
+// pushToolEvent lives in @skyramp/skyramp, which pulls the native dylib. Mock
+// it so we can assert on the event payload without loading the binary. Under
+// native ESM jest.mock is not hoisted — use unstable_mockModule + dynamic
+// import of the subject below.
+const pushToolEvent = jest.fn();
+jest.unstable_mockModule("@skyramp/skyramp", () => ({ pushToolEvent }));
+jest.unstable_mockModule("../utils/telemetry.js", () => ({
+    getEntryPoint: jest.fn(() => "mcp"),
+    getCIPlatform: jest.fn(() => undefined),
+    getRepositoryInfo: jest.fn(async () => ({})),
+}));
+jest.unstable_mockModule("../utils/logger.js", () => ({
+    logger: { info: jest.fn(), error: jest.fn(), debug: jest.fn(), warn: jest.fn() },
+}));
+const { AnalyticsService } = await import("./AnalyticsService.js");
+const telemetry = await import("../utils/telemetry.js");
+// The version the production code should resolve: package.json two levels up
+// from this module's own location — the same lookup getMCPPackageVersion does
+// via import.meta.url. Computing it the same way here proves the test harness
+// itself supports import.meta now.
+const expectedVersion = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8")).version;
+describe("AnalyticsService — import.meta-based version resolution", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        telemetry.getEntryPoint.mockReturnValue("mcp");
+        telemetry.getCIPlatform.mockReturnValue(undefined);
+        telemetry.getRepositoryInfo.mockResolvedValue({});
+    });
+    it("stamps the package.json version (resolved via import.meta.url) into the event params", async () => {
+        const params = {};
+        await AnalyticsService.pushMCPToolEvent("skyramp_smoke_test_generation", undefined, params);
+        expect(pushToolEvent).toHaveBeenCalledTimes(1);
+        const [, toolName, , sentParams] = pushToolEvent.mock.calls[0];
+        expect(toolName).toBe("skyramp_smoke_test_generation");
+        expect(sentParams.mcpServerVersion).toBe(expectedVersion);
+        // Sanity: a real semver-ish string, not an empty/undefined fallback.
+        expect(sentParams.mcpServerVersion).toMatch(/^\d+\.\d+\.\d+/);
+    });
+    it("concatenates error text from an isError result into the event error message", async () => {
+        const result = {
+            isError: true,
+            content: [
+                { type: "text", text: "first failure" },
+                { type: "text", text: "second failure" },
+            ],
+        };
+        await AnalyticsService.pushMCPToolEvent("skyramp_execute_test", result, {});
+        const [, , errorMessage] = pushToolEvent.mock.calls[0];
+        expect(errorMessage).toBe("first failure, second failure");
+    });
+    it("sends an empty error message for a successful result", async () => {
+        const result = { isError: false, content: [{ type: "text", text: "ok" }] };
+        await AnalyticsService.pushMCPToolEvent("skyramp_execute_test", result, {});
+        const [, , errorMessage] = pushToolEvent.mock.calls[0];
+        expect(errorMessage).toBe("");
+    });
+    it("includes ciPlatform in the params when running in CI", async () => {
+        telemetry.getCIPlatform.mockReturnValue("github_actions");
+        const params = {};
+        await AnalyticsService.pushMCPToolEvent("skyramp_init_workspace", undefined, params);
+        const [, , , sentParams] = pushToolEvent.mock.calls[0];
+        expect(sentParams.ciPlatform).toBe("github_actions");
+    });
+    it("merges repository info into the params", async () => {
+        telemetry.getRepositoryInfo.mockResolvedValue({ repoName: "letsramp/mcp", repoOwner: "letsramp" });
+        const params = { repositoryPath: "/repo" };
+        await AnalyticsService.pushMCPToolEvent("skyramp_analyze_changes", undefined, params);
+        expect(telemetry.getRepositoryInfo).toHaveBeenCalledWith("/repo");
+        const [, , , sentParams] = pushToolEvent.mock.calls[0];
+        expect(sentParams.repoName).toBe("letsramp/mcp");
+    });
+    it("swallows errors from pushToolEvent (telemetry must never break a tool call)", async () => {
+        pushToolEvent.mockRejectedValueOnce(new Error("network down"));
+        await expect(AnalyticsService.pushMCPToolEvent("skyramp_smoke_test_generation", undefined, {})).resolves.toBeUndefined();
+    });
+});

package/build/services/ModularizationService.d.ts

@@ -0,0 +1,11 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export interface ModularizationParams {
+    testFile: string;
+    testType?: string;
+    language?: string;
+    isTraceBased?: boolean;
+    prompt?: string;
+}
+export declare class ModularizationService {
+    processModularizationRequest(params: ModularizationParams): Promise<CallToolResult>;
+}

package/build/services/ScenarioGenerationService.d.ts

@@ -0,0 +1,37 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export interface TraceRequest {
+    Source: string;
+    Destination: string;
+    RequestBody: string;
+    ResponseBody: string;
+    RequestHeaders: Record<string, string[]>;
+    ResponseHeaders: Record<string, string[]>;
+    Method: string;
+    Path: string;
+    QueryParams: Record<string, string[]>;
+    StatusCode: number;
+    Port: number;
+    Timestamp: string;
+    Scheme: string;
+}
+export interface ScenarioParams {
+    scenarioName: string;
+    destination: string;
+    apiSchema?: string;
+    baseURL?: string;
+    method: string;
+    path: string;
+    requestBody?: string;
+    queryParams?: string;
+    responseBody?: string;
+    statusCode?: number;
+    outputDir: string;
+    authHeader?: string;
+    authScheme?: string;
+    authToken?: string;
+    responseHeaders?: Record<string, string[]>;
+}
+export declare class ScenarioGenerationService {
+    parseScenario(params: ScenarioParams): Promise<CallToolResult>;
+    generateTraceRequestFromInput(params: ScenarioParams): TraceRequest | null;
+}

package/build/services/ScenarioGenerationService.integration.test.d.ts

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

package/build/services/ScenarioGenerationService.integration.test.js

@@ -4,10 +4,14 @@
  *
  * Requires: @skyramp/skyramp native dylib (skips if not available)
  */
+import { jest } from "@jest/globals";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { createRequire } from "module";
 import { ScenarioGenerationService } from "./ScenarioGenerationService.js";
+// Native dylib is a CommonJS addon — load it via createRequire under ESM.
+const require = createRequire(import.meta.url);
 let SkyrampClient;
 try {
     SkyrampClient = require("@skyramp/skyramp").SkyrampClient;

package/build/services/ScenarioGenerationService.test.d.ts

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

package/build/services/TestDiscoveryService.d.ts

@@ -0,0 +1,128 @@
+import { TestAnalysisResult } from "../types/TestAnalysis.js";
+interface TestDiscoveryResult {
+    tests: TestAnalysisResult[];
+    /** Paths of external files that were deemed relevant to the PR (score > 0). */
+    relevantExternalTestPaths: string[];
+}
+export interface TestDiscoveryOptions {
+    /**
+     * Resource names derived from endpoints in changed files (e.g. ["orders", "products"]).
+     * - Non-empty array: external files partitioned by relevance; only relevant files
+     *   get full endpoint extraction. May be the sentinel `["unknown"]` when endpoints
+     *   exist but resource names are unresolvable — treated as "endpoints present" to
+     *   avoid skipping external coverage. Also used for "add field" PRs where the changed
+     *   files have no endpoint definitions but the scanner found related endpoints nearby.
+     * - Empty array `[]`: PR mode with no endpoints from diff or scanner — external
+     *   tests are skipped entirely to avoid flooding context.
+     * - `undefined`: full-repo mode — external tests capped at MAX_EXTERNAL_FULL_REPO.
+     */
+    changedResources?: string[];
+}
+export declare class TestDiscoveryService {
+    private readonly EXCLUDED_DIRS;
+    private readonly SKYRAMP_MARKER;
+    private readonly SUPPORTED_EXTENSIONS;
+    private readonly MAX_CONCURRENT_OPERATIONS;
+    private readonly MAX_EXTERNAL_FULL_REPO;
+    private readonly TEST_FILE_PATTERNS;
+    private readonly TEST_DIR_PATTERNS;
+    /**
+     * Discover all tests under testDir — both Skyramp-generated and external (user-written).
+     * Uses fast-glob for cross-platform file scanning, then classifies discovered files
+     * as Skyramp-generated tests, external tests, or not-a-test during processing.
+     *
+     * External test handling depends on `options.changedResources`:
+     * - `string[]` with entries (PR mode, endpoints detected): partition by relevance.
+     * - `[]` empty array (PR mode, scanner found no endpoints): skip external tests entirely
+     *   rather than flooding context with irrelevant files.
+     * - `undefined` (full-repo mode, no diff): cap at MAX_EXTERNAL_FULL_REPO.
+     */
+    discoverTests(testDir: string, options?: TestDiscoveryOptions): Promise<TestDiscoveryResult>;
+    /**
+     * Score an external test file's relevance to a set of changed resource names.
+     * Tokenises the last two segments of the file path (split by /, \, -, _, .)
+     * and counts overlapping tokens with the changed resources.
+     * Example: "test_orders_api.py" vs ["orders"] → score 1.
+     */
+    private scoreRelevance;
+    /**
+     * Partition external test files into relevant (score > 0) and low-relevance (score = 0)
+     * based on file path/name overlap with the changed resource names from the PR diff.
+     */
+    private partitionByRelevance;
+    /**
+     * Process test files in parallel batches with concurrency control
+     * @param isExternal When true, uses external test metadata extraction
+     * @param contentCache Optional pre-read file contents from classification pass
+     */
+    private processFilesInBatches;
+    /**
+     * Classify candidate files as skyramp (has marker), external (test file without
+     * marker), or not-a-test. Caches file contents so downstream metadata extraction
+     * doesn't need to re-read from disk.
+     */
+    private classifyTestFiles;
+    /**
+     * Check if a file is an external (non-Skyramp) test file based on naming convention
+     * or directory placement.
+     */
+    private isExternalTestFile;
+    /**
+     * Extract metadata from a test file
+     * File is already confirmed to contain Skyramp marker by file search
+     * @param cachedContent Optional pre-read content from classification pass
+     */
+    private extractTestMetadata;
+    /**
+     * Extract the HTTP methods and paths covered by this test file.
+     * Returns a comma-separated string like "GET /orders/{id}, DELETE /orders/{id}".
+     * Handles Python (send_request / check_schema) and TypeScript/JS (sendRequest).
+     */
+    private extractCoveredEndpoints;
+    /**
+     * Extract metadata from an external (non-Skyramp) test file.
+     * Uses heuristic patterns for endpoint extraction, test type, and framework detection.
+     * @param cachedContent Optional pre-read content from classification pass
+     */
+    private extractExternalTestMetadata;
+    /**
+     * Extract HTTP endpoints from external (non-Skyramp) test files.
+     * Matches common patterns: requests.get, axios.post, fetch, supertest, RestAssured.
+     */
+    private extractExternalEndpoints;
+    /**
+     * Normalize an endpoint path extracted from test code.
+     * Strips base URL prefixes and returns only the path portion.
+     * Returns null if the path doesn't look like an API endpoint.
+     */
+    private normalizeEndpointPath;
+    /**
+     * Detect test type from external test file path and content.
+     * Falls back to directory/filename heuristics since external tests lack Skyramp command lines.
+     */
+    private detectExternalTestType;
+    /**
+     * Detect test framework from external test file content by checking imports.
+     */
+    private detectExternalFramework;
+    /**
+     * Detect programming language from file extension
+     */
+    private detectLanguage;
+    /**
+     * Detect test type from file content and name
+     * Checks Skyramp command line, filename, and content patterns
+     */
+    private detectTestType;
+    /**
+     * Extract API schema path from test content
+     * Looks for Skyramp command line first, then fallback to other patterns
+     */
+    private extractApiSchema;
+    /**
+     * Extract Framework from test content
+     * Looks for Skyramp command line first, then fallback to other patterns
+     */
+    private extractFramework;
+}
+export {};

package/build/services/TestDiscoveryService.test.d.ts

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

package/build/services/TestDiscoveryService.test.js

@@ -1,10 +1,12 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
 // Mock heavy dependencies
 jest.mock("simple-git", () => ({
     simpleGit: jest.fn(() => ({
         checkIsRepo: jest.fn().mockResolvedValue(false),
     })),
 }));
-jest.mock("../utils/logger.js", () => ({
+jest.unstable_mockModule("../utils/logger.js", () => ({
     logger: {
         info: jest.fn(),
         debug: jest.fn(),
@@ -14,12 +16,11 @@ jest.mock("../utils/logger.js", () => ({
 }));
 // fast-glob must return real file paths from the temp directory.
 // We use the real implementation by not mocking it.
-// Jest resolves .js → .ts via moduleNameMapper in jest.config.
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-import { TestDiscoveryService } from "./TestDiscoveryService.js";
 import { TestSource } from "../types/TestAnalysis.js";
+const { TestDiscoveryService } = await import("./TestDiscoveryService.js");
 describe("TestDiscoveryService", () => {
     let service;
     let tmpDir;

package/build/services/TestExecutionService.d.ts

@@ -0,0 +1,46 @@
+import { TestExecutionResult, BatchExecutionResult, TestExecutionOptions, ProgressCallback } from "../types/TestExecution.js";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.28";
+export declare const PLAYWRIGHT_CONFIG_FILES: string[];
+export declare const EXCLUDED_MOUNT_ITEMS: string[];
+export declare const MOUNT_NULL_ITEMS: string[];
+/**
+ * Detect session file paths referenced in test files
+ * Looks for storageState patterns in TypeScript/JavaScript/Python/Java/C# test files
+ * Excludes matches found in comments
+ *
+ * Also handles the codegen pattern `path.join(__dirname, '<filename>')` (TS/JS) —
+ * the filename is resolved relative to the test file's directory on the host so
+ * the existing absolute-path mount branch makes it visible at the same path
+ * inside the container (Playwright's TS loader resolves __dirname to the host
+ * workspace path at runtime).
+ */
+export declare function detectSessionFiles(testFilePath: string): string[];
+export declare class TestExecutionService {
+    private docker;
+    private imageReady;
+    constructor();
+    /**
+     * Execute multiple tests in parallel batches
+     */
+    executeBatch(testOptions: TestExecutionOptions[]): Promise<BatchExecutionResult>;
+    /**
+     * Execute a single test
+     * @param options Test execution options
+     * @param onProgress Optional callback for progress updates
+     */
+    executeTest(options: TestExecutionOptions, onProgress?: ProgressCallback): Promise<TestExecutionResult>;
+    /**
+     * Ensure Docker image is available
+     * @param onProgress Optional callback for progress updates during pull
+     * @returns Object indicating whether image was cached or pulled
+     */
+    private ensureDockerImage;
+    /**
+     * Parse errors from test output
+     */
+    private parseErrors;
+    /**
+     * Parse warnings from test output
+     */
+    private parseWarnings;
+}

package/build/services/TestExecutionService.test.d.ts

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

package/build/services/TestExecutionService.test.js

@@ -1,28 +1,43 @@
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
 import { buildContainerEnv, rewriteLocalhostForDocker } from "./containerEnv.js";
 // Mock dockerode before importing TestExecutionService
 const mockRun = jest.fn();
 const mockListImages = jest.fn();
-jest.mock("dockerode", () => {
-    return jest.fn().mockImplementation(() => ({
+jest.unstable_mockModule("dockerode", () => ({
+    default: jest.fn().mockImplementation(() => ({
         run: mockRun,
         listImages: mockListImages,
-    }));
+    })),
+}));
+// Get actual fs for spreading, then mock specific methods
+const actualFs = await import("fs");
+const mockAccessSync = jest.fn();
+const mockExistsSync = jest.fn().mockReturnValue(true);
+const mockReaddirSync = jest.fn().mockImplementation((_path, options) => {
+    if (options?.withFileTypes) {
+        return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
+    }
+    return ["test_file.py"];
 });
-// Mock fs for workspace/file validation
-jest.mock("fs", () => ({
-    ...jest.requireActual("fs"),
-    accessSync: jest.fn(),
-    existsSync: jest.fn().mockReturnValue(true),
-    readdirSync: jest.fn().mockImplementation((_path, options) => {
-        if (options?.withFileTypes) {
-            return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
-        }
-        return ["test_file.py"];
-    }),
-    readFileSync: jest.fn().mockReturnValue(""),
+const mockReadFileSync = jest.fn().mockReturnValue("");
+jest.unstable_mockModule("fs", () => ({
+    ...actualFs,
+    default: {
+        ...actualFs.default,
+        accessSync: mockAccessSync,
+        existsSync: mockExistsSync,
+        readdirSync: mockReaddirSync,
+        readFileSync: mockReadFileSync,
+        constants: actualFs.default.constants,
+    },
+    accessSync: mockAccessSync,
+    existsSync: mockExistsSync,
+    readdirSync: mockReaddirSync,
+    readFileSync: mockReadFileSync,
 }));
 // Mock logger
-jest.mock("../utils/logger.js", () => ({
+jest.unstable_mockModule("../utils/logger.js", () => ({
     logger: {
         debug: jest.fn(),
         info: jest.fn(),
@@ -145,12 +160,9 @@ describe("buildContainerEnv", () => {
 describe("detectSessionFiles", () => {
     // Import after mocks are set up so the fs mock applies
     let detectSessionFiles;
-    let mockReadFileSync;
     beforeAll(async () => {
         const mod = await import("./TestExecutionService.js");
         detectSessionFiles = mod.detectSessionFiles;
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        mockReadFileSync = require("fs").readFileSync;
     });
     it("detects string-literal storageState (TS/JS)", () => {
         mockReadFileSync.mockReturnValueOnce(`test.use({ storageState: '/abs/path/session.json' });`);
@@ -258,9 +270,7 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
     // resolve correctly inside the executor regardless of which path-shape the
     // codegen happens to emit.
     it("mirrors each workspace file mount at both /home/user/<f> and the host-absolute path", async () => {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const fs = require("fs");
-        fs.readdirSync.mockImplementation((_path, options) => {
+        mockReaddirSync.mockImplementation((_path, options) => {
             if (options?.withFileTypes) {
                 return [
                     { name: "xdr_dashboard.spec.ts", isFile: () => true, isDirectory: () => false },
@@ -288,9 +298,7 @@ describe("TestExecutionService.executeTest - Docker env forwarding", () => {
         expect(targets).toContain("/Users/pedro/projects/cisco-xdr-tests/skyramp_session_storage.json");
     });
     it("does not double-mount when workspacePath equals /home/user", async () => {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const fs = require("fs");
-        fs.readdirSync.mockImplementation((_path, options) => {
+        mockReaddirSync.mockImplementation((_path, options) => {
             if (options?.withFileTypes) {
                 return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
             }

package/build/services/TestGenerationService.d.ts

@@ -0,0 +1,56 @@
+import { SkyrampClient } from "@skyramp/skyramp";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { TestType } from "../types/TestTypes.js";
+export interface BaseTestParams {
+    endpointURL?: string;
+    method?: string;
+    apiSchema?: string;
+    language?: string;
+    framework?: string;
+    output?: string;
+    outputDir: string;
+    force: boolean;
+    deployDashboard?: boolean;
+    runtime?: string;
+    dockerNetwork?: string;
+    dockerWorkerPort?: number;
+    k8sNamespace?: string;
+    k8sConfig?: string;
+    k8sContext?: string;
+    authHeader?: string;
+    authScheme?: string;
+    pathParams?: string;
+    queryParams?: string;
+    formParams?: string;
+    requestData?: string;
+    responseStatusCode?: string;
+    trace?: string;
+    include?: string[];
+    exclude?: string[];
+    insecure?: boolean;
+    prompt?: string;
+    codeReuse?: boolean;
+    modularizeCode?: boolean;
+    chainingKey?: string;
+    scenarioFile?: string;
+    mockPort?: number;
+    optionalFields?: boolean;
+}
+export declare abstract class TestGenerationService {
+    protected client: SkyrampClient;
+    constructor();
+    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 handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+    private static readonly STANDARD_HEADERS;
+    private static simpleWildcardMatch;
+    private static traceMatchesFilters;
+    protected extractAuthFromTrace(traceFilePath: string, include?: string[], exclude?: string[]): {
+        authHeader: string;
+        authScheme: string;
+    } | null;
+    protected executeGeneration(generateOptions: any): Promise<string>;
+    protected buildBaseGenerationOptions(params: BaseTestParams): any;
+}

package/build/services/TestGenerationService.test.d.ts

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

package/build/services/TestGenerationService.test.js

@@ -1,14 +1,18 @@
-// Mock @skyramp/skyramp before importing TestGenerationService to avoid
-// pulling in playwright (dynamic imports fail on Node 18 in CI).
-jest.mock("@skyramp/skyramp", () => ({
-    SkyrampClient: jest.fn().mockImplementation(() => ({})),
-}));
-import { TestGenerationService } from "./TestGenerationService.js";
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
 import { TestType } from "../types/TestTypes.js";
 import { AUTH_PLACEHOLDER_TOKEN } from "../types/TestTypes.js";
 import fs from "fs";
 import os from "os";
 import path from "path";
+// Mock @skyramp/skyramp before importing TestGenerationService to avoid
+// pulling in playwright (dynamic imports fail on Node 18 in CI). Under native
+// ESM, jest.mock is not hoisted — use unstable_mockModule + dynamic import.
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({})),
+}));
+const { TestGenerationService, BaseTestParams } = await import("./TestGenerationService.js");
+const { SkyrampClient } = await import("@skyramp/skyramp");
 class StubService extends TestGenerationService {
     buildGenerationOptions() {
         return {};
@@ -87,7 +91,6 @@ describe("TestGenerationService — authType/authScheme not passed to library",
     let mockGenerateRestTest;
     beforeEach(() => {
         mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        const { SkyrampClient } = require("@skyramp/skyramp");
         SkyrampClient.mockImplementation(() => ({
             generateRestTest: mockGenerateRestTest,
         }));
@@ -333,7 +336,6 @@ describe("TestGenerationService — trace-based auth in executeGeneration", () =
     let tmpDir;
     beforeEach(() => {
         mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        const { SkyrampClient } = require("@skyramp/skyramp");
         SkyrampClient.mockImplementation(() => ({
             generateRestTest: mockGenerateRestTest,
         }));

package/build/services/containerEnv.d.ts

@@ -0,0 +1,14 @@
+import { TestExecutionOptions } from "../types/TestExecution.js";
+/**
+ * Rewrite localhost / 127.0.0.1 URLs to host.docker.internal so the Docker
+ * executor container can reach services running on the host machine.
+ *
+ * Only applied when NOT using host networking (bridge mode), because in bridge
+ * mode the container's localhost is its own loopback, not the host's.
+ * host.docker.internal is mapped via ExtraHosts in TestExecutionService.
+ */
+export declare function rewriteLocalhostForDocker(url: string): string;
+/**
+ * Build the environment variable array for the Docker executor container.
+ */
+export declare function buildContainerEnv(options: Pick<TestExecutionOptions, "token" | "language" | "useHostNetwork">, saveStoragePath?: string, hostEnv?: Record<string, string | undefined>): string[];

package/build/tool-phase-coverage.test.d.ts

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

package/build/tool-phase-coverage.test.js

@@ -1,6 +1,8 @@
 import { TOOL_PHASE_MAP, TOOLS_WITHOUT_PHASE } from "./tool-phases.js";
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function findAllToolNames() {
     const toolNames = [];
     function walk(dir) {

package/build/tool-phases.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Canonical mapping of Skyramp MCP tool names to testbot progress phases.
+ *
+ * The testbot progress UI reads this map at runtime to know which tool calls
+ * correspond to which progress steps. When adding or renaming tools, update
+ * this map so the progress UI stays accurate.
+ *
+ * Tools not in this map must be listed in TOOLS_WITHOUT_PHASE.
+ *
+ * Phases: analyzing, generating, executing, maintaining, reporting
+ *
+ * ## Static vs context-dependent mappings
+ *
+ * - **Static** (`string`): the tool always maps to this phase.
+ * - **Context-dependent** (`{ before, after }`): the phase depends on whether
+ *   the "generating" boundary has been crossed. The consumer tracks a boolean
+ *   flag (`generationSeen`), initially `false`. When any tool in
+ *   `GENERATING_TOOLS` is encountered, set `generationSeen = true`.
+ *   - While `generationSeen` is `false`, resolve to the `before` phase.
+ *   - Once `generationSeen` is `true`, resolve to the `after` phase.
+ *
+ *   Example: `skyramp_execute_test` maps to `{ before: "maintaining", after: "executing" }`.
+ *   Before any generation tool is seen, execution calls are part of
+ *   maintenance (baseline runs). After generation, they are final test execution.
+ *
+ *   Reset `generationSeen` to `false` at the start of each session/run.
+ */
+export type PhaseMapping = string | {
+    before: string;
+    after: string;
+};
+export declare const TOOL_PHASE_MAP: Record<string, PhaseMapping>;
+/** Tools whose phase depends on context — listed here for consumer discovery. */
+export declare const CONTEXT_DEPENDENT_TOOLS: Set<string>;
+/** All tools that belong to the "generating" phase — used as the boundary. */
+export declare const GENERATING_TOOLS: Set<string>;
+/** Tools that intentionally have no progress phase (infrastructure/utility). */
+export declare const TOOLS_WITHOUT_PHASE: Set<string>;

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

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

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

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

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

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

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

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

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

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