@debugg-ai/debugg-ai-mcp 1.0.21 → 1.0.24

package/dist/config/index.js

@@ -2,10 +2,26 @@
  * Centralized configuration management for DebuggAI MCP Server
  */
 import { z } from 'zod';
-import { createRequire } from 'module';
-import { resolve } from 'path';
-const _require = createRequire(import.meta.url);
-const _pkg = _require(resolve(process.cwd(), 'package.json'));
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+function findPackageVersion() {
+    const __dir = dirname(fileURLToPath(import.meta.url));
+    let dir = __dir;
+    while (true) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+            if (pkg.name === '@debugg-ai/debugg-ai-mcp')
+                return pkg.version;
+        }
+        catch { /* keep walking */ }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return 'unknown';
+        dir = parent;
+    }
+}
+const _version = findPackageVersion();
 const configSchema = z.object({
     server: z.object({
         name: z.string().default('DebuggAI MCP Server'),
@@ -32,7 +48,7 @@ export function loadConfig() {
     const rawConfig = {
         server: {
             name: 'DebuggAI MCP Server',
-            version: _pkg.version,
+            version: _version,
         },
         api: {
             // Priority: DEBUGGAI_API_TOKEN → DEBUGGAI_JWT_TOKEN → DEBUGGAI_API_KEY

package/dist/handlers/liveSessionHandlers.js

@@ -76,12 +76,9 @@ export async function startLiveSessionHandler(input, context, progressCallback)
         if (!session) {
             throw new Error('Failed to start browser session: No session returned');
         }
-        // If we need a tunnel, create it now using the tunnelKey from the backend
+        // If we need a tunnel, create it now using the account ngrok auth token
         if (isLocalhost && tunnelId) {
-            const tunnelAuthToken = session.tunnelKey;
-            if (!tunnelAuthToken) {
-                throw new Error('No tunnel key provided by backend - tunnels not available for localhost URLs');
-            }
+            const tunnelAuthToken = await client.getNgrokAuthToken();
             logger.info(`Creating tunnel with backend-provided key for ${input.url} -> ${sessionUrl}`);
             // Create the tunnel using the original localhost URL and the generated tunnel ID
             const port = extractLocalhostPort(input.url);

package/dist/handlers/testPageChangesHandler.js

@@ -50,22 +50,7 @@ export async function testPageChangesHandler(input, context, progressCallback) {
             const { v4: uuidv4 } = await import('uuid');
             tunnelId = uuidv4();
             const tunnelPublicUrl = `https://${tunnelId}.ngrok.debugg.ai`;
-            // Start a minimal browser session to obtain the ngrok auth token
-            const session = await client.browserSessions.startSession({
-                url: tunnelPublicUrl,
-                originalUrl: targetUrlRaw,
-                localPort: port,
-                sessionName: `Tunnel provisioning for ${targetUrlRaw}`,
-                monitorConsole: false,
-                monitorNetwork: false,
-                takeScreenshots: false,
-                isLocalhost: true,
-                tunnelId,
-            });
-            const tunnelAuthToken = session.tunnelKey;
-            if (!tunnelAuthToken) {
-                throw new Error('Browser sessions service did not return a tunnel auth token');
-            }
+            const tunnelAuthToken = await client.getNgrokAuthToken();
             const tunnelResult = await tunnelManager.processUrl(targetUrlRaw, tunnelAuthToken, tunnelId);
             targetUrl = tunnelResult.url;
             logger.info(`Tunnel ready: ${targetUrl}`);

package/dist/services/index.js

@@ -38,6 +38,8 @@ export class DebuggAIServerClient {
     e2es;
     browserSessions;
     workflows;
+    // Cached ngrok auth token — stable per account, fetched once per server session
+    _ngrokAuthToken;
     constructor(userApiKey) {
         this.userApiKey = userApiKey;
         // Note: init() is async and should be called separately
@@ -50,6 +52,33 @@ export class DebuggAIServerClient {
         this.browserSessions = createBrowserSessionsService(this.tx);
         this.workflows = createWorkflowsService(this.tx);
     }
+    /**
+     * Returns the ngrok auth token for this account.
+     * The token is stable per account — fetched once via a minimal e2e test creation
+     * and cached for the lifetime of this server session.
+     */
+    async getNgrokAuthToken() {
+        if (this._ngrokAuthToken)
+            return this._ngrokAuthToken;
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        // The e2e-tests POST returns tunnel_key (stable per account) at creation time.
+        // We create a minimal probe test, extract the key, then delete the test.
+        const created = await this.tx.post('api/v1/e2e-tests/', {
+            description: '_mcp_tunnel_probe',
+            repoName: '_mcp',
+            branchName: 'main',
+        });
+        const token = created?.tunnelKey;
+        if (!token)
+            throw new Error('Backend did not return a tunnel auth token');
+        // Clean up the probe test
+        if (created?.uuid) {
+            this.tx.delete(`api/v1/e2e-tests/${created.uuid}/`).catch(() => { });
+        }
+        this._ngrokAuthToken = token;
+        return token;
+    }
 }
 /**
  * Create and initialize a service client

package/package.json

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

package/dist/e2e-agents/e2eRunner.js

@@ -1,145 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-let ngrokModule = null;
-async function getNgrok() {
-    if (!ngrokModule) {
-        try {
-            ngrokModule = require('ngrok');
-        }
-        catch (error) {
-            throw new Error(`Failed to load ngrok module: ${error}`);
-        }
-    }
-    return ngrokModule;
-}
-async function startTunnel(authToken, localPort, domain) {
-    try {
-        const ngrok = await getNgrok();
-        if (process.env.DOCKER_CONTAINER === "true") {
-            const url = await ngrok.connect({ proto: 'http', addr: `host.docker.internal:${localPort}`, hostname: domain, authtoken: authToken });
-            return url;
-        }
-        else {
-            const url = await ngrok.connect({ proto: 'http', addr: localPort, hostname: domain, authtoken: authToken });
-            return url;
-        }
-    }
-    catch (err) {
-        console.error('Error starting ngrok tunnel:', err);
-        throw err;
-    }
-}
-async function stopTunnel(url) {
-    try {
-        const ngrok = await getNgrok();
-        if (url) {
-            await ngrok.disconnect(url);
-        }
-        else {
-            await ngrok.disconnect();
-        }
-    }
-    catch (err) {
-        console.error('Error stopping ngrok tunnel:', err);
-    }
-}
-const POLL_INTERVAL_MS = 1500;
-const TIMEOUT_MS = 900_000; // 15 minutes
-export class E2eTestRunner {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async setup() {
-        await this.configureNgrok();
-    }
-    async configureNgrok() {
-        // ngrok binary is downloaded automatically by the ngrok package
-    }
-    async startTunnel(authToken, port, url) {
-        await startTunnel(authToken, port, url);
-        console.error(`Tunnel started at: ${url}`);
-        return url;
-    }
-    /**
-     * Create a new E2E test and run it.
-     */
-    async createNewE2eTest(testPort, testDescription, repoName, branchName, repoPath, filePath) {
-        console.error(`Creating new E2E test with description: ${testDescription}`);
-        const key = uuidv4();
-        const e2eTest = await this.client.e2es?.createE2eTest(testDescription, { filePath: filePath ?? "", repoName, branchName, repoPath, key });
-        console.error("E2E test creation response:", JSON.stringify(e2eTest, null, 2));
-        const authToken = e2eTest?.tunnelKey;
-        if (!authToken) {
-            console.error("Failed to get auth token. E2E test response:", e2eTest);
-            console.error("Available keys in response:", e2eTest ? Object.keys(e2eTest) : 'null response');
-            return null;
-        }
-        await startTunnel(authToken, testPort, `${key}.ngrok.debugg.ai`);
-        console.error(`E2E test created - ${e2eTest}`);
-        if (!e2eTest) {
-            console.error("Failed to create E2E test.");
-            return null;
-        }
-        if (!e2eTest.curRun) {
-            console.error("Failed to create E2E test run.");
-            return null;
-        }
-        return e2eTest.curRun;
-    }
-    /**
-     * Poll an E2E run until it completes or times out.
-     *
-     * Uses a safe async loop — no setInterval race conditions.
-     * The tunnel is stopped in a finally block so cleanup always runs
-     * regardless of how the loop exits (completion, timeout, or error).
-     *
-     * onUpdate is called on every poll tick so progress notifications
-     * fire at a steady cadence and keep the MCP connection alive.
-     */
-    async handleE2eRun(e2eRun, onUpdate) {
-        const tunnelUrl = `https://${e2eRun.key}.ngrok.debugg.ai`;
-        const startTime = Date.now();
-        let updatedRun = e2eRun;
-        console.error(`🔧 Handling E2E run - ${e2eRun.uuid}`);
-        console.error(`🌐 Tunnel: ${tunnelUrl}`);
-        try {
-            while (true) {
-                if (Date.now() - startTime >= TIMEOUT_MS) {
-                    console.error('⏰ E2E test timed out after 15 minutes');
-                    break;
-                }
-                await this._sleep(POLL_INTERVAL_MS);
-                try {
-                    const latestRun = await this.client.e2es?.getE2eRun(e2eRun.uuid);
-                    if (latestRun) {
-                        updatedRun = latestRun;
-                    }
-                }
-                catch (pollError) {
-                    console.error(`⚠️ Poll error (continuing): ${pollError}`);
-                }
-                console.error(`📡 Polled E2E run status: ${updatedRun.status}`);
-                // Always fire onUpdate — keeps MCP progress notifications alive
-                // even when the run is loading or the poll returned null
-                await onUpdate(updatedRun);
-                if (updatedRun.status === 'completed') {
-                    break;
-                }
-            }
-        }
-        finally {
-            await this._stopTunnel(tunnelUrl);
-        }
-        return updatedRun;
-    }
-    // Overridable in tests
-    async _sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    async _stopTunnel(url) {
-        await stopTunnel(url);
-    }
-}
-export default E2eTestRunner;

package/dist/e2e-agents/recordingHandler.js

@@ -1,57 +0,0 @@
-import * as fs from "fs";
-import * as http from "http";
-import * as https from "https";
-import * as path from "path";
-import { URL } from "url";
-export async function fetchAndOpenGif(projectRoot, recordingUrl, testName, testId) {
-    const cacheDir = path.join(projectRoot, ".debugg-ai", "e2e-runs");
-    console.error('....downloading gif....');
-    console.error('cacheDir', cacheDir);
-    console.error('testId', testId);
-    console.error('recordingUrl', recordingUrl);
-    let localUrl = recordingUrl.replace('localhost', 'localhost:8002');
-    console.error('localUrl', localUrl);
-    await fs.promises.mkdir(cacheDir, { recursive: true });
-    const filePath = path.join(cacheDir, `${testName.replace(/[^a-zA-Z0-9]/g, '-')}-${testId.slice(0, 4)}.gif`);
-    const fileUrl = new URL(localUrl);
-    const file = fs.createWriteStream(filePath);
-    console.error(`⬇️ Downloading test recording...`);
-    await new Promise((resolve, reject) => {
-        console.error('fetching gif', fileUrl);
-        if (fileUrl.protocol === 'https:') {
-            https.get(localUrl, (response) => {
-                if (response.statusCode !== 200) {
-                    reject(new Error(`Failed to download file: ${response.statusCode}`));
-                    return;
-                }
-                response.pipe(file);
-                file.on("finish", () => {
-                    file.close();
-                    resolve();
-                });
-            }).on("error", (err) => {
-                fs.unlinkSync(filePath);
-                reject(err);
-            });
-        }
-        else {
-            http.get(localUrl, (response) => {
-                if (response.statusCode !== 200) {
-                    reject(new Error(`Failed to download file: ${response.statusCode}`));
-                    return;
-                }
-                response.pipe(file);
-                file.on("finish", () => {
-                    file.close();
-                    resolve();
-                });
-            }).on("error", (err) => {
-                fs.unlinkSync(filePath);
-                reject(err);
-            });
-        }
-    });
-    console.error(`📂 Opening test recording`);
-    // const fileUri = vscode.Uri.file(filePath);
-    // await vscode.commands.executeCommand('vscode.open', fileUri);
-}

package/dist/e2e-agents/resultsFormatter.js

@@ -1,102 +0,0 @@
-export class RunResultFormatter {
-    steps = [];
-    passed(result) {
-        return result.status === "completed" && result.outcome === "pass";
-    }
-    formatFailures(result) {
-        if (this.passed(result) || !result.outcome)
-            return "";
-        return "\n\n❌ Failures:" + "\n" + `> ${result.outcome}`;
-    }
-    formatStepsAsMarkdown() {
-        if (this.steps.length === 0)
-            return "";
-        return ("\n\n" +
-            this.steps
-                .map((s, idx) => {
-                const num = `Step ${idx + 1}:`;
-                const label = s.label.padEnd(30);
-                const icon = "✅ Success";
-                // s.status === "pending"
-                //     ? chalk.yellow("⏳ Pending")
-                //     : s.status === "success"
-                //         ? chalk.green("✅ Success")
-                //         : chalk.red("❌ Failed");
-                return `${num} ${label} ${icon}`;
-            })
-                .join("\n\n"));
-    }
-    updateStep(label, status) {
-        const existing = this.steps.find((s) => s.label === label);
-        if (existing) {
-            existing.status = status;
-        }
-        else {
-            this.steps.push({ label, status });
-        }
-        console.error('updating step. steps ->', this.steps);
-        // Clear terminal and redraw
-        console.error("\x1Bc"); // ANSI clear screen
-        console.error("🧪 E2E Test Progress" +
-            `\r\n${this.steps
-                .map((s, i) => {
-                const icon = s.status === "pending"
-                    ? "⏳"
-                    : s.status === "success"
-                        ? "✅"
-                        : "❌";
-                return `${`Step ${i + 1}:`} ${s.label.padEnd(30)} ${icon}`;
-            })
-                .join("\r\n")}`);
-    }
-    formatTerminalBox(result) {
-        const header = this.passed(result)
-            ? "✅ Test Passed"
-            : "❌ Test Failed";
-        const body = [
-            "Test: " + result.test?.name,
-            "Description: " + (result.test?.description ?? "None"),
-            "Duration: " + `${result.metrics?.executionTime ?? 0}s`,
-            "Status: " + result.status,
-            "Outcome: " + result.outcome,
-            this.formatStepsAsMarkdown(),
-            this.passed(result) ? "" : this.formatFailures(result),
-        ]
-            .filter(Boolean)
-            .join("\n");
-        return `${header}\n${body}`;
-    }
-    formatMarkdownSummary(result) {
-        return [
-            `🧪 **Test Name:** ${result.test?.name ?? "Unknown"}`,
-            `📄 **Description:** ${result.test?.description ?? "None"}`,
-            `⏱ **Duration:** ${result.metrics?.executionTime ?? 0}s`,
-            `🔎 **Status:** ${result.status}`,
-            `📊 **Outcome:** ${result.outcome}`,
-            this.formatStepsAsMarkdown(),
-            this.formatFailures(result),
-        ]
-            .filter(Boolean)
-            .join("\n")
-            .trim();
-    }
-    /*
-    Terminal uses different formatting than markdown.
-    */
-    terminalSummary(result) {
-        return [
-            `🧪 Test Name: ${result.test?.name ?? "Unknown"}`,
-            `📄 Description: ${result.test?.description ?? "None"}`,
-            `⏱ Duration: ${result.metrics?.executionTime ?? 0}s`,
-            `🔎 Status: ${result.status}`,
-            `📊 Outcome: ${result.outcome}`,
-            this.formatFailures(result),
-        ]
-            .filter(Boolean)
-            .join("\r\n")
-            .trim();
-    }
-    appendToTestRun(result) {
-        console.error(this.terminalSummary(result));
-    }
-}