@debugg-ai/debugg-ai-mcp 1.0.1

package/dist/src/tunnels/ngrok/index.js

@@ -0,0 +1,154 @@
+import { existsSync, promises } from 'fs';
+import { join } from 'path';
+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';
+const basePath = join(__dirname, 'bin');
+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}.`);
+            }
+        }
+        else {
+            console.error(`Could not parse config file at ${configPath}.`);
+        }
+    }
+};
+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 (!tunnel) {
+        console.error('No tunnel provided');
+        return;
+    }
+    if (typeof tunnel !== 'undefined') {
+        const configPath = getConfigPath();
+        if (existsSync(configPath)) {
+            tunnel.configPath = configPath;
+        }
+        try {
+            tunnel.binPath = binPath;
+            try {
+                const url = await connect(tunnel);
+            }
+            catch (error) {
+                console.error(`There was an error starting your tunnel.`);
+                console.error(error);
+            }
+        }
+        catch (error) {
+            console.error(`There was an error finding the bin path.`);
+            console.error(error);
+        }
+    }
+};
+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.error('tunnels', tunnels);
+        console.error('attempting to stop tunnel', tunnel);
+        if (tunnels.length > 0) {
+            if (tunnel === 'All') {
+                await closeAllTunnels();
+            }
+            else if (typeof tunnel !== 'undefined') {
+                await closeTunnel(tunnel, api);
+            }
+        }
+        else {
+            console.error('There are no active ngrok tunnels.');
+        }
+    }
+    catch (error) {
+        console.error('Could not get active tunnels from ngrok.');
+        console.error(error);
+    }
+};
+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.`;
+            // hideStatusBarItem();
+        }
+        console.error(message);
+    }
+    catch (error) {
+        // window.showErrorMessage(
+        //   `There was a problem stopping the tunnel ${tunnel}, see the log for details.`
+        // );
+        console.error(error);
+    }
+};
+const closeAllTunnels = async () => {
+    try {
+        await disconnect();
+        await kill();
+        // window.showInformationMessage(
+        //   'All ngrok tunnels disconnected. ngrok has been shutdown.'
+        // );
+        // hideStatusBarItem();
+    }
+    catch (error) {
+        // window.showErrorMessage(
+        //   'There was an issue closing the ngrok tunnels, check the log for details.'
+        // );
+        console.error(error);
+    }
+};
+export const downloadBinary = async () => {
+    const binaryLocations = [
+        join(basePath, 'ngrok'),
+        join(basePath, 'ngrok.exe'),
+    ];
+    if (binaryLocations.some((path) => existsSync(path))) {
+        console.info('ngrok binary is already downloaded');
+    }
+    else {
+        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);
+        }
+    }
+};

package/dist/src/tunnels/ngrok/statusBarItem.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hideStatusBarItem = exports.showStatusBarItem = exports.createStatusBarItem = void 0;
+var vscode_1 = require("vscode");
+var statusBarItem;
+var createStatusBarItem = function (commandId, version) {
+    statusBarItem = vscode_1.window.createStatusBarItem(vscode_1.StatusBarAlignment.Left);
+    var statusBarText = '$(globe) ngrok';
+    if (version) {
+        statusBarText += " (v".concat(version, ")");
+    }
+    statusBarItem.text = statusBarText;
+    statusBarItem.tooltip = 'ngrok is running';
+    statusBarItem.command = commandId;
+    return statusBarItem;
+};
+exports.createStatusBarItem = createStatusBarItem;
+var showStatusBarItem = function () {
+    statusBarItem.show();
+};
+exports.showStatusBarItem = showStatusBarItem;
+var hideStatusBarItem = function () {
+    statusBarItem.hide();
+};
+exports.hideStatusBarItem = hideStatusBarItem;

package/dist/src/tunnels/ngrok/types.js

@@ -0,0 +1,2 @@
+export {};
+/* eslint-enable */ 

package/dist/src/utils/axios.js

@@ -0,0 +1,35 @@
+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/src/utils/axiosNaming.js

@@ -0,0 +1,31 @@
+import { objToCamelCase, objToSnakeCase } from "../utils/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/src/utils/axiosTransport.js

@@ -0,0 +1,57 @@
+// utils/axiosTransport.ts
+import axios from "axios";
+import { objToCamelCase, objToSnakeCase, } from "./objectNaming.js";
+/**
+ * A tiny wrapper around axios that keeps all your interceptors
+ * but gives service factories a clean, typed surface.
+ */
+export class AxiosTransport {
+    axios;
+    constructor({ baseUrl, apiKey, instance }) {
+        // Use an injected instance or create one that mimics `axiosServices`
+        // Use provided apiKey as the Token. Must be requested on the app.
+        this.axios =
+            instance ??
+                axios.create({
+                    baseURL: baseUrl.replace(/\/+$/, "/"),
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                        ...(apiKey ? { Authorization: `Token ${apiKey}` } : {}),
+                    },
+                });
+        /* ---------- INTERCEPTORS ---------- */
+        // Response → camelCase
+        this.axios.interceptors.response.use((res) => {
+            res.data = objToCamelCase(res.data);
+            return res;
+        }, (err) => Promise.reject((err.response && err.response.data) || "Unknown Axios error"));
+        // Request → snake_case
+        this.axios.interceptors.request.use((cfg) => {
+            if (cfg.data && typeof cfg.data === "object") {
+                cfg.data = objToSnakeCase(cfg.data);
+            }
+            if (cfg.params && typeof cfg.params === "object") {
+                cfg.params = objToSnakeCase(cfg.params);
+            }
+            return cfg;
+        });
+    }
+    /* ---------- SHORTHAND METHODS ---------- */
+    async request(cfg) {
+        const res = await this.axios.request(cfg);
+        return res.data;
+    }
+    get(url, params) {
+        return this.request({ url, method: "GET", params });
+    }
+    post(url, data, cfg) {
+        return this.request({ url, method: "POST", data, ...cfg });
+    }
+    put(url, data, cfg) {
+        return this.request({ url, method: "PUT", data, ...cfg });
+    }
+    delete(url, cfg) {
+        return this.request({ url, method: "DELETE", ...cfg });
+    }
+}

package/dist/src/utils/objectNaming.js

@@ -0,0 +1,47 @@
+// Function to handle converting a string to camelCase
+export function stringToCamelCase(str) {
+    return str
+        .toLowerCase()
+        .split("_")
+        .map((s, i) => i === 0 ? s : s.slice(0, 1).toUpperCase() + s.slice(1, s.length))
+        .join("");
+}
+// Function to handle converting a string to snake_case
+export function stringToSnakeCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+// Function to handle switching API data response objects into camelCase
+export function objToCamelCase(obj) {
+    if (!obj) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((entry) => typeof entry !== "object" ? entry : objToCamelCase(entry));
+    }
+    const newObj = Object.entries(obj).reduce((acc, [key, value]) => {
+        const newKey = stringToCamelCase(key);
+        const newValue = typeof value !== "object" ? value : objToCamelCase(value);
+        acc[newKey] = newValue;
+        return acc;
+    }, {});
+    return newObj;
+}
+// Function to handle switching objects into snake_case
+export function objToSnakeCase(obj) {
+    if (!obj) {
+        return obj;
+    }
+    if (obj instanceof File || obj instanceof FormData) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((entry) => typeof entry !== "object" ? entry : objToSnakeCase(entry));
+    }
+    const newObj = Object.entries(obj).reduce((acc, [key, value]) => {
+        const newKey = stringToSnakeCase(key);
+        const newValue = typeof value !== "object" ? value : objToSnakeCase(value);
+        acc[newKey] = newValue;
+        return acc;
+    }, {});
+    return newObj;
+}

package/dist/src/utils/transportConfig.js

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

package/dist/tunnels/ngrok/error.js

@@ -0,0 +1,3 @@
+export function isError(error) {
+    return error instanceof Error;
+}

package/dist/tunnels/ngrok/index.js

@@ -0,0 +1,159 @@
+import { existsSync, promises } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+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';
+// Get the equivalent of __dirname in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const basePath = join(__dirname, 'bin');
+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}.`);
+            }
+        }
+        else {
+            console.error(`Could not parse config file at ${configPath}.`);
+        }
+    }
+};
+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 (!tunnel) {
+        console.error('No tunnel provided');
+        return;
+    }
+    if (typeof tunnel !== 'undefined') {
+        const configPath = getConfigPath();
+        if (existsSync(configPath)) {
+            tunnel.configPath = configPath;
+        }
+        try {
+            tunnel.binPath = binPath;
+            try {
+                const url = await connect(tunnel);
+            }
+            catch (error) {
+                console.error(`There was an error starting your tunnel.`);
+                console.error(error);
+            }
+        }
+        catch (error) {
+            console.error(`There was an error finding the bin path.`);
+            console.error(error);
+        }
+    }
+};
+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.error('tunnels', tunnels);
+        console.error('attempting to stop tunnel', tunnel);
+        if (tunnels.length > 0) {
+            if (tunnel === 'All') {
+                await closeAllTunnels();
+            }
+            else if (typeof tunnel !== 'undefined') {
+                await closeTunnel(tunnel, api);
+            }
+        }
+        else {
+            console.error('There are no active ngrok tunnels.');
+        }
+    }
+    catch (error) {
+        console.error('Could not get active tunnels from ngrok.');
+        console.error(error);
+    }
+};
+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.`;
+            // hideStatusBarItem();
+        }
+        console.error(message);
+    }
+    catch (error) {
+        // window.showErrorMessage(
+        //   `There was a problem stopping the tunnel ${tunnel}, see the log for details.`
+        // );
+        console.error(error);
+    }
+};
+const closeAllTunnels = async () => {
+    try {
+        await disconnect();
+        await kill();
+        // window.showInformationMessage(
+        //   'All ngrok tunnels disconnected. ngrok has been shutdown.'
+        // );
+        // hideStatusBarItem();
+    }
+    catch (error) {
+        // window.showErrorMessage(
+        //   'There was an issue closing the ngrok tunnels, check the log for details.'
+        // );
+        console.error(error);
+    }
+};
+export const downloadBinary = async () => {
+    const binaryLocations = [
+        join(basePath, 'ngrok'),
+        join(basePath, 'ngrok.exe'),
+    ];
+    if (binaryLocations.some((path) => existsSync(path))) {
+        console.info('ngrok binary is already downloaded');
+    }
+    else {
+        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);
+        }
+    }
+};

package/dist/tunnels/ngrok/types.js

@@ -0,0 +1,2 @@
+export {};
+/* eslint-enable */ 

package/dist/utils/axios.js

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,31 @@
+import { objToCamelCase, objToSnakeCase } from "../utils/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/axiosTransport.js

@@ -0,0 +1,57 @@
+// utils/axiosTransport.ts
+import axios from "axios";
+import { objToCamelCase, objToSnakeCase, } from "./objectNaming.js";
+/**
+ * A tiny wrapper around axios that keeps all your interceptors
+ * but gives service factories a clean, typed surface.
+ */
+export class AxiosTransport {
+    axios;
+    constructor({ baseUrl, apiKey, instance }) {
+        // Use an injected instance or create one that mimics `axiosServices`
+        // Use provided apiKey as the Token. Must be requested on the app.
+        this.axios =
+            instance ??
+                axios.create({
+                    baseURL: baseUrl.replace(/\/+$/, "/"),
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                        ...(apiKey ? { Authorization: `Token ${apiKey}` } : {}),
+                    },
+                });
+        /* ---------- INTERCEPTORS ---------- */
+        // Response → camelCase
+        this.axios.interceptors.response.use((res) => {
+            res.data = objToCamelCase(res.data);
+            return res;
+        }, (err) => Promise.reject((err.response && err.response.data) || "Unknown Axios error"));
+        // Request → snake_case
+        this.axios.interceptors.request.use((cfg) => {
+            if (cfg.data && typeof cfg.data === "object") {
+                cfg.data = objToSnakeCase(cfg.data);
+            }
+            if (cfg.params && typeof cfg.params === "object") {
+                cfg.params = objToSnakeCase(cfg.params);
+            }
+            return cfg;
+        });
+    }
+    /* ---------- SHORTHAND METHODS ---------- */
+    async request(cfg) {
+        const res = await this.axios.request(cfg);
+        return res.data;
+    }
+    get(url, params) {
+        return this.request({ url, method: "GET", params });
+    }
+    post(url, data, cfg) {
+        return this.request({ url, method: "POST", data, ...cfg });
+    }
+    put(url, data, cfg) {
+        return this.request({ url, method: "PUT", data, ...cfg });
+    }
+    delete(url, cfg) {
+        return this.request({ url, method: "DELETE", ...cfg });
+    }
+}