@skyramp/mcp 0.2.6 → 0.2.150-rc.mntnc

package/build/tools/executeSkyrampTestTool.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { stripVTControlCharacters } from "util";
 import { TestExecutionService } from "../services/TestExecutionService.js";
 import { AnalyticsService } from "../services/AnalyticsService.js";
+import { TestExecutionStatus } from "../types/TestExecution.js";
 import { getWorkspaceBaseUrl } from "../utils/workspaceAuth.js";
 import { ProgrammingLanguage, TestType } from "../types/TestTypes.js";
 import { StateManager } from "../utils/AnalysisStateManager.js";
@@ -66,7 +67,11 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
             stateFile: z
                 .string()
                 .optional()
-                .describe("Optional path to state file from skyramp_analyze_changes. When provided, execution results (passed/failed, errors, duration) will be written back to enrich the test health analysis."),
+                .describe("Path to state file from skyramp_analyze_changes. Always pass when available — results are written back so skyramp_submit_report can override before/afterStatus with ground-truth pass/fail."),
+            phase: z
+                .enum(["before", "after"])
+                .optional()
+                .describe("Execution phase for maintained tests: 'before' captures pre-edit baseline; 'after' (default) records post-edit result."),
         },
         _meta: {
             keywords: ["run test", "execute test"],
@@ -147,7 +152,12 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                     if (stateData && stateData.existingTests) {
                         const testIndex = stateData.existingTests.findIndex((t) => t.testFile === params.testFile);
                         if (testIndex >= 0) {
-                            stateData.existingTests[testIndex].execution = result;
+                            if (params.phase === "before") {
+                                stateData.existingTests[testIndex].executionBefore = result;
+                            }
+                            else {
+                                stateData.existingTests[testIndex].executionAfter = result;
+                            }
                             await stateManager.writeData(stateData);
                             logger.info(`Updated stateFile with execution results for ${params.testFile}`);
                         }
@@ -163,7 +173,7 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
             }
             // Progress is already reported by TestExecutionService
             // Only report final status if not already at 100%
-            if (!result.passed) {
+            if (result.status !== TestExecutionStatus.Pass) {
                 errorResult = {
                     content: [
                         {
@@ -177,11 +187,14 @@ For detailed documentation visit: https://www.skyramp.dev/docs/quickstart`,
                 return errorResult;
             }
             // Success - progress already reported by TestExecutionService
+            const videoInfo = result.videoPath
+                ? `\n\nVideo recording: ${result.videoPath}`
+                : "";
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Test execution result: ${stripVTControlCharacters(result.output || "")}`,
+                        text: `Test execution result: ${stripVTControlCharacters(result.output || "")}${videoInfo}`,
                     },
                 ],
             };

package/build/tools/fixErrorTool.d.ts

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

package/build/tools/generate-tests/generateBatchScenarioRestTool.d.ts

@@ -0,0 +1,45 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { HttpMethod } from "../../types/TestTypes.js";
+export declare const stepSchema: z.ZodEffects<z.ZodObject<{
+    method: z.ZodNativeEnum<typeof HttpMethod>;
+    path: z.ZodString;
+    requestBody: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    queryParams: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    responseBody: z.ZodOptional<z.ZodString>;
+    statusCode: z.ZodOptional<z.ZodNumber>;
+    responseHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    method: HttpMethod;
+    queryParams?: string | undefined;
+    statusCode?: number | undefined;
+    requestBody?: string | undefined;
+    responseBody?: string | undefined;
+    responseHeaders?: Record<string, string[]> | undefined;
+}, {
+    path: string;
+    method: HttpMethod;
+    queryParams?: string | undefined;
+    statusCode?: number | undefined;
+    requestBody?: string | undefined;
+    responseBody?: string | undefined;
+    responseHeaders?: Record<string, string[]> | undefined;
+}>, {
+    path: string;
+    method: HttpMethod;
+    queryParams?: string | undefined;
+    statusCode?: number | undefined;
+    requestBody?: string | undefined;
+    responseBody?: string | undefined;
+    responseHeaders?: Record<string, string[]> | undefined;
+}, {
+    path: string;
+    method: HttpMethod;
+    queryParams?: string | undefined;
+    statusCode?: number | undefined;
+    requestBody?: string | undefined;
+    responseBody?: string | undefined;
+    responseHeaders?: Record<string, string[]> | undefined;
+}>;
+export declare function registerBatchScenarioTestTool(server: McpServer): void;

package/build/tools/generate-tests/generateBatchScenarioRestTool.js

@@ -67,7 +67,7 @@ CRITICAL: For search/filter/list endpoints (e.g., GET /products/search?q=bear&li
     responseBody: z
         .string()
         .optional()
-        .describe("JSON string of the expected response body"),
+        .describe("JSON string of the expected response body. For steps that produce an id used by later steps, include that id field with a realistic UUID generated fresh for this scenario — the backend chains by value-matching any subsequent step path or requestBody that contains the same UUID."),
     statusCode: z
         .number()
         .optional()

package/build/tools/generate-tests/generateBatchScenarioRestTool.test.d.ts

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

package/build/tools/generate-tests/generateBatchScenarioRestTool.test.js

@@ -1,10 +1,13 @@
-jest.mock("../../services/ScenarioGenerationService.js", () => ({
+// @ts-nocheck - Jest ESM type inference issues
+import { jest } from "@jest/globals";
+import fs from "fs";
+jest.unstable_mockModule("../../services/ScenarioGenerationService.js", () => ({
     ScenarioGenerationService: jest.fn().mockImplementation(() => ({
         generateTraceRequestFromInput: jest.fn().mockReturnValue(null),
     })),
 }));
-jest.mock("../../services/AnalyticsService.js", () => ({ AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) } }));
-jest.mock("../../utils/workspaceAuth.js", () => ({
+jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({ AnalyticsService: { pushMCPToolEvent: jest.fn().mockResolvedValue(undefined) } }));
+jest.unstable_mockModule("../../utils/workspaceAuth.js", () => ({
     getWorkspaceAuthConfig: jest.fn().mockResolvedValue({ authHeader: undefined, authType: "none" }),
     WorkspaceAuthType: { None: "none" },
     getDefaultAuthHeader: jest.fn().mockReturnValue(""),
@@ -12,10 +15,10 @@ jest.mock("../../utils/workspaceAuth.js", () => ({
     getAuthScheme: jest.fn().mockReturnValue(""),
     readWorkspaceConfigRaw: jest.fn().mockResolvedValue(null),
 }));
-jest.mock("../../utils/logger.js", () => ({ logger: { info: jest.fn(), warning: jest.fn(), error: jest.fn() } }));
-jest.mock("../../prompts/personas.js", () => ({ getPersonaPrefix: () => "" }));
-import fs from "fs";
-import { stepSchema, registerBatchScenarioTestTool } from "./generateBatchScenarioRestTool.js";
+jest.unstable_mockModule("../../utils/logger.js", () => ({ logger: { info: jest.fn(), warning: jest.fn(), error: jest.fn() } }));
+jest.unstable_mockModule("../../prompts/personas.js", () => ({ getPersonaPrefix: () => "" }));
+const { stepSchema, registerBatchScenarioTestTool } = await import("./generateBatchScenarioRestTool.js");
+const { ScenarioGenerationService } = await import("../../services/ScenarioGenerationService.js");
 /** Build a minimal mock McpServer, register the tool, and return the captured handler. */
 function captureHandler() {
     let capturedHandler;
@@ -191,8 +194,7 @@ describe("generateBatchScenarioRestTool — spec path validation (Change 3)", ()
         readFileSyncSpy = jest.spyOn(fs, "readFileSync").mockReturnValue(fakeSpec);
         writeFileSyncSpy = jest.spyOn(fs, "writeFileSync").mockImplementation(() => { });
         // Return a valid trace so tests reach the success path (where the warning is appended)
-        const ScenarioSvc = require("../../services/ScenarioGenerationService.js").ScenarioGenerationService;
-        ScenarioSvc.mockImplementation(() => ({
+        ScenarioGenerationService.mockImplementation(() => ({
             generateTraceRequestFromInput: jest.fn().mockReturnValue({ method: "GET", path: "/mock" }),
         }));
     });

package/build/tools/generate-tests/generateContractRestTool.d.ts

@@ -0,0 +1,31 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+type ContractParams = BaseTestParams & {
+    enhanceAssertions?: boolean;
+    assertOptions?: string;
+    responseData?: string;
+    providerMode?: boolean;
+    consumerMode?: boolean;
+    providerOutput?: string;
+    consumerOutput?: string;
+    parentRequestData?: Record<string, string>;
+    parentStatusCode?: Record<string, string>;
+    parentFormParams?: Record<string, string>;
+    skipProvisionParents?: boolean;
+};
+export declare class ContractTestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+    generateTest(params: ContractParams & Record<string, any>): Promise<CallToolResult>;
+    private buildSampleDataSection;
+    private buildPlaceholderReplacementBlock;
+    private buildSampleDataInstructions;
+    private buildProviderPostGenInstructions;
+    private buildConsumerStubReplacementInstructions;
+    protected validateInputs(params: ContractParams): CallToolResult;
+    protected buildGenerationOptions(params: ContractParams): any;
+}
+export declare function registerContractTestTool(server: McpServer): void;
+export {};

package/build/tools/generate-tests/generateE2ERestTool.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare class E2ETestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    protected buildGenerationOptions(params: BaseTestParams & {
+        responseData?: string;
+        playwrightInput?: string;
+    }): any;
+    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+}
+export declare function registerE2ETestTool(server: McpServer): void;

package/build/tools/generate-tests/generateFuzzRestTool.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
+export declare class FuzzTestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    protected buildGenerationOptions(params: BaseTestParams & {
+        responseData?: string;
+    }): any;
+}
+export declare function registerFuzzTestTool(server: McpServer): void;

package/build/tools/generate-tests/generateIntegrationRestTool.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare class IntegrationTestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    generateTest(params: BaseTestParams & Record<string, any>): Promise<CallToolResult>;
+    private buildAssertionEnhancementInstructions;
+    protected buildGenerationOptions(params: BaseTestParams & {
+        responseData?: string;
+        playwrightInput?: string;
+        scenarioFile?: string;
+    }): any;
+    protected handleApiAnalysis(_params: BaseTestParams): Promise<CallToolResult | null>;
+}
+export declare function registerIntegrationTestTool(server: McpServer): void;

package/build/tools/generate-tests/generateLoadRestTool.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export { loadTestSchema, numericString } from "./loadTestSchema.js";
+export declare class LoadTestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    protected buildGenerationOptions(params: BaseTestParams & {
+        loadCount?: string;
+        loadDuration?: string;
+        loadNumThreads?: string;
+        loadRampupDuration?: string;
+        loadRampupInterval?: string;
+        loadTargetRPS?: string;
+    }): any;
+    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+}
+export declare function registerLoadTestTool(server: McpServer): void;

package/build/tools/generate-tests/generateLoadRestTool.test.d.ts

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

package/build/tools/generate-tests/generateMockRestTool.d.ts

@@ -0,0 +1,64 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService } from "../../services/TestGenerationService.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+type MockParams = {
+    endpointURL?: string;
+    method?: string;
+    apiSchema?: string;
+    responseData?: string;
+    responseStatusCode?: string;
+    requestData?: string;
+    formParams?: string;
+    requestAware?: boolean;
+    trace?: string;
+    mockPort?: number;
+    optionalFields?: boolean;
+    language?: string;
+    framework?: string;
+    output?: string;
+    outputDir: string;
+    force: boolean;
+    deployDashboard?: boolean;
+    runtime?: string;
+    dockerNetwork?: string;
+    dockerWorkerPort?: number;
+    k8sNamespace?: string;
+    k8sConfig?: string;
+    k8sContext?: string;
+    prompt?: string;
+};
+export declare class MockGenerationService extends TestGenerationService {
+    protected getTestType(): TestType;
+    generateTest(params: MockParams & Record<string, any>): Promise<CallToolResult>;
+    private buildReorganizationInstructions;
+    protected buildGenerationOptions(params: MockParams): {
+        uri: string | undefined;
+        method: string | undefined;
+        apiSchema: string[];
+        language: string;
+        framework: string;
+        output: string | undefined;
+        outputDir: string;
+        force: boolean;
+        deployDashboard: boolean | undefined;
+        runtime: string | undefined;
+        dockerNetwork: string | undefined;
+        dockerWorkerPort: string;
+        k8sNamespace: string | undefined;
+        k8sConfig: string | undefined;
+        k8sContext: string | undefined;
+        requestData: string | undefined;
+        responseData: string | undefined;
+        responseStatusCode: string | undefined;
+        formParams: string | undefined;
+        requestAware: boolean | undefined;
+        traceFilePath: string | undefined;
+        entrypoint: string;
+        mockPort: number;
+        optionalFields: boolean;
+    };
+    protected executeGeneration(generateOptions: any): Promise<string>;
+}
+export declare function registerMockTool(server: McpServer): void;
+export {};

package/build/tools/generate-tests/generateSmokeRestTool.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { TestGenerationService, BaseTestParams } from "../../services/TestGenerationService.js";
+export declare class SmokeTestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    protected buildGenerationOptions(params: BaseTestParams): any;
+}
+export declare function registerSmokeTestTool(server: McpServer): void;

package/build/tools/generate-tests/generateUIRestTool.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TestType } from "../../types/TestTypes.js";
+import { BaseTestParams, TestGenerationService } from "../../services/TestGenerationService.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare class UITestService extends TestGenerationService {
+    protected getTestType(): TestType;
+    protected buildGenerationOptions(params: BaseTestParams & {
+        playwrightInput?: string;
+    }): any;
+    protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
+    generateTest(params: BaseTestParams & Record<string, any>): Promise<CallToolResult>;
+    private buildUIPostGenInstructions;
+}
+export declare function registerUITestTool(server: McpServer): void;

package/build/tools/generate-tests/generateUIRestTool.js

@@ -96,7 +96,7 @@ This tells you exactly which frontend files changed so you record traces for the
 
 **Typical pipeline:** Use the \`browser_*\` tools (\`browser_navigate\`, \`browser_click\`, \`browser_type\`, etc.) to record user interactions, then call \`skyramp_export_zip\` to export a trace zip, then pass the absolute path to that zip as \`playwrightInput\` here.
 
-**DOM Analyzer tools for blueprint-aware recording:** alongside the basic \`browser_*\` interaction tools, the Skyramp MCP exposes \`browser_blueprint\` (canonical PageBlueprint capture), \`browser_blueprint_diff\` (structured before/after delta), \`browser_widget_contract_lookup\` (interaction recipe for custom widgets by fingerprint), and the sitemap tools \`browser_sitemap_build\` / \`browser_sitemap_query\`. These enable semantic target selection and delta-derived assertions: capture a blueprint before each meaningful action, perform the action, then capture again — the diff between the two grounds your assertions in observable state changes rather than author guesses about what "success" looks like.
+**DOM Analyzer tools for blueprint-aware recording:** alongside the basic \`browser_*\` interaction tools, the Skyramp MCP exposes \`browser_blueprint\` (canonical PageBlueprint capture). This enables semantic target selection and delta-derived assertions: capture a blueprint before each meaningful action, perform the action, then capture again — the delta between the two grounds your assertions in observable state changes rather than author guesses about what "success" looks like.
 
 **CRITICAL: Do NOT use skyramp_start_trace_collection/skyramp_stop_trace_collection for UI test recording — use browser_* tools + skyramp_export_zip instead.**`,
         inputSchema: uiTestSchema,

package/build/tools/generate-tests/loadTestSchema.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const numericString: (description: string) => z.ZodEffects<z.ZodString, string, string>;
+export declare const loadTestSchema: {
+    loadCount: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    loadDuration: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    loadNumThreads: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    loadRampupDuration: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    loadRampupInterval: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    loadTargetRPS: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
+    trace: z.ZodDefault<z.ZodString>;
+    include: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    endpointURL: z.ZodDefault<z.ZodString>;
+    deployDashboard: z.ZodDefault<z.ZodBoolean>;
+    runtime: z.ZodDefault<z.ZodNativeEnum<typeof import("../../types/TestTypes.js").RuntimeEnvironment>>;
+    dockerNetwork: z.ZodDefault<z.ZodString>;
+    dockerWorkerPort: z.ZodDefault<z.ZodNumber>;
+    k8sNamespace: z.ZodDefault<z.ZodString>;
+    k8sConfig: z.ZodDefault<z.ZodString>;
+    k8sContext: z.ZodDefault<z.ZodString>;
+    authHeader: z.ZodDefault<z.ZodString>;
+    authScheme: z.ZodDefault<z.ZodString>;
+    insecure: z.ZodDefault<z.ZodBoolean>;
+    output: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    outputDir: z.ZodString;
+    force: z.ZodDefault<z.ZodBoolean>;
+    mockPort: z.ZodDefault<z.ZodNumber>;
+    optionalFields: z.ZodDefault<z.ZodBoolean>;
+    prompt: z.ZodString;
+    language: z.ZodNativeEnum<typeof import("../../types/TestTypes.js").ProgrammingLanguage>;
+    framework: z.ZodString;
+    method: z.ZodDefault<z.ZodUnion<[z.ZodNativeEnum<typeof import("../../types/TestTypes.js").HttpMethod>, z.ZodLiteral<"">]>>;
+    apiSchema: z.ZodDefault<z.ZodString>;
+    pathParams: z.ZodDefault<z.ZodString>;
+    queryParams: z.ZodDefault<z.ZodString>;
+    formParams: z.ZodDefault<z.ZodString>;
+    requestData: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+    responseStatusCode: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+};

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

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** User params passed to workflow builder (optional fields may be undefined) */
+export type OneClickParams = {
+    workflow: string;
+    repositoryPath: string;
+    endpointURL?: string;
+    apiSchema?: string;
+    topN?: number;
+    token?: string;
+};
+export declare function registerOneClickTool(server: McpServer): void;