@skyramp/mcp 0.0.39 → 0.0.40

package/build/prompts/startTraceCollectionPrompts.js

@@ -16,6 +16,22 @@ export function registerStartTraceCollectionPrompt(mcpServer) {
 * Once you have all the data call the start trace generation tool to start the trace collection.
 * Always ask user if they want to enable playwright for trace collection.
 
+**Playwright Configuration Options:**
+When playwright is enabled for trace collection, you can optionally configure:
+
+1. **Playwright Storage Path** (playwrightStoragePath):
+   - Path to a playwright session storage file containing authentication data (cookies, localStorage, sessionStorage, etc.)
+   - MUST be an absolute path like /path/to/storage.json
+   - Use this when you have manually created a session from the login flow and want to reuse it for future trace collections to avoid manual login every time
+   - The session file should be created beforehand using Playwright's storageState feature during the login flow
+
+2. **Playwright Viewport Size** (playwrightViewportSize):
+   - Defines the browser window size for trace collection
+   - Supported formats:
+     * 'hd' - 1280x720
+     * 'full-hd' - 1920x1080
+     * '2k' - 2560x1440
+     * Custom: 'width,height' (e.g., '1920,1080')
 
 **Example usage prompt for trace collection:**
 * To start a trace collection session using agent, run the following command:
@@ -25,6 +41,9 @@ export function registerStartTraceCollectionPrompt(mcpServer) {
 * To start a playwright trace collection session using agent, run the following command:
   Start playwright trace collection with default settings.
 
+**Example usage prompt for trace collection with playwright storage and viewport:**
+* Start playwright trace collection with storage path /Users/dev/session-storage.json and viewport size full-hd
+
 **CRITICAL: NEVER SHOW THE CLI COMMANDS.**
 `,
                 },

package/build/tools/executeSkyrampTestTool.js

@@ -5,7 +5,7 @@ import { Writable } from "stream";
 import { logger } from "../utils/logger.js";
 import { stripVTControlCharacters } from "util";
 import fs from "fs";
-const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.2.29";
+const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.2.30";
 const DOCKER_PLATFORM = "linux/amd64";
 export function registerExecuteSkyrampTestTool(server) {
     server.registerTool("skyramp_execute_test", {

package/build/tools/trace/startTraceCollectionTool.js

@@ -3,6 +3,7 @@ import { SkyrampClient } from "@skyramp/skyramp";
 import openProxyTerminalTracked from "../../utils/proxy-terminal.js";
 import { TELEMETRY_entrypoint_FIELD_NAME } from "../../utils/utils.js";
 import { logger } from "../../utils/logger.js";
+import { basePlaywrightSchema } from "../../types/TestTypes.js";
 export function registerTraceTool(server) {
     server.registerTool("skyramp_start_trace_collection", {
         description: `Start trace collection using Skyramp's comprehensive tracing capabilities.
@@ -26,6 +27,8 @@ For detailed documentation visit: https://www.skyramp.dev/docs/load-test/advance
                 .boolean()
                 .describe("Whether to enable Playwright for trace collection. Set to true for UI interactions, false for API-only tracing")
                 .default(true),
+            playwrightStoragePath: basePlaywrightSchema.shape.playwrightStoragePath,
+            playwrightViewportSize: basePlaywrightSchema.shape.playwrightViewportSize,
             runtime: z
                 .string()
                 .default("docker")
@@ -79,6 +82,8 @@ For detailed documentation visit: https://www.skyramp.dev/docs/load-test/advance
             generateNoProxy: params.noProxy,
             unblock: true,
             playwright: params.playwright,
+            playwrightStoragePath: params.playwrightStoragePath,
+            playwrightViewportSize: params.playwrightViewportSize,
             entrypoint: TELEMETRY_entrypoint_FIELD_NAME,
         };
         try {

package/build/types/TestTypes.js

@@ -65,6 +65,19 @@ export const baseSchema = z.object({
         .describe("Whether to overwrite existing files in the output directory"),
     prompt: z.string().describe("The prompt user provided to generate the test"),
 });
+export const basePlaywrightSchema = z.object({
+    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 captured using start_trace_collection tool"),
+    playwrightStoragePath: z
+        .string()
+        .optional()
+        .describe("Path to playwright session storage for trace collection with playwright enabled. THE PATH MUST BE AN ABSOLUTE PATH LIKE /Users/<path>/<filename>.json"),
+    playwrightViewportSize: z
+        .string()
+        .optional()
+        .describe("Viewport size for playwright browser. THE VALUE MUST BE IN THE FORMAT [hd, full-hd, 2k, 'x,y' e.g. '1920,1080' for 1920x1080 resolution]"),
+});
 export const baseTraceSchema = z.object({
     trace: z
         .string()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "main": "build/index.js",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.11.4",
-    "@skyramp/skyramp": "^1.2.29",
+    "@skyramp/skyramp": "^1.2.30",
     "@playwright/test": "^1.55.0",
     "dockerode": "^4.0.6",
     "zod": "^3.25.3"

package/build/tools/__tests__/codeReuseTool.test.js

@@ -1,266 +0,0 @@
-import { describe, it, expect, beforeEach, jest } from "@jest/globals";
-import { registerCodeReuseTool } from "../code-refactor/codeReuseTool.js";
-import { getCodeReusePrompt } from "../../prompts/code-reuse.js";
-// Mock the logger
-jest.mock("../../utils/logger", () => ({
-    logger: {
-        info: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn(),
-        debug: jest.fn(),
-    },
-}));
-// Mock the prompt function
-jest.mock("../../prompts/code-reuse", () => ({
-    getCodeReusePrompt: jest.fn(),
-}));
-describe("Code Reuse Tool", () => {
-    let mockServer;
-    let mockRegisterTool;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockRegisterTool = jest.fn();
-        mockServer = {
-            registerTool: mockRegisterTool,
-        };
-        getCodeReusePrompt.mockReturnValue("Mocked prompt content");
-    });
-    describe("Tool Registration", () => {
-        it("should register the code reuse tool with correct configuration", () => {
-            registerCodeReuseTool(mockServer);
-            expect(mockRegisterTool).toHaveBeenCalledWith("skyramp_code_reuse", expect.objectContaining({
-                description: expect.stringContaining("Analyzes code for reuse opportunities"),
-                inputSchema: expect.objectContaining({
-                    testFile: expect.any(Object),
-                    language: expect.any(Object),
-                    framework: expect.any(Object),
-                    modularizeCode: expect.any(Object),
-                    prompt: expect.any(Object),
-                }),
-                annotations: expect.objectContaining({
-                    keywords: expect.arrayContaining([
-                        "code reuse",
-                        "duplicate code",
-                        "helper functions",
-                        "import",
-                        "refactor",
-                    ]),
-                }),
-            }), expect.any(Function));
-        });
-    });
-    describe("Tool Execution", () => {
-        let toolHandler;
-        beforeEach(() => {
-            registerCodeReuseTool(mockServer);
-            toolHandler = mockRegisterTool.mock.calls[0][2];
-        });
-        it("should handle valid input parameters correctly", async () => {
-            const params = {
-                testFile: "/path/to/test.spec.ts",
-                language: "typescript",
-                framework: "playwright",
-                modularizeCode: true,
-                prompt: "Test code content to analyze",
-            };
-            const result = await toolHandler(params);
-            expect(getCodeReusePrompt).toHaveBeenCalledWith(params.testFile, params.language, params.modularizeCode);
-            expect(result).toEqual({
-                content: [
-                    {
-                        type: "text",
-                        text: expect.stringContaining("Mocked prompt content"),
-                    },
-                ],
-            });
-            expect(result.content[0].text).toContain(params.testFile);
-            expect(result.content[0].text).toContain(params.language);
-            expect(result.content[0].text).toContain(params.framework);
-            expect(result.content[0].text).toContain(params.prompt);
-        });
-        it("should include analysis instructions in the output", async () => {
-            const params = {
-                testFile: "/path/to/test.spec.ts",
-                language: "typescript",
-                framework: "playwright",
-                modularizeCode: false,
-                prompt: "Code to analyze",
-            };
-            const result = await toolHandler(params);
-            const outputText = result.content[0].text;
-            expect(outputText).toContain("ANALYSIS INSTRUCTIONS");
-            expect(outputText).toContain("search for existing test files using glob_file_search");
-            expect(outputText).toContain("Read existing test files to identify reusable helper functions");
-            expect(outputText).toContain("Import and reuse existing functions instead of duplicating code");
-            expect(outputText).toContain("DO NOT modify existing utility files");
-        });
-        it("should handle different frameworks", async () => {
-            const frameworks = ["playwright", "jest", "pytest", "junit"];
-            for (const framework of frameworks) {
-                const params = {
-                    testFile: "/path/to/test.spec.ts",
-                    language: "typescript",
-                    framework,
-                    modularizeCode: false,
-                    prompt: "Test framework code",
-                };
-                const result = await toolHandler(params);
-                expect(result.content[0].text).toContain(`Framework: ${framework}`);
-            }
-        });
-        it("should handle modularizeCode flag variations", async () => {
-            const modularizeOptions = [true, false];
-            for (const modularizeCode of modularizeOptions) {
-                const params = {
-                    testFile: "/path/to/test.spec.ts",
-                    language: "typescript",
-                    framework: "playwright",
-                    modularizeCode,
-                    prompt: "Code content",
-                };
-                await toolHandler(params);
-                expect(getCodeReusePrompt).toHaveBeenCalledWith(params.testFile, params.language, modularizeCode);
-            }
-        });
-        it("should format output with proper sections", async () => {
-            const params = {
-                testFile: "/path/to/integration.test.ts",
-                language: "typescript",
-                framework: "playwright",
-                modularizeCode: true,
-                prompt: "Integration test code with potential reuse opportunities",
-            };
-            const result = await toolHandler(params);
-            const outputText = result.content[0].text;
-            // Check for proper section formatting
-            expect(outputText).toContain("CODE TO ANALYZE");
-            expect(outputText).toContain("ANALYSIS INSTRUCTIONS");
-            expect(outputText).toMatch(/═+/); // Section separators
-            expect(outputText).toContain("📝"); // Emoji indicators
-            expect(outputText).toContain("🎯"); // Analysis emoji
-        });
-        it("should include specific reuse categories in instructions", async () => {
-            const params = {
-                testFile: "/path/to/ui.test.ts",
-                language: "typescript",
-                framework: "playwright",
-                modularizeCode: true,
-                prompt: "UI test with authentication and form filling",
-            };
-            const result = await toolHandler(params);
-            const outputText = result.content[0].text;
-            expect(outputText).toContain("authentication");
-            expect(outputText).toContain("HTTP request");
-            expect(outputText).toContain("data setup");
-            expect(outputText).toContain("validation");
-            expect(outputText).toContain("utility functions");
-        });
-    });
-    describe("Input Validation", () => {
-        let toolHandler;
-        beforeEach(() => {
-            registerCodeReuseTool(mockServer);
-            toolHandler = mockRegisterTool.mock.calls[0][2];
-        });
-        it("should handle minimal required parameters", async () => {
-            const minimalParams = {
-                testFile: "/path/to/test.ts",
-                language: "typescript",
-                framework: "jest",
-                modularizeCode: false,
-                prompt: "Basic test code",
-            };
-            const result = await toolHandler(minimalParams);
-            expect(result.content).toHaveLength(1);
-            expect(result.content[0].type).toBe("text");
-        });
-        it("should preserve all input parameters in output", async () => {
-            const params = {
-                testFile: "/complex/path/to/advanced.test.ts",
-                language: "typescript",
-                framework: "playwright",
-                modularizeCode: true,
-                prompt: "Complex test code with multiple helper functions and duplicate patterns",
-            };
-            const result = await toolHandler(params);
-            const outputText = result.content[0].text;
-            expect(outputText).toContain(params.testFile);
-            expect(outputText).toContain(params.language);
-            expect(outputText).toContain(params.framework);
-            expect(outputText).toContain(params.prompt);
-        });
-    });
-    describe("Error Handling", () => {
-        let toolHandler;
-        beforeEach(() => {
-            registerCodeReuseTool(mockServer);
-            toolHandler = mockRegisterTool.mock.calls[0][2];
-        });
-        it("should handle errors in prompt generation gracefully", async () => {
-            getCodeReusePrompt.mockImplementation(() => {
-                throw new Error("Prompt generation failed");
-            });
-            const params = {
-                testFile: "/path/to/test.ts",
-                language: "typescript",
-                framework: "jest",
-                modularizeCode: false,
-                prompt: "Test code",
-            };
-            await expect(toolHandler(params)).rejects.toThrow("Prompt generation failed");
-        });
-    });
-    describe("Integration with Prompt System", () => {
-        let toolHandler;
-        beforeEach(() => {
-            registerCodeReuseTool(mockServer);
-            toolHandler = mockRegisterTool.mock.calls[0][2];
-        });
-        it("should call getCodeReusePrompt with correct parameters", async () => {
-            const params = {
-                testFile: "/src/tests/api.test.ts",
-                language: "typescript",
-                framework: "jest",
-                modularizeCode: true,
-                prompt: "API test code",
-            };
-            await toolHandler(params);
-            expect(getCodeReusePrompt).toHaveBeenCalledTimes(1);
-            expect(getCodeReusePrompt).toHaveBeenCalledWith(params.testFile, params.language, params.modularizeCode);
-        });
-        it("should integrate prompt content with tool-specific instructions", async () => {
-            const mockPromptContent = "Custom analysis instructions from prompt";
-            getCodeReusePrompt.mockReturnValue(mockPromptContent);
-            const params = {
-                testFile: "/test/example.ts",
-                language: "typescript",
-                framework: "playwright",
-                modularizeCode: false,
-                prompt: "Example code",
-            };
-            const result = await toolHandler(params);
-            const outputText = result.content[0].text;
-            expect(outputText).toContain(mockPromptContent);
-            expect(outputText).toContain("Read test file /test/example.ts");
-        });
-    });
-    describe("Tool Metadata", () => {
-        it("should have appropriate keywords for discoverability", () => {
-            registerCodeReuseTool(mockServer);
-            const toolConfig = mockRegisterTool.mock.calls[0][1];
-            const keywords = toolConfig.annotations.keywords;
-            expect(keywords).toContain("code reuse");
-            expect(keywords).toContain("duplicate code");
-            expect(keywords).toContain("helper functions");
-            expect(keywords).toContain("import");
-            expect(keywords).toContain("refactor");
-        });
-        it("should have a descriptive tool description", () => {
-            registerCodeReuseTool(mockServer);
-            const toolConfig = mockRegisterTool.mock.calls[0][1];
-            expect(toolConfig.description).toContain("Analyzes code for reuse opportunities");
-            expect(toolConfig.description).toContain("duplicate code patterns");
-            expect(toolConfig.description).toContain("importing and reusing existing helper functions");
-        });
-    });
-});