@debugg-ai/debugg-ai-mcp 1.0.50 → 1.0.52

package/dist/utils/gitContext.js

@@ -15,7 +15,7 @@ export function detectRepoName() {
     try {
         const raw = execSync('git remote get-url origin', {
             encoding: 'utf-8',
-            timeout: 5000,
+            timeout: 2000,
             stdio: ['ignore', 'pipe', 'ignore'],
         }).trim();
         cached = parseRepoName(raw);

package/dist/utils/logger.js

@@ -23,14 +23,16 @@ const createLogger = () => {
                 stderrLevels: ['error', 'warn', 'info', 'debug'],
             }),
         ],
-        // Ensure uncaught exceptions and rejections are logged
+        // Ensure uncaught exceptions and rejections go to stderr (NOT stdout — stdout is the MCP transport)
         exceptionHandlers: [
             new winston.transports.Console({
+                stderrLevels: ['error', 'warn', 'info', 'debug'],
                 format: winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json()),
             }),
         ],
         rejectionHandlers: [
             new winston.transports.Console({
+                stderrLevels: ['error', 'warn', 'info', 'debug'],
                 format: winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json()),
             }),
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "1.0.50",
+  "version": "1.0.52",
   "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 {};