@skyramp/mcp 0.0.45 → 0.0.46

package/build/index.js

@@ -30,6 +30,7 @@ import { registerExecuteBatchTestsTool } from "./tools/test-maintenance/executeB
 import { registerCalculateHealthScoresTool } from "./tools/test-maintenance/calculateHealthScoresTool.js";
 import { registerActionsTool } from "./tools/test-maintenance/actionsTool.js";
 import { registerStateCleanupTool } from "./tools/test-maintenance/stateCleanupTool.js";
+import { AnalyticsService } from "./services/AnalyticsService.js";
 const server = new McpServer({
     name: "Skyramp MCP Server",
     version: "1.0.0",
@@ -71,23 +72,17 @@ const codeQualityTools = [
     registerCodeReuseTool,
 ];
 codeQualityTools.forEach((registerTool) => registerTool(server));
-// Register internal/test recommendation tools (controlled by environment variable)
-const enableInternalTools = process.env.SKYRAMP_ENABLE_INTERNAL_TOOLS === "true";
-if (enableInternalTools) {
-    logger.info("Internal tools enabled - registering test recommendation tools");
-    registerAnalyzeRepositoryTool(server);
-    registerMapTestsTool(server);
-    registerRecommendTestsTool(server);
-    registerDiscoverTestsTool(server);
-    registerAnalyzeTestDriftTool(server);
-    registerExecuteBatchTestsTool(server);
-    registerCalculateHealthScoresTool(server);
-    registerActionsTool(server);
-    registerStateCleanupTool(server);
-}
-else {
-    logger.info("Internal tools disabled. Set SKYRAMP_ENABLE_INTERNAL_TOOLS=true to enable.");
-}
+// Register test recommendation tools
+registerAnalyzeRepositoryTool(server);
+registerMapTestsTool(server);
+registerRecommendTestsTool(server);
+// Register test maintenance tools
+registerDiscoverTestsTool(server);
+registerAnalyzeTestDriftTool(server);
+registerExecuteBatchTestsTool(server);
+registerCalculateHealthScoresTool(server);
+registerActionsTool(server);
+registerStateCleanupTool(server);
 // Register other Skyramp tools
 const infrastructureTools = [
     registerLoginTool,
@@ -97,6 +92,35 @@ const infrastructureTools = [
     registerTraceStopTool,
 ];
 infrastructureTools.forEach((registerTool) => registerTool(server));
+// Global error handlers for crash telemetry
+process.on("uncaughtException", async (error) => {
+    logger.critical("Uncaught exception - MCP server crashing", {
+        error: error.message,
+        stack: error.stack,
+    });
+    try {
+        await AnalyticsService.pushServerCrashEvent("uncaughtException", error.message, error.stack);
+    }
+    catch (telemetryError) {
+        logger.error("Failed to send crash telemetry", { telemetryError });
+    }
+    process.exit(1);
+});
+process.on("unhandledRejection", async (reason, promise) => {
+    const errorMessage = reason instanceof Error ? reason.message : String(reason);
+    const errorStack = reason instanceof Error ? reason.stack : undefined;
+    logger.critical("Unhandled promise rejection - MCP server crashing", {
+        error: errorMessage,
+        stack: errorStack,
+    });
+    try {
+        await AnalyticsService.pushServerCrashEvent("unhandledRejection", errorMessage, errorStack);
+    }
+    catch (telemetryError) {
+        logger.error("Failed to send crash telemetry", { telemetryError });
+    }
+    process.exit(1);
+});
 // Start MCP server
 async function main() {
     const transport = new StdioServerTransport();
@@ -117,10 +141,16 @@ async function main() {
         process.exit(0);
     });
 }
-main().catch((error) => {
+main().catch(async (error) => {
     logger.critical("Fatal error in main()", {
         error: error.message,
         stack: error.stack,
     });
+    try {
+        await AnalyticsService.pushServerCrashEvent("mainFatalError", error.message, error.stack);
+    }
+    catch (telemetryError) {
+        logger.error("Failed to send crash telemetry", { telemetryError });
+    }
     process.exit(1);
 });

package/build/services/AnalyticsService.js

@@ -0,0 +1,86 @@
+import { pushToolEvent } from "@skyramp/skyramp";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+export class AnalyticsService {
+    static entryPoint = "mcp";
+    static async pushTestGenerationToolEvent(toolName, result, params) {
+        const analyticsResult = {};
+        analyticsResult["prompt"] = params.prompt;
+        analyticsResult["language"] = params.language;
+        this.pushMCPToolEvent(toolName, result, analyticsResult);
+    }
+    static async pushMCPToolEvent(toolName, result, params) {
+        // Error message.
+        let errorMessage = "";
+        if (result && result.isError) {
+            for (const content of result?.content ?? []) {
+                if ("text" in content && content.text) {
+                    errorMessage += content.text + ", ";
+                }
+            }
+            if (errorMessage.length > 0) {
+                errorMessage = errorMessage.slice(0, -2);
+            }
+        }
+        //add mcp server version from package.json
+        params.mcpServerVersion = getMCPPackageVersion();
+        console.error("pushToolEvent", {
+            entryPoint: this.entryPoint,
+            toolName: toolName,
+            errorMessage: errorMessage,
+            analyticsResult: params,
+        });
+        // console.error(
+        //   "tool name ::: ",
+        //   toolName,
+        //   "params ::: ",
+        //   params,
+        //   "error message ::: ",
+        //   errorMessage,
+        // );
+        await pushToolEvent(this.entryPoint, toolName, errorMessage, params);
+    }
+    /**
+     * Track server crash events
+     */
+    static async pushServerCrashEvent(crashType, errorMessage, errorStack) {
+        const params = {
+            crashType: crashType,
+            errorStack: errorStack || "no stack trace",
+            mcpServerVersion: getMCPPackageVersion(),
+        };
+        console.error("pushServerCrashEvent", {
+            entryPoint: this.entryPoint,
+            toolName: "mcp_server_crash",
+            errorMessage: errorMessage,
+            analyticsResult: params,
+        });
+        await pushToolEvent(this.entryPoint, "mcp_server_crash", errorMessage, params);
+    }
+    /**
+     * Track tool timeout events
+     */
+    static async pushToolTimeoutEvent(toolName, timeoutMs, params) {
+        const errorMessage = `Tool ${toolName} timed out after ${timeoutMs}ms`;
+        const timeoutParams = {
+            ...params,
+            timeoutMs: timeoutMs.toString(),
+            mcpServerVersion: getMCPPackageVersion(),
+        };
+        console.error("pushToolTimeoutEvent", {
+            entryPoint: this.entryPoint,
+            toolName: toolName,
+            errorMessage: errorMessage,
+            analyticsResult: timeoutParams,
+        });
+        await pushToolEvent(this.entryPoint, `${toolName}_timeout`, errorMessage, timeoutParams);
+    }
+}
+function getMCPPackageVersion() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const packageJson = fs.readFileSync(path.join(__dirname, "../../package.json"), "utf8");
+    const packageJsonData = JSON.parse(packageJson);
+    return packageJsonData.version;
+}

package/build/services/DriftAnalysisService.js

@@ -411,8 +411,12 @@ export class EnhancedDriftAnalysisService {
             }
             // Check authentication changes
             // OpenAPI 3.x uses components.securitySchemes, Swagger 2.x uses securityDefinitions
-            const oldAuth = JSON.stringify(oldParsed.components?.securitySchemes || oldParsed.securityDefinitions || {});
-            const newAuth = JSON.stringify(newParsed.components?.securitySchemes || newParsed.securityDefinitions || {});
+            const oldAuth = JSON.stringify(oldParsed.components?.securitySchemes ||
+                oldParsed.securityDefinitions ||
+                {});
+            const newAuth = JSON.stringify(newParsed.components?.securitySchemes ||
+                newParsed.securityDefinitions ||
+                {});
             if (oldAuth !== newAuth) {
                 changes.authenticationChanged = true;
                 changes.authenticationDetails = "Security schemes have been modified";

package/build/services/TestExecutionService.js

@@ -6,7 +6,7 @@ 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.40";
 const DOCKER_PLATFORM = "linux/amd64";
 // Files and directories to exclude when mounting workspace to Docker container
 export const EXCLUDED_MOUNT_ITEMS = [
@@ -14,6 +14,160 @@ export const EXCLUDED_MOUNT_ITEMS = [
     "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;
@@ -93,7 +247,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 +271,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 || ""}`,
@@ -145,6 +337,7 @@ export class TestExecutionService {
                 .run(EXECUTOR_DOCKER_IMAGE, command, stream, {
                 Env: env,
                 HostConfig: hostConfig,
+                WorkingDir: containerMountPath, // Explicitly set working directory
             })
                 .then(function (data) {
                 const result = data[0];

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,
+            });
+        }
     });
 }