@skyramp/mcp 0.0.1

package/build/tools/generateE2ERestTool.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { baseSchema, baseTraceSchema } from "../types/TestTypes.js";
+import { TestGenerationService, } from "../services/TestGenerationService.js";
+const e2eTestSchema = {
+    ...baseSchema.shape,
+    ...baseTraceSchema.shape,
+    playwrightInput: z
+        .string()
+        .describe("MUST be absolute path to the playwright input file like  /path/to/playwright-ui-test.zip and MUST be a zip file"),
+};
+export class E2ETestService extends TestGenerationService {
+    getTestType() {
+        return "e2e";
+    }
+    buildGenerationOptions(params) {
+        return {
+            ...super.buildBaseGenerationOptions(params),
+            responseData: params.responseData,
+            playwrightInput: params.playwrightInput,
+        };
+    }
+}
+export function registerEndtoEndTestTool(server) {
+    server.registerTool("skyramp_e2e_test_generation", {
+        description: "Generate an E2E test",
+        inputSchema: e2eTestSchema,
+        annotations: {
+            keywords: ["e2e test", "end-to-end test"],
+        },
+    }, async (params) => {
+        const service = new E2ETestService();
+        return await service.generateTest(params);
+    });
+}

package/build/tools/generateFuzzRestTool.js

@@ -0,0 +1,32 @@
+import { baseTestSchema } from "../types/TestTypes.js";
+import { TestGenerationService, } from "../services/TestGenerationService.js";
+import { z } from "zod";
+const fuzzTestSchema = {
+    ...baseTestSchema,
+    responseData: z
+        .string()
+        .describe("Sample response body data, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)"),
+};
+export class FuzzTestService extends TestGenerationService {
+    getTestType() {
+        return "fuzz";
+    }
+    buildGenerationOptions(params) {
+        return {
+            ...super.buildBaseGenerationOptions(params),
+            responseData: params.responseData,
+        };
+    }
+}
+export function registerFuzzTestTool(server) {
+    server.registerTool("skyramp_fuzz_test_generation", {
+        description: "Generate a fuzz test",
+        inputSchema: fuzzTestSchema,
+        annotations: {
+            keywords: ["negative test", "random test"],
+        },
+    }, async (params) => {
+        const service = new FuzzTestService();
+        return await service.generateTest(params);
+    });
+}

package/build/tools/generateIntegrationRestTool.js

@@ -0,0 +1,29 @@
+import { baseTestSchema, baseTraceSchema, } from "../types/TestTypes.js";
+import { TestGenerationService, } from "../services/TestGenerationService.js";
+const integrationTestSchema = {
+    ...baseTestSchema,
+    trace: baseTraceSchema.shape.trace.optional(),
+    include: baseTraceSchema.shape.include.optional(),
+    exclude: baseTraceSchema.shape.exclude.optional(),
+};
+export class IntegrationTestService extends TestGenerationService {
+    getTestType() {
+        return "integration";
+    }
+    buildGenerationOptions(params) {
+        return {
+            ...super.buildBaseGenerationOptions(params),
+            responseData: params.responseData,
+            playwrightInput: params.playwrightInput,
+        };
+    }
+}
+export function registerIntegrationTestTool(server) {
+    server.registerTool("skyramp_integration_test_generation", {
+        description: "Generate an integration test",
+        inputSchema: integrationTestSchema,
+    }, async (params) => {
+        const service = new IntegrationTestService();
+        return await service.generateTest(params);
+    });
+}

package/build/tools/generateLoadRestTool.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { baseTestSchema, baseTraceSchema, } from "../types/TestTypes.js";
+import { TestGenerationService, } from "../services/TestGenerationService.js";
+const loadTestSchema = {
+    ...baseTestSchema,
+    loadCount: z
+        .string()
+        .optional()
+        .describe("Total number of requests to send during the load test"),
+    loadDuration: z
+        .string()
+        .optional()
+        .describe("Duration of the load test in seconds (default: 5)"),
+    loadNumThreads: z
+        .string()
+        .optional()
+        .describe("Number of concurrent threads/users for the load test (default: 1)"),
+    loadRampupDuration: z
+        .string()
+        .optional()
+        .describe("Time in seconds to gradually increase load to target level"),
+    loadRampupInterval: z
+        .string()
+        .optional()
+        .describe("Interval in seconds between ramping up threads"),
+    loadTargetRPS: z
+        .string()
+        .optional()
+        .describe("Target requests per second for the load test"),
+    trace: baseTraceSchema.shape.trace.optional(),
+    include: baseTraceSchema.shape.include.optional(),
+    exclude: baseTraceSchema.shape.exclude.optional(),
+};
+export class LoadTestService extends TestGenerationService {
+    getTestType() {
+        return "load";
+    }
+    buildGenerationOptions(params) {
+        return {
+            ...super.buildBaseGenerationOptions(params),
+            loadCount: params.loadCount,
+            loadDuration: params.loadDuration,
+            loadNumThreads: params.loadNumThreads,
+            loadRampupDuration: params.loadRampupDuration,
+            loadRampupInterval: params.loadRampupInterval,
+            loadTargetRPS: params.loadTargetRPS,
+        };
+    }
+}
+export function registerLoadTestTool(server) {
+    server.registerTool("skyramp_load_test_generation", {
+        description: "Generate a load test",
+        inputSchema: loadTestSchema,
+        annotations: {
+            keywords: ["load test", "performance test"],
+        },
+    }, async (params) => {
+        const service = new LoadTestService();
+        return await service.generateTest(params);
+    });
+}

package/build/tools/generateSmokeRestTool.js

@@ -0,0 +1,23 @@
+import { baseTestSchema } from "../types/TestTypes.js";
+import { TestGenerationService, } from "../services/TestGenerationService.js";
+// Concrete implementations for each test type
+export class SmokeTestService extends TestGenerationService {
+    getTestType() {
+        return "smoke";
+    }
+    buildGenerationOptions(params) {
+        return super.buildBaseGenerationOptions(params);
+    }
+}
+export function registerSmokeTestTool(server) {
+    server.registerTool("skyramp_smoke_test_generation", {
+        description: "Generate a smoke test",
+        inputSchema: baseTestSchema,
+        annotations: {
+            keywords: ["smoke test", "quick test"],
+        },
+    }, async (params) => {
+        const service = new SmokeTestService();
+        return await service.generateTest(params);
+    });
+}

package/build/tools/generateUIRestTool.js

@@ -0,0 +1,37 @@
+import { baseSchema } from "../types/TestTypes.js";
+import { z } from "zod";
+import { TestGenerationService, } from "../services/TestGenerationService.js";
+export class UITestService extends TestGenerationService {
+    getTestType() {
+        return "ui";
+    }
+    buildGenerationOptions(params) {
+        const options = this.buildBaseGenerationOptions(params);
+        return {
+            ...options,
+            playwrightInput: params.playwrightInput,
+        };
+    }
+    async handleApiAnalysis(params, generateOptions) {
+        return null;
+    }
+}
+// Only include the original params in the schema
+const uiTestSchema = {
+    ...baseSchema.shape,
+    playwrightInput: z
+        .string()
+        .describe("MUST be absolute path to the playwright input file like  /path/to/playwright-ui-test.zip and MUST be a zip file"),
+};
+export function registerUITestTool(server) {
+    server.registerTool("skyramp_ui_test_generation", {
+        description: "Generate an UI test",
+        inputSchema: uiTestSchema,
+        annotations: {
+            keywords: ["ui test", "playwright"],
+        },
+    }, async (params) => {
+        const service = new UITestService();
+        return await service.generateTest(params);
+    });
+}

package/build/tools/startTraceCollectionTool.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { SkyrampClient } from "@skyramp/skyramp";
+import openProxyTerminalTracked from "../utils/proxy-terminal.js";
+import { TELEMETRY_entrypoint_FIELD_NAME } from "../utils/utils.js";
+export function registerTraceTool(server) {
+    server.registerTool("skyramp_start_trace_generation", {
+        description: "Start trace collection",
+        inputSchema: {
+            playwright: z
+                .boolean()
+                .describe("Whether to enable Playwright for trace collection. Set to true for UI interactions, false for API-only tracing")
+                .default(true),
+            runtime: z
+                .string()
+                .describe("Runtime environment for trace collection (docker, kubernetes, etc.). Defaults to docker if not specified")
+                .default("docker"),
+            include: z
+                .array(z.string())
+                .optional()
+                .describe("List of service names or patterns to include in trace collection"),
+            exclude: z
+                .array(z.string())
+                .optional()
+                .describe("List of service names or patterns to exclude from trace collection"),
+            noProxy: z
+                .array(z.string())
+                .optional()
+                .describe("List of hosts or patterns that should bypass proxy during tracing"),
+            dockerNetwork: z
+                .string()
+                .optional()
+                .describe("Docker network name to use for containerized trace collection"),
+            dockerWorkerPort: z
+                .number()
+                .optional()
+                .describe("Port number for the Docker worker service during trace collection"),
+        },
+        annotations: {
+            keywords: ["start trace", "trace collection", "trace generation"],
+        },
+    }, async (params) => {
+        const client = new SkyrampClient();
+        const generateOptions = {
+            testType: "trace",
+            runtime: params.runtime ?? "docker",
+            dockerNetwork: params.dockerNetwork ?? "skyramp",
+            dockerWorkerPort: (params.dockerWorkerPort ?? 35142).toString(),
+            generateInclude: params.include,
+            generateExclude: params.exclude,
+            generateNoProxy: params.noProxy,
+            unblock: true,
+            playwright: params.playwright,
+            entrypoint: TELEMETRY_entrypoint_FIELD_NAME,
+        };
+        try {
+            const result = await client.generateRestTest(generateOptions);
+            await openProxyTerminalTracked();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Trace collection started: ${result}. Please let me know when you are ready to stop the trace collection.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Trace generation failed: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/stopTraceCollectionTool.js

@@ -0,0 +1,86 @@
+import { SkyrampClient } from "@skyramp/skyramp";
+import { closeProxyTerminal } from "../utils/proxy-terminal.js";
+import { z } from "zod";
+import { PLAYWRIGHT_OUTPUT_FILE_FIELD_NAME, TELEMETRY_entrypoint_FIELD_NAME, TRACE_OUTPUT_FILE_FIELD_NAME, validatePath, } from "../utils/utils.js";
+import { logger } from "../utils/logger.js";
+export function registerTraceStopTool(server) {
+    server.registerTool("skyramp_stop_trace_generation", {
+        description: "Stop trace collection",
+        inputSchema: {
+            traceOutputFile: z
+                .string()
+                .describe("MUST be absolute path to save the trace output file (e.g., /path/to/skyramp-traces.json). This file will contain the collected trace data"),
+            playwright: z
+                .boolean()
+                .describe("Whether Playwright was used for trace collection. Must match the setting used when starting trace collection"),
+            playwrightOutput: z
+                .string()
+                .describe("MUST be absolute path to save the Playwright output file (e.g., /path/to/playwright.zip). Only used when playwright is true"),
+        },
+        annotations: {
+            keywords: ["stop trace", "collect generated trace"],
+        },
+    }, async (params) => {
+        const client = new SkyrampClient();
+        try {
+            const stopTraceOptions = {
+                output: params.traceOutputFile ?? "skyramp-traces.json",
+                workerContainerName: "skyramp-trace-worker",
+                playwright: params.playwright ?? false,
+                playwrightOutput: params.playwrightOutput ?? "playwright.zip",
+                entrypoint: TELEMETRY_entrypoint_FIELD_NAME,
+            };
+            let errList = {
+                content: [],
+                isError: true,
+            };
+            if (stopTraceOptions.output == "" &&
+                stopTraceOptions.playwrightOutput == "") {
+                errList.content.push({
+                    type: "text",
+                    text: "Error: Either trace output file or playwright output file is required.",
+                });
+            }
+            logger.debug("Trace collection stop options", {
+                playwright: stopTraceOptions.playwright,
+            });
+            if (!stopTraceOptions.playwright) {
+                logger.info("Playwright disabled for trace collection");
+                stopTraceOptions.playwrightOutput = "";
+            }
+            let err = validatePath(stopTraceOptions.output, TRACE_OUTPUT_FILE_FIELD_NAME);
+            if (err && err.content) {
+                errList.content.push(err.content[0]);
+            }
+            err = validatePath(stopTraceOptions.playwrightOutput, PLAYWRIGHT_OUTPUT_FILE_FIELD_NAME);
+            if (err && err.content) {
+                errList.content.push(err.content[0]);
+            }
+            //if error is not empty, return error
+            if (errList.content.length > 0) {
+                return errList;
+            }
+            await closeProxyTerminal();
+            const result = await client.traceCollect(stopTraceOptions);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Trace collection is stopped: ${result}. Trace is generated to given output file`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Trace generation result: ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/build/types/TestTypes.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+export const baseSchema = z.object({
+    language: z
+        .string()
+        .optional()
+        .describe("Programming language for the generated test (default: python)"),
+    framework: z
+        .string()
+        .optional()
+        .describe("Testing framework to use (e.g., pytest for python, playwright for javascript, junit for java, etc.)"),
+    output: z.string().optional().describe("Name of the output test file"),
+    outputDir: z
+        .string()
+        .describe("MUST be absolute path to the directory where test files will be generated. If not provided, the CURRENT WORKING DIRECTORY will be used WITHOUT ANY SUBDIRECTORIES"),
+    force: z
+        .boolean()
+        .describe("Whether to overwrite existing files in the output directory"),
+    deployDashboard: z
+        .boolean()
+        .optional()
+        .describe("Whether to deploy the Skyramp dashboard for test monitoring"),
+    runtime: z
+        .string()
+        .optional()
+        .describe("Runtime environment (docker, kubernetes, etc.)"),
+    dockerNetwork: z
+        .string()
+        .optional()
+        .describe("Docker network name to use for containerized testing"),
+    dockerWorkerPort: z
+        .number()
+        .optional()
+        .describe("Port number for the Docker worker service"),
+    k8sNamespace: z
+        .string()
+        .optional()
+        .describe("Kubernetes namespace for deployment"),
+    k8sConfig: z
+        .string()
+        .optional()
+        .describe("Path to Kubernetes configuration file"),
+    k8sContext: z.string().optional().describe("Kubernetes context to use"),
+    authHeader: z
+        .string()
+        .optional()
+        .describe("Authorization header value for authenticated requests"),
+    insecure: z
+        .boolean()
+        .optional()
+        .describe("Whether to allow insecure SSL connections for HTTPS endpoints"),
+});
+export const baseTraceSchema = z.object({
+    ...baseSchema.shape,
+    trace: z
+        .string()
+        .describe("MUST be absolute path to trace file for test generation like /path/to/trace.json and MUST be a json file"),
+    include: z
+        .array(z.string())
+        .optional()
+        .describe("List of endpoints or patterns to include in test generation"),
+    exclude: z
+        .array(z.string())
+        .optional()
+        .describe("List of endpoints or patterns to exclude from test generation"),
+});
+// Base schema that all test tools share
+export const baseTestSchema = {
+    ...baseSchema.shape,
+    endpointURL: z
+        .string()
+        .optional()
+        .describe("The endpoint URL to test (e.g., https://api.example.com/v1/products)"),
+    method: z
+        .string()
+        .optional()
+        .describe("HTTP method to use (GET, POST, PUT, DELETE, etc.)"),
+    apiSchema: z
+        .string()
+        .optional()
+        .describe("MUST be absolute path to the OpenAPI/Swagger schema file"),
+    pathParams: z
+        .string()
+        .optional()
+        .describe("MUST be string of comma separated values like 'id=1,name=John' for URL path parameters"),
+    queryParams: z
+        .string()
+        .optional()
+        .describe("MUST be string of comma separated values like 'id=1,name=John' for URL query parameters"),
+    formParams: z
+        .string()
+        .optional()
+        .describe("MUST be string of comma separated values like 'id=1,name=John' for form data parameters"),
+    requestData: z
+        .string()
+        .optional()
+        .describe("Sample request body data, provided either as an inline JSON/YAML string or as an absolute file path prefixed with '@' (e.g., @/absolute/path/to/file)."),
+    responseStatusCode: z
+        .string()
+        .optional()
+        .describe("Expected HTTP response status code (e.g., '200', '201', '404')"),
+};

package/build/utils/analyze-openapi.js

@@ -0,0 +1,25 @@
+import { SkyrampClient } from "@skyramp/skyramp";
+import { IsValidKeyValueList } from "./utils.js";
+// Analyze OpenAPI to check for required path params
+export async function analyzeOpenAPIWithGivenEndpoint(apiSchemaInput, uriInput, pathParamsInput) {
+    const client = new SkyrampClient();
+    const analyzeOpenapiOptions = {
+        apiSchema: apiSchemaInput,
+        uri: uriInput,
+    };
+    const pathParamRequired = await client.analyzeOpenapi(analyzeOpenapiOptions);
+    if (IsValidKeyValueList(pathParamRequired)) {
+        const requiredPathParams = pathParamRequired
+            ? pathParamRequired.split(",").map((p) => p.trim())
+            : [];
+        let providedPathParams = pathParamsInput
+            ? pathParamsInput.split(",").map((param) => param.split("=")[0].trim())
+            : [];
+        // Find missing path parameters by comparing keys
+        let missingPathParams = requiredPathParams.filter((param) => !providedPathParams.includes(param));
+        if (missingPathParams.length > 0) {
+            return `${missingPathParams.join(", ")}`;
+        }
+    }
+    return null;
+}

package/build/utils/logger.js

@@ -0,0 +1,38 @@
+export class McpLogger {
+    loggerName;
+    constructor(loggerName = "skyramp-mcp") {
+        this.loggerName = loggerName;
+    }
+    sendLogMessage(level, message, data) {
+        // MCP servers should use console.error for logging to stderr per MCP spec
+        // This ensures logs are properly captured by MCP clients and don't interfere
+        // with the JSON-RPC protocol communication on stdout
+        const timestamp = new Date().toISOString();
+        const logEntry = {
+            timestamp,
+            level: level.toUpperCase(),
+            logger: this.loggerName,
+            message,
+            ...(data && { data }),
+        };
+        // Use console.error for structured logging (this goes to stderr)
+        console.error(JSON.stringify(logEntry));
+    }
+    debug(message, data) {
+        this.sendLogMessage("debug", message, data);
+    }
+    info(message, data) {
+        this.sendLogMessage("info", message, data);
+    }
+    warning(message, data) {
+        this.sendLogMessage("warning", message, data);
+    }
+    error(message, data) {
+        this.sendLogMessage("error", message, data);
+    }
+    critical(message, data) {
+        this.sendLogMessage("critical", message, data);
+    }
+}
+// Export singleton instance
+export const logger = new McpLogger();