@skyramp/mcp 0.0.45 → 0.0.47

package/build/services/TestExecutionService.js

@@ -6,20 +6,176 @@ import { stripVTControlCharacters } from "util";
 import { logger } from "../utils/logger.js";
 const DEFAULT_TIMEOUT = 300000; // 5 minutes
 const MAX_CONCURRENT_EXECUTIONS = 5;
-const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.2.38";
+const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.2.41";
 const DOCKER_PLATFORM = "linux/amd64";
+const EXECUTION_PROGRESS_INTERVAL = 10000; // 10 seconds between progress updates during execution
 // Files and directories to exclude when mounting workspace to Docker container
 export const EXCLUDED_MOUNT_ITEMS = [
     "package-lock.json",
     "package.json",
     "node_modules",
 ];
+/**
+ * Find the start index of a comment in a line, ignoring comment delimiters inside strings
+ * Returns -1 if no comment is found outside of strings
+ */
+function findCommentStart(line) {
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        const nextChar = i + 1 < line.length ? line[i + 1] : "";
+        // Handle escape sequences
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        // Track string boundaries
+        if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+            continue;
+        }
+        if (char === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+            continue;
+        }
+        // Check for comments only if not in a string
+        if (!inSingleQuote && !inDoubleQuote) {
+            if (char === "/" && nextChar === "/") {
+                return i;
+            }
+            if (char === "#") {
+                return i;
+            }
+        }
+    }
+    return -1; // No comment found
+}
+/**
+ * Filter out comments from code lines
+ * Returns array of non-comment lines with inline comments removed
+ */
+function filterComments(lines) {
+    const nonCommentLines = [];
+    let inMultiLineComment = false;
+    let inPythonMultiLineComment = false;
+    for (let line of lines) {
+        const trimmed = line.trim();
+        // Check for Python multi-line string comments (""" or ''')
+        // Count occurrences to handle single-line strings like '''comment'''
+        const tripleDoubleCount = (trimmed.match(/"""/g) || []).length;
+        const tripleSingleCount = (trimmed.match(/'''/g) || []).length;
+        if (tripleDoubleCount > 0) {
+            // Odd number: opening or closing a multi-line comment (toggle state)
+            // Even number: complete string on same line (e.g., """comment""" - don't toggle)
+            if (tripleDoubleCount % 2 === 1) {
+                inPythonMultiLineComment = !inPythonMultiLineComment;
+            }
+            continue; // Skip any line with triple quotes
+        }
+        if (tripleSingleCount > 0) {
+            if (tripleSingleCount % 2 === 1) {
+                inPythonMultiLineComment = !inPythonMultiLineComment;
+            }
+            continue;
+        }
+        if (inPythonMultiLineComment) {
+            continue;
+        }
+        // Check for multi-line comment start/end (/* */)
+        if (trimmed.includes("/*")) {
+            if (trimmed.includes("*/")) {
+                // Single-line multi-line comment (e.g., /* comment */)
+                // Don't change state, just skip the line
+                continue;
+            }
+            else {
+                // Opening a multi-line comment
+                inMultiLineComment = true;
+                continue;
+            }
+        }
+        if (inMultiLineComment) {
+            if (trimmed.includes("*/")) {
+                inMultiLineComment = false;
+            }
+            continue;
+        }
+        // Skip single-line comments
+        if (trimmed.startsWith("//") || trimmed.startsWith("#")) {
+            continue;
+        }
+        // Remove inline comments from the line before processing
+        // Use helper function to avoid removing comment delimiters inside strings
+        const commentIndex = findCommentStart(line);
+        if (commentIndex >= 0) {
+            line = line.substring(0, commentIndex);
+        }
+        nonCommentLines.push(line);
+    }
+    return nonCommentLines;
+}
+/**
+ * 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
+ */
+function detectSessionFiles(testFilePath) {
+    try {
+        const content = fs.readFileSync(testFilePath, "utf-8");
+        const lines = content.split("\n");
+        const sessionFiles = [];
+        // Pattern for TypeScript/JavaScript: storageState: '/path/to/file' or storageState: "/path/to/file"
+        const tsJsPattern = /storageState:\s*['"]([^'"]+)['"]/g;
+        // Pattern for Python: storage_state='/path/to/file' or storage_state="/path/to/file"
+        const pythonPattern = /storage_state\s*=\s*['"]([^'"]+)['"]/g;
+        // Pattern for Java: setStorageState(Paths.get("path")) or setStorageState("path")
+        // Enforces proper parenthesis matching: first ) is required, second ) is required when using Paths.get
+        const javaPattern = /setStorageState(?:Path)?\s*\(\s*(?:Paths\.get\s*\(\s*)?['"]([^'"]+)['"]\s*\)(?:\s*\))?/g;
+        // Pattern for C#: StorageStatePath = "path" or StorageState = "path"
+        const csharpPattern = /StorageState(?:Path)?\s*=\s*['"]([^'"]+)['"]/g;
+        // Filter out comments
+        const codeLines = filterComments(lines);
+        // Process each non-comment line
+        for (const line of codeLines) {
+            // Try all patterns on this line
+            let match;
+            tsJsPattern.lastIndex = 0;
+            while ((match = tsJsPattern.exec(line)) !== null) {
+                sessionFiles.push(match[1]);
+            }
+            pythonPattern.lastIndex = 0;
+            while ((match = pythonPattern.exec(line)) !== null) {
+                sessionFiles.push(match[1]);
+            }
+            javaPattern.lastIndex = 0;
+            while ((match = javaPattern.exec(line)) !== null) {
+                sessionFiles.push(match[1]);
+            }
+            csharpPattern.lastIndex = 0;
+            while ((match = csharpPattern.exec(line)) !== null) {
+                sessionFiles.push(match[1]);
+            }
+        }
+        return sessionFiles;
+    }
+    catch (error) {
+        logger.error(`Failed to detect session files in ${testFilePath}`, {
+            error,
+        });
+        return [];
+    }
+}
 export class TestExecutionService {
     docker;
-    imageReady;
+    imageReady = null;
     constructor() {
         this.docker = new Docker();
-        this.imageReady = this.ensureDockerImage();
     }
     /**
      * Execute multiple tests in parallel batches
@@ -63,13 +219,42 @@ export class TestExecutionService {
     }
     /**
      * Execute a single test
+     * @param options Test execution options
+     * @param onProgress Optional callback for progress updates
      */
-    async executeTest(options) {
+    async executeTest(options, onProgress) {
         const startTime = Date.now();
         const executedAt = new Date().toISOString();
         logger.debug(`Executing test: ${options.testFile}`);
-        // Wait for Docker image to be ready
-        await this.imageReady;
+        // Check and ensure Docker image is ready with progress reporting
+        await onProgress?.({
+            phase: "docker-check",
+            message: "Checking Docker image availability...",
+            percent: 5,
+        });
+        const imageResult = await this.ensureDockerImage(onProgress);
+        if (imageResult.cached) {
+            await onProgress?.({
+                phase: "docker-check",
+                message: "Using cached Docker image",
+                percent: 20,
+                details: { cached: true },
+            });
+        }
+        else {
+            await onProgress?.({
+                phase: "docker-pull",
+                message: "Docker image pull completed",
+                percent: 20,
+                details: { cached: false },
+            });
+        }
+        // Report preparing phase
+        await onProgress?.({
+            phase: "preparing",
+            message: "Validating workspace and test file...",
+            percent: 25,
+        });
         // Validate workspace path - use accessSync for better validation
         const workspacePath = path.resolve(options.workspacePath);
         try {
@@ -86,6 +271,11 @@ export class TestExecutionService {
         if (!fs.existsSync(options.testFile)) {
             throw new Error(`Test file does not exist: ${options.testFile}`);
         }
+        await onProgress?.({
+            phase: "preparing",
+            message: "Preparing Docker container configuration...",
+            percent: 30,
+        });
         const containerMountPath = "/home/user";
         const dockerSocketPath = "/var/run/docker.sock";
         // Calculate relative test file path
@@ -93,7 +283,7 @@ export class TestExecutionService {
         testFilePath = path.resolve(containerMountPath, testFilePath);
         // Prepare Docker command
         const command = [
-            "./root/runner.sh",
+            "/root/runner.sh",
             options.language,
             testFilePath,
             options.testType,
@@ -117,6 +307,44 @@ export class TestExecutionService {
             Target: path.join(containerMountPath, file),
             Source: path.join(workspacePath, file),
         })));
+        // Detect and mount session files
+        const sessionFiles = detectSessionFiles(options.testFile);
+        const mountedPaths = new Set(); // Track mounted file paths to prevent duplicates
+        for (const sessionFile of sessionFiles) {
+            let sessionFileSource;
+            let sessionFileTarget;
+            if (path.isAbsolute(sessionFile)) {
+                // Absolute path: mount at the same absolute path in container
+                sessionFileSource = sessionFile;
+                sessionFileTarget = sessionFile;
+            }
+            else {
+                // Relative path: resolve from test file directory on host
+                const testFileDir = path.dirname(options.testFile);
+                sessionFileSource = path.resolve(testFileDir, sessionFile);
+                // Mount at the corresponding relative path in the container
+                const testFileDirInContainer = path.dirname(testFilePath);
+                sessionFileTarget = path.resolve(testFileDirInContainer, sessionFile);
+            }
+            // Check if session file exists on host
+            if (fs.existsSync(sessionFileSource)) {
+                // Only mount if we haven't already mounted this path
+                if (!mountedPaths.has(sessionFileTarget)) {
+                    logger.info(` docker run -v ${sessionFileSource}:${sessionFileTarget}:ro ...`);
+                    hostConfig.Mounts?.push({
+                        Type: "bind",
+                        Target: sessionFileTarget,
+                        Source: sessionFileSource,
+                        ReadOnly: true,
+                    });
+                    mountedPaths.add(sessionFileTarget);
+                }
+            }
+            else {
+                logger.error(`✗ Session file not found: ${sessionFileSource}`);
+                logger.error(`  Referenced in test as: ${sessionFile}`);
+            }
+        }
         // Prepare environment variables
         const env = [
             `SKYRAMP_TEST_TOKEN=${options.token || ""}`,
@@ -138,13 +366,40 @@ export class TestExecutionService {
         }
         const stream = new DockerStream();
         try {
+            // Report executing phase
+            await onProgress?.({
+                phase: "executing",
+                message: "Starting test execution in Docker container...",
+                percent: 40,
+            });
             let statusCode = 0;
             let containerRef = null;
+            // Start periodic progress reporter during execution
+            // Runs in parallel with docker.run() to keep the AI agent informed
+            let progressIntervalHandle;
+            if (onProgress) {
+                let progressTick = 0;
+                progressIntervalHandle = setInterval(() => {
+                    progressTick++;
+                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                    // Progress moves from 40% to 79% during execution phase
+                    // Slowly increment to show activity without reaching 80% (reserved for processing)
+                    const percent = Math.min(40 + progressTick * 2, 79);
+                    onProgress({
+                        phase: "executing",
+                        message: `Test running... (${elapsed}s elapsed)`,
+                        percent,
+                    }).catch(() => {
+                        // Ignore progress notification errors
+                    });
+                }, EXECUTION_PROGRESS_INTERVAL);
+            }
             // Run container with timeout
             const executionPromise = this.docker
                 .run(EXECUTOR_DOCKER_IMAGE, command, stream, {
                 Env: env,
                 HostConfig: hostConfig,
+                WorkingDir: containerMountPath, // Explicitly set working directory
             })
                 .then(function (data) {
                 const result = data[0];
@@ -174,14 +429,18 @@ export class TestExecutionService {
             });
             try {
                 statusCode = await Promise.race([executionPromise, timeoutPromise]);
-                // Clear the timeout timer if execution completes successfully
+                // Clear timers on successful completion
                 if (timeoutHandle)
                     clearTimeout(timeoutHandle);
+                if (progressIntervalHandle)
+                    clearInterval(progressIntervalHandle);
             }
             catch (error) {
-                // Clear the timeout timer on any error
+                // Clear all timers on error
                 if (timeoutHandle)
                     clearTimeout(timeoutHandle);
+                if (progressIntervalHandle)
+                    clearInterval(progressIntervalHandle);
                 // Cleanup container on timeout or other errors
                 if (containerRef !== null) {
                     const container = containerRef;
@@ -199,6 +458,12 @@ export class TestExecutionService {
                 }
                 throw error; // Re-throw the original error
             }
+            // Report processing phase
+            await onProgress?.({
+                phase: "processing",
+                message: "Test execution completed, processing results...",
+                percent: 80,
+            });
             const duration = Date.now() - startTime;
             const cleanOutput = stripVTControlCharacters(output);
             logger.info("Test execution completed", {
@@ -222,6 +487,14 @@ export class TestExecutionService {
                 output: cleanOutput,
                 exitCode: statusCode,
             };
+            // Report completion
+            await onProgress?.({
+                phase: "processing",
+                message: result.passed
+                    ? "Test passed successfully"
+                    : "Test execution completed with failures",
+                percent: 100,
+            });
             logger.debug(`Test ${result.passed ? "passed" : "failed"}: ${options.testFile}`);
             return result;
         }
@@ -243,17 +516,25 @@ export class TestExecutionService {
     }
     /**
      * Ensure Docker image is available
+     * @param onProgress Optional callback for progress updates during pull
+     * @returns Object indicating whether image was cached or pulled
      */
-    async ensureDockerImage() {
+    async ensureDockerImage(onProgress) {
         try {
             const images = await this.docker.listImages();
             const imageExists = images.some((img) => (img.RepoTags && img.RepoTags.includes(EXECUTOR_DOCKER_IMAGE)) ||
                 (img.RepoDigests && img.RepoDigests.includes(EXECUTOR_DOCKER_IMAGE)));
             if (imageExists) {
                 logger.debug(`Docker image ${EXECUTOR_DOCKER_IMAGE} already available`);
-                return;
+                return { cached: true };
             }
             logger.info(`Pulling Docker image ${EXECUTOR_DOCKER_IMAGE}...`);
+            await onProgress?.({
+                phase: "docker-pull",
+                message: `Pulling Docker image ${EXECUTOR_DOCKER_IMAGE}...`,
+                percent: 10,
+                details: { cached: false },
+            });
             await new Promise((resolve, reject) => {
                 this.docker.pull(EXECUTOR_DOCKER_IMAGE, { platform: DOCKER_PLATFORM }, (err, stream) => {
                     if (err)
@@ -265,9 +546,39 @@ export class TestExecutionService {
                             return reject(err);
                         logger.info(`Docker image ${EXECUTOR_DOCKER_IMAGE} pulled successfully`);
                         resolve(res);
+                    }, 
+                    // Progress callback for each layer
+                    (event) => {
+                        if (event.status && onProgress) {
+                            const progressMsg = event.progress || event.status;
+                            const layerId = event.id || "";
+                            // Calculate approximate progress (10-19% range during pull)
+                            let percent = 10;
+                            if (event.progressDetail?.current &&
+                                event.progressDetail?.total) {
+                                const layerProgress = event.progressDetail.current / event.progressDetail.total;
+                                percent = 10 + Math.floor(layerProgress * 9); // 10-19%
+                            }
+                            onProgress({
+                                phase: "docker-pull",
+                                message: `${event.status}${layerId ? ` [${layerId}]` : ""}: ${progressMsg}`,
+                                percent,
+                                details: {
+                                    cached: false,
+                                    pullProgress: {
+                                        current: event.progressDetail?.current,
+                                        total: event.progressDetail?.total,
+                                        layer: layerId,
+                                    },
+                                },
+                            }).catch(() => {
+                                // Ignore progress notification errors
+                            });
+                        }
                     });
                 });
             });
+            return { cached: false };
         }
         catch (error) {
             logger.error(`Failed to ensure Docker image: ${error.message}`);

package/build/services/TestHealthService.js

@@ -323,7 +323,8 @@ export class TestHealthService {
                 // If execution data shows failure, escalate
                 if (execution && !execution.passed) {
                     priority = "HIGH";
-                    rationale = "Drift analysis unavailable and test is failing - investigate immediately";
+                    rationale =
+                        "Drift analysis unavailable and test is failing - investigate immediately";
                     estimatedWork = "MEDIUM";
                 }
             }
@@ -331,14 +332,16 @@ export class TestHealthService {
                 // No drift data but test is failing
                 action = "UPDATE";
                 priority = "HIGH";
-                rationale = "Test is failing but drift analysis unavailable - review test logic and dependencies";
+                rationale =
+                    "Test is failing but drift analysis unavailable - review test logic and dependencies";
                 estimatedWork = "MEDIUM";
             }
             else if (execution && execution.passed) {
                 // No drift data but test is passing
                 action = "VERIFY";
                 priority = "LOW";
-                rationale = "Drift analysis unavailable but test is passing - periodic verification recommended";
+                rationale =
+                    "Drift analysis unavailable but test is passing - periodic verification recommended";
                 estimatedWork = "SMALL";
             }
             else {
@@ -566,10 +569,10 @@ export class TestHealthService {
                 }
                 else {
                     // This is a literal path part, escape special regex chars
-                    return part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
                 }
             })
-                .join('');
+                .join("");
             // pathRegexString is already escaped, so we can use it directly
             const pathRegex = new RegExp(pathRegexString);
             const method = endpoint.method.toUpperCase();

package/build/tools/auth/loginTool.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { SkyrampClient } from "@skyramp/skyramp";
 import { logger } from "../../utils/logger.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
+const TOOL_NAME = "skyramp_login";
 export function registerLoginTool(server) {
-    server.registerTool("skyramp_login", {
+    server.registerTool(TOOL_NAME, {
         description: `Login to Skyramp platform 
 
 Logging into Skyramp provides access to additional platform features and services.
@@ -16,6 +18,7 @@ Logging into Skyramp provides access to additional platform features and service
             keywords: ["login", "authenticate", "skyramp login"],
         },
     }, async (params) => {
+        let errorResult;
         logger.info("Logging in to Skyramp", {
             prompt: params.prompt,
         });
@@ -34,7 +37,7 @@ Logging into Skyramp provides access to additional platform features and service
         }
         catch (error) {
             const errorMessage = `Login to Skyramp failed: ${error.message}`;
-            return {
+            errorResult = {
                 content: [
                     {
                         type: "text",
@@ -43,6 +46,13 @@ Logging into Skyramp provides access to additional platform features and service
                 ],
                 isError: true,
             };
+            return errorResult;
+        }
+        finally {
+            const recordParams = {
+                prompt: params.prompt,
+            };
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, recordParams);
         }
     });
 }

package/build/tools/auth/logoutTool.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { SkyrampClient } from "@skyramp/skyramp";
 import { logger } from "../../utils/logger.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
+const TOOL_NAME = "skyramp_logout";
 export function registerLogoutTool(server) {
-    server.registerTool("skyramp_logout", {
+    server.registerTool(TOOL_NAME, {
         description: `Logout from Skyramp platform
 
 Logout from Skyramp platform to end your authenticated session.`,
@@ -15,6 +17,7 @@ Logout from Skyramp platform to end your authenticated session.`,
             keywords: ["logout", "sign out", "skyramp logout"],
         },
     }, async (params) => {
+        let errorResult;
         logger.info("Logging out from Skyramp", {
             prompt: params.prompt,
         });
@@ -32,7 +35,7 @@ Logout from Skyramp platform to end your authenticated session.`,
         }
         catch (error) {
             const errorMessage = `Logout from Skyramp failed: ${error.message}`;
-            return {
+            errorResult = {
                 content: [
                     {
                         type: "text",
@@ -41,6 +44,13 @@ Logout from Skyramp platform to end your authenticated session.`,
                 ],
                 isError: true,
             };
+            return errorResult;
+        }
+        finally {
+            const recordParams = {
+                prompt: params.prompt,
+            };
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, recordParams);
         }
     });
 }

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

@@ -3,6 +3,7 @@ import { logger } from "../../utils/logger.js";
 import { getCodeReusePrompt } from "../../prompts/code-reuse.js";
 import { codeRefactoringSchema, languageSchema, } from "../../types/TestTypes.js";
 import { SKYRAMP_UTILS_HEADER } from "../../utils/utils.js";
+import { AnalyticsService } from "../../services/AnalyticsService.js";
 const codeReuseSchema = z.object({
     testFile: z
         .string()
@@ -14,8 +15,9 @@ const codeReuseSchema = z.object({
         .string()
         .describe("The code content to analyze and optimize for code reuse"),
 });
+const TOOL_NAME = "skyramp_reuse_code";
 export function registerCodeReuseTool(server) {
-    server.registerTool("skyramp_reuse_code", {
+    server.registerTool(TOOL_NAME, {
         description: `Analyzes code for reuse opportunities and enforces code reuse principles. 
       
       This tool helps identify and reuse ONLY EXISTING helper functions from other test files (grep based on "${SKYRAMP_UTILS_HEADER}"). 
@@ -58,19 +60,43 @@ export function registerCodeReuseTool(server) {
             ],
         },
     }, async (params) => {
-        logger.info("Analyzing code for reuse opportunities", {
-            testFile: params.testFile,
-            language: params.language,
-            framework: params.framework,
-        });
-        const codeReusePrompt = getCodeReusePrompt(params.testFile, params.language);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: codeReusePrompt,
-                },
-            ],
-        };
+        let errorResult;
+        try {
+            logger.info("Analyzing code for reuse opportunities", {
+                testFile: params.testFile,
+                language: params.language,
+                framework: params.framework,
+            });
+            const codeReusePrompt = getCodeReusePrompt(params.testFile, params.language);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: codeReusePrompt,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = `Code reuse analysis failed: ${error.message}`;
+            errorResult = {
+                content: [
+                    {
+                        type: "text",
+                        text: errorMessage,
+                    },
+                ],
+                isError: true,
+            };
+            return errorResult;
+        }
+        finally {
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
+                prompt: params.prompt,
+                testFile: params.testFile,
+                language: params.language,
+                framework: params.framework,
+            });
+        }
     });
 }