@debugg-ai/debugg-ai-mcp 1.0.51 → 1.0.53

package/dist/index.js

@@ -23,16 +23,13 @@ import { config } from "./config/index.js";
 import { initTools, getTools, getTool } from "./tools/index.js";
 import { resolveProjectContext } from "./services/projectContext.js";
 import { Logger, validateInput, createErrorResponse, toMCPError, handleConfigurationError, Telemetry, TelemetryEvents, } from "./utils/index.js";
-// Initialize logger
-const logger = new Logger({ module: 'main' });
-/**
- * Initialize MCP Server with configuration
- */
+// Logger and server are initialized lazily in main() to avoid triggering
+// config loading at module load time. If config validation fails (bad env vars),
+// the error is caught by main()'s try-catch instead of crashing before any
+// error handling is set up.
+let logger;
+let server;
 function createMCPServer() {
-    logger.info('Initializing DebuggAI MCP Server', {
-        name: config.server.name,
-        version: config.server.version
-    });
     return new Server({
         name: config.server.name,
         version: config.server.version,
@@ -45,7 +42,6 @@ function createMCPServer() {
         },
     });
 }
-const server = createMCPServer();
 /**
  * Create progress callback for tool execution
  */
@@ -76,75 +72,70 @@ function createProgressCallback(progressToken) {
     };
 }
 /**
- * Handle tool execution requests with proper validation and error handling
+ * Register MCP request handlers. Called in main() after server is created.
  */
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-    const typedReq = req;
-    const requestId = `req_${Date.now()}`;
-    const requestLogger = logger.child({ requestId });
-    requestLogger.info("Received tool call request", {
-        toolName: typedReq.params.name,
-        hasProgressToken: !!typedReq.params._meta?.progressToken,
-        progressToken: typedReq.params._meta?.progressToken,
-        progressTokenType: typeof typedReq.params._meta?.progressToken
-    });
-    const { name, arguments: args } = typedReq.params;
-    const progressToken = typedReq.params._meta?.progressToken;
-    // Unknown tool is a protocol error - throw directly so SDK returns JSON-RPC error
-    const tool = getTool(name);
-    if (!tool) {
-        requestLogger.warn(`Tool not found: ${name}`);
-        throw new Error(`Unknown tool: ${name}`);
-    }
-    try {
-        // Validate input using the tool's schema
-        const validatedInput = validateInput(tool.inputSchema, args, name);
-        // Create tool context
-        const context = {
-            progressToken: typeof progressToken === 'string' ? progressToken : undefined,
-            requestId,
-            timestamp: new Date(),
-        };
-        // Create progress callback
-        const progressCallback = createProgressCallback(typeof progressToken === 'string' || typeof progressToken === 'number' ? String(progressToken) : undefined);
-        // Execute tool handler with progress callback
-        requestLogger.info(`Executing tool: ${name}`);
-        const toolStart = Date.now();
-        const result = await tool.handler(validatedInput, context, progressCallback);
-        const toolDuration = Date.now() - toolStart;
-        requestLogger.info(`Tool execution completed: ${name}`);
-        Telemetry.capture(TelemetryEvents.TOOL_EXECUTED, { toolName: name, durationMs: toolDuration, success: true });
-        return result;
-    }
-    catch (error) {
-        // Validation and execution errors are tool execution errors (isError: true)
-        // so the model can self-correct
-        const mcpError = toMCPError(error, 'tool execution');
-        requestLogger.error('Tool execution failed', {
-            errorCode: mcpError.code,
-            message: mcpError.message,
-            data: mcpError.data
+function registerHandlers() {
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const typedReq = req;
+        const requestId = `req_${Date.now()}`;
+        const requestLogger = logger.child({ requestId });
+        requestLogger.info("Received tool call request", {
+            toolName: typedReq.params.name,
+            hasProgressToken: !!typedReq.params._meta?.progressToken,
+            progressToken: typedReq.params._meta?.progressToken,
+            progressTokenType: typeof typedReq.params._meta?.progressToken
         });
-        Telemetry.capture(TelemetryEvents.TOOL_FAILED, { toolName: name, errorCode: mcpError.code });
-        return createErrorResponse(mcpError, typedReq.params.name);
-    }
-});
-/**
- * Handle list tools requests
- */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const tools = getTools();
-    logger.info('Tools list requested', { toolCount: tools.length });
-    return {
-        tools: tools,
-    };
-});
+        const { name, arguments: args } = typedReq.params;
+        const progressToken = typedReq.params._meta?.progressToken;
+        const tool = getTool(name);
+        if (!tool) {
+            requestLogger.warn(`Tool not found: ${name}`);
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        try {
+            const validatedInput = validateInput(tool.inputSchema, args, name);
+            const context = {
+                progressToken: typeof progressToken === 'string' ? progressToken : undefined,
+                requestId,
+                timestamp: new Date(),
+            };
+            const progressCallback = createProgressCallback(typeof progressToken === 'string' || typeof progressToken === 'number' ? String(progressToken) : undefined);
+            requestLogger.info(`Executing tool: ${name}`);
+            const toolStart = Date.now();
+            const result = await tool.handler(validatedInput, context, progressCallback);
+            const toolDuration = Date.now() - toolStart;
+            requestLogger.info(`Tool execution completed: ${name}`);
+            Telemetry.capture(TelemetryEvents.TOOL_EXECUTED, { toolName: name, durationMs: toolDuration, success: true });
+            return result;
+        }
+        catch (error) {
+            const mcpError = toMCPError(error, 'tool execution');
+            requestLogger.error('Tool execution failed', {
+                errorCode: mcpError.code,
+                message: mcpError.message,
+                data: mcpError.data
+            });
+            Telemetry.capture(TelemetryEvents.TOOL_FAILED, { toolName: name, errorCode: mcpError.code });
+            return createErrorResponse(mcpError, typedReq.params.name);
+        }
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = getTools();
+        logger.info('Tools list requested', { toolCount: tools.length });
+        return { tools };
+    });
+}
 /**
  * Main server initialization and startup
  */
 async function main() {
     try {
-        // Log startup information
+        // Initialize logger and server here (not at module load time) so config
+        // validation errors are caught by this try-catch instead of crashing.
+        logger = new Logger({ module: 'main' });
+        server = createMCPServer();
+        // Register request handlers (they reference the `server` variable)
+        registerHandlers();
         logger.info('Starting DebuggAI MCP Server', {
             nodeVersion: process.version,
             platform: process.platform,
@@ -198,27 +189,43 @@ async function main() {
         throw handleConfigurationError(error);
     }
 }
+/**
+ * Safe log helper — falls back to stderr if logger isn't initialized yet
+ * (e.g. config validation failed before logger was created).
+ */
+function safeLog(level, message, meta) {
+    try {
+        if (logger) {
+            logger[level](message, meta);
+            return;
+        }
+    }
+    catch {
+        // Logger init failed (config validation error) — fall through to stderr
+    }
+    process.stderr.write(`[${level.toUpperCase()}] ${message} ${meta ? JSON.stringify(meta) : ''}\n`);
+}
 /**
  * Handle graceful shutdown
  */
 process.on('SIGINT', async () => {
-    logger.info('Received SIGINT, shutting down gracefully');
+    safeLog('info', 'Received SIGINT, shutting down gracefully');
     await Telemetry.shutdown();
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
-    logger.info('Received SIGTERM, shutting down gracefully');
+    safeLog('info', 'Received SIGTERM, shutting down gracefully');
     await Telemetry.shutdown();
     process.exit(0);
 });
 process.on('unhandledRejection', (reason) => {
-    logger.error('Unhandled promise rejection', {
+    safeLog('error', 'Unhandled promise rejection', {
         error: reason instanceof Error ? reason.message : String(reason),
         stack: reason instanceof Error ? reason.stack : undefined,
     });
 });
 process.on('uncaughtException', (error) => {
-    logger.error('Uncaught exception', {
+    safeLog('error', 'Uncaught exception', {
         error: error.message,
         stack: error.stack,
     });
@@ -227,9 +234,9 @@ process.on('uncaughtException', (error) => {
  * Start the server
  */
 main().catch((error) => {
-    logger.error('Fatal error during startup', {
+    safeLog('error', 'Fatal error during startup', {
         error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : undefined
+        stack: error instanceof Error ? error.stack : undefined,
     });
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {

package/dist/services/ngrok/index.js

@@ -1,198 +0,0 @@
-import { existsSync, promises } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { isError } from './error.js';
-const { readFile } = promises;
-import { mkdirp } from 'mkdirp';
-import { authtoken, connect, disconnect, getApi, kill } from 'ngrok';
-import download from 'ngrok/download';
-import { parse } from 'yaml';
-// ES module compatible __dirname
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// Use empty string to let ngrok use its default binary location  
-const basePath = '';
-export const binPath = () => basePath;
-const DEFAULT_CONFIG_PATH = join(__dirname, 'ngrok-config.yml');
-const getConfigPath = () => {
-    return DEFAULT_CONFIG_PATH;
-};
-const getConfig = async () => {
-    const configPath = getConfigPath();
-    try {
-        const config = parse(await readFile(configPath, 'utf8'));
-        if (config && typeof config.authtoken !== 'undefined') {
-            await authtoken({ authtoken: config.authtoken, binPath });
-        }
-        return config;
-    }
-    catch (error) {
-        if (isError(error) && error.code === 'ENOENT') {
-            if (configPath !== DEFAULT_CONFIG_PATH) {
-                console.error(`Could not find config file at ${configPath}.`);
-                error.message = `Could not find config file at ${configPath}`;
-                throw error;
-            }
-        }
-        else {
-            console.error(`Could not parse config file at ${configPath}.`);
-            throw error;
-        }
-    }
-};
-const tunnelsFromConfig = (tunnels) => {
-    return Object.keys(tunnels).map((tunnelName) => {
-        return {
-            label: tunnelName,
-            tunnelOptions: { name: tunnelName, ...tunnels[tunnelName] },
-        };
-    });
-};
-const getActiveTunnels = async (api) => {
-    const response = await api.listTunnels();
-    return response.tunnels;
-};
-export const start = async (options) => {
-    const config = await getConfig();
-    const tunnel = options;
-    if (typeof tunnel !== 'undefined') {
-        const configPath = getConfigPath();
-        if (existsSync(configPath)) {
-            tunnel.configPath = configPath;
-        }
-        try {
-            // Let ngrok use default binPath if ours is empty
-            if (basePath) {
-                tunnel.binPath = binPath;
-            }
-            try {
-                const url = await connect(tunnel);
-                return url;
-            }
-            catch (error) {
-                if (isError(error)) {
-                    error.message = `There was an error starting your tunnel.`;
-                }
-                console.error(`There was an error starting your tunnel.`);
-                throw error;
-            }
-        }
-        catch (error) {
-            if (isError(error)) {
-                error.message = `There was an error finding the bin path.`;
-            }
-            console.error(`There was an error finding the bin path.`);
-            throw error;
-        }
-    }
-    return null;
-};
-export const stop = async (tunnel) => {
-    const api = getApi();
-    if (!api) {
-        console.error('ngrok is not currently running.');
-        return;
-    }
-    try {
-        const tunnels = await getActiveTunnels(api);
-        console.log('tunnels', tunnels);
-        console.log('attempting to stop tunnel', tunnel);
-        if (tunnels.length > 0) {
-            if (tunnel === 'All') {
-                await closeAllTunnels();
-            }
-            else if (typeof tunnel !== 'undefined') {
-                let tunnelUrl = tunnel.includes("http") ? tunnel : `https://${tunnel}`;
-                await closeTunnel(tunnelUrl, api);
-            }
-        }
-        else {
-            console.error('There are no active ngrok tunnels.');
-        }
-    }
-    catch (error) {
-        console.error('Could not get active tunnels from ngrok.');
-    }
-};
-const closeTunnel = async (tunnel, api) => {
-    try {
-        await disconnect(tunnel);
-        let message = `Debugg AI tunnel disconnected.`;
-        if ((await getActiveTunnels(api)).length === 0) {
-            await kill();
-            message = `${message} DebuggAI test runner completed.`;
-        }
-    }
-    catch (error) {
-        console.error(error);
-    }
-};
-const closeAllTunnels = async () => {
-    try {
-        await disconnect();
-        await kill();
-    }
-    catch (error) {
-        console.error(error);
-    }
-};
-export const setAuthToken = async (token) => {
-    if (typeof token !== 'undefined') {
-        await authtoken({
-            authtoken: token,
-            configPath: getConfigPath(),
-        });
-    }
-};
-export async function downloadBinary() {
-    const binaryLocations = [
-        join(basePath, 'ngrok'),
-        join(basePath, 'ngrok.exe'),
-    ];
-    if (binaryLocations.some((path) => existsSync(path))) {
-        console.info('ngrok binary is already downloaded');
-    }
-    else {
-        async function runDownload() {
-            await mkdirp(basePath);
-            try {
-                await new Promise((resolve, reject) => download((error) => (error ? reject(error) : resolve())));
-            }
-            catch (error) {
-                console.error(`Can't update local tunnel configuration. The tests may not work correctly.`);
-                console.error(error);
-            }
-        }
-        await runDownload();
-    }
-}
-;
-export class NgrokTunnelClient {
-    api = null;
-    constructor() {
-        this.api = getApi();
-    }
-    start = async (options) => {
-        return await start(options);
-    };
-    stop = async (tunnel) => {
-        await stop(tunnel);
-    };
-    getActiveTunnels = async (api) => {
-        return await getActiveTunnels(api);
-    };
-    getUrl = async (api) => {
-        const tunnels = await getActiveTunnels(api);
-        return tunnels.map((tunnel) => tunnel.public_url).join(', ');
-    };
-    getApi = async () => {
-        if (!this.api)
-            throw new Error('ngrok is not currently running.');
-        return this.api;
-    };
-    downloadBinary = async () => {
-        await downloadBinary();
-    };
-}
-// Export tunnel manager for high-level API
-export { tunnelManager } from './tunnelManager.js';

package/dist/utils/axios.js

@@ -1,35 +0,0 @@
-import axios from "axios";
-const axiosServices = axios.create({
-    baseURL: process.env.REACT_APP_API_URL || "http://localhost:81",
-    headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": "Token 6f960ed60c88b5af7d1d7ecfabeee53f5068dc4d",
-    },
-});
-// ==============================|| AXIOS - FOR MOCK SERVICES ||============================== //
-axiosServices.interceptors.response.use((response) => {
-    //console.error(`Response data....${response.data}`)
-    if (response.data) {
-        // response.data = objToCamelCase(response.data);
-        // response.data = response.data;
-    }
-    return response;
-}, (error) => {
-    // let host = window.location.host;
-    // let parts = host.split(".");
-    // let subdomain = parts[0];
-    // if (error.response.status === 401 && subdomain == 'app' && !window.location.href.includes('/login')) {
-    //   window.location = '/login';
-    // }
-    if (error) {
-        // error = objToCamelCase(error);
-    }
-    return Promise.reject((error.response && error.response.data) || "Wrong Services");
-});
-axiosServices.interceptors.request.use(async (config) => {
-    // Update naming convention from CamelCase to the underscored type
-    return config;
-}, (error) => error);
-export default axiosServices;
-export const { get, post, put, delete: destroy } = axiosServices;

package/dist/utils/axiosNaming.js

@@ -1,31 +0,0 @@
-import { objToCamelCase, objToSnakeCase } from "./objectNaming.js";
-import { destroy as destroyAxios, get as getAxios, post as postAxios, put as putAxios } from "./axios.js";
-export async function get(url, params) {
-    const fmtdParams = objToSnakeCase(params);
-    return getAxios(url, fmtdParams).then((response) => {
-        console.error("response", response);
-        const fmtdData = objToCamelCase(response.data);
-        response.data = fmtdData;
-        return response;
-    });
-}
-export async function post(url, data, config) {
-    const fmtdData = objToSnakeCase(data);
-    return postAxios(url, fmtdData, config).then((response) => {
-        response.data = objToCamelCase(response.data);
-        return response;
-    });
-}
-export async function put(url, data, config) {
-    const fmtdData = objToSnakeCase(data);
-    return putAxios(url, fmtdData, config).then((response) => {
-        response.data = objToCamelCase(response.data);
-        return response;
-    });
-}
-export async function destroy(url, config) {
-    return destroyAxios(url, config).then((response) => {
-        response.data = objToCamelCase(response.data);
-        return response;
-    });
-}

package/dist/utils/transportConfig.js

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