@debugg-ai/debugg-ai-mcp 2.6.1 → 2.8.1

package/dist/handlers/testPageChangesHandler.js

@@ -125,69 +125,75 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                     return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                 }
             }
-            if (progressCallback) {
-                await progressCallback({ progress: 1, total: TOTAL_STEPS, message: 'Provisioning secure tunnel for localhost...' });
-            }
-            const reused = findExistingTunnel(ctx);
-            if (reused) {
-                ctx = reused;
-                logger.info(`Reusing tunnel: ${ctx.targetUrl} (id: ${ctx.tunnelId})`);
+            if (config.devMode) {
+                // Dev mode: local backend can reach localhost directly — no tunnel needed.
+                logger.info(`check_app_in_browser: dev mode — using localhost URL directly: ${ctx.originalUrl}`);
             }
             else {
-                let tunnel;
-                try {
-                    tunnel = await client.tunnels.provisionWithRetry();
-                }
-                catch (provisionError) {
-                    const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
-                    const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
-                    throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
-                        `The remote browser needs a secure tunnel to reach your local dev server. ` +
-                        `Make sure your dev server is running on the specified port and try again. ` +
-                        `(Detail: ${msg})${diag}`);
+                if (progressCallback) {
+                    await progressCallback({ progress: 1, total: TOTAL_STEPS, message: 'Provisioning secure tunnel for localhost...' });
                 }
-                keyId = tunnel.keyId;
-                try {
-                    ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                const reused = findExistingTunnel(ctx);
+                if (reused) {
+                    ctx = reused;
+                    logger.info(`Reusing tunnel: ${ctx.targetUrl} (id: ${ctx.tunnelId})`);
                 }
-                catch (tunnelError) {
-                    const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
-                    throw new Error(`Tunnel creation failed for ${ctx.originalUrl}. ` +
-                        `Could not establish a secure connection between the remote browser and your local port. ` +
-                        `Verify your dev server is running and the port is accessible. ` +
-                        `(Detail: ${msg})`);
+                else {
+                    let tunnel;
+                    try {
+                        tunnel = await client.tunnels.provisionWithRetry();
+                    }
+                    catch (provisionError) {
+                        const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
+                        const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
+                        throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
+                            `The remote browser needs a secure tunnel to reach your local dev server. ` +
+                            `Make sure your dev server is running on the specified port and try again. ` +
+                            `(Detail: ${msg})${diag}`);
+                    }
+                    keyId = tunnel.keyId;
+                    try {
+                        ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                    }
+                    catch (tunnelError) {
+                        const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
+                        throw new Error(`Tunnel creation failed for ${ctx.originalUrl}. ` +
+                            `Could not establish a secure connection between the remote browser and your local port. ` +
+                            `Verify your dev server is running and the port is accessible. ` +
+                            `(Detail: ${msg})`);
+                    }
+                    logger.info(`Tunnel ready: ${ctx.targetUrl} (id: ${ctx.tunnelId})`);
                 }
-                logger.info(`Tunnel ready: ${ctx.targetUrl} (id: ${ctx.tunnelId})`);
-            }
-            // Bead 1om: verify traffic actually flows through the tunnel. The
-            // tunnel can be established (ngrok.connect returns OK) yet refuse
-            // to forward traffic — e.g., IPv4/IPv6 bind mismatch, or the dev
-            // server died between the pre-flight probe and here. Catch it now,
-            // in ~1s, not via a 5-minute browser-agent false-pass.
-            if (ctx.targetUrl) {
-                const health = await probeTunnelHealth(ctx.targetUrl);
-                if (!health.healthy) {
-                    const payload = {
-                        error: 'TunnelTrafficBlocked',
-                        message: `Tunnel was established but traffic isn't reaching the dev server. ${health.detail ?? ''} Common causes: dev server binds to 0.0.0.0 or ::1 but not 127.0.0.1; dev server crashed; firewall.`,
-                        detail: {
-                            code: health.code,
-                            status: health.status,
-                            ngrokErrorCode: health.ngrokErrorCode,
-                            elapsedMs: health.elapsedMs,
-                        },
-                    };
-                    logger.warn(`Tunnel health probe failed for ${ctx.targetUrl}: ${health.code} ${health.ngrokErrorCode ?? ''} in ${health.elapsedMs}ms`);
-                    // Tear down the broken tunnel so a subsequent call doesn't reuse it.
-                    // stopTunnel handles both owned (ngrok disconnect + key revoke) and
-                    // borrowed (just drops local ref) cases.
-                    if (ctx.tunnelId) {
-                        tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                // Bead 1om: verify traffic actually flows through the tunnel. The
+                // tunnel can be established (ngrok.connect returns OK) yet refuse
+                // to forward traffic — e.g., IPv4/IPv6 bind mismatch, or the dev
+                // server died between the pre-flight probe and here. Catch it now,
+                // in ~1s, not via a 5-minute browser-agent false-pass.
+                if (ctx.targetUrl) {
+                    const health = await probeTunnelHealth(ctx.targetUrl);
+                    if (!health.healthy) {
+                        const payload = {
+                            error: 'TunnelTrafficBlocked',
+                            message: `Tunnel was established but traffic isn't reaching the dev server. ${health.detail ?? ''} Common causes: dev server binds to 0.0.0.0 or ::1 but not 127.0.0.1; dev server crashed; firewall.`,
+                            detail: {
+                                code: health.code,
+                                status: health.status,
+                                ngrokErrorCode: health.ngrokErrorCode,
+                                elapsedMs: health.elapsedMs,
+                            },
+                        };
+                        logger.warn(`Tunnel health probe failed for ${ctx.targetUrl}: ${health.code} ${health.ngrokErrorCode ?? ''} in ${health.elapsedMs}ms`);
+                        // Tear down the broken tunnel so a subsequent call doesn't reuse it.
+                        // stopTunnel handles both owned (ngrok disconnect + key revoke) and
+                        // borrowed (just drops local ref) cases.
+                        if (ctx.tunnelId) {
+                            tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                        }
+                        // keyId is consumed by stopTunnel's revoke path; clear so the
+                        // outer finally block doesn't double-revoke.
+                        keyId = undefined;
+                        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                     }
-                    // keyId is consumed by stopTunnel's revoke path; clear so the
-                    // outer finally block doesn't double-revoke.
-                    keyId = undefined;
-                    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                 }
             }
         }

package/dist/handlers/triggerCrawlHandler.js

@@ -82,48 +82,54 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
                     return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                 }
             }
-            if (progressCallback) {
-                await progressCallback({ progress: 1, total: 4, message: 'Provisioning secure tunnel for localhost...' });
-            }
-            const reused = findExistingTunnel(ctx);
-            if (reused) {
-                ctx = reused;
+            if (config.devMode) {
+                // Dev mode: local backend can reach localhost directly — no tunnel needed.
+                logger.info(`trigger_crawl: dev mode — using localhost URL directly: ${ctx.originalUrl}`);
             }
             else {
-                let tunnel;
-                try {
-                    tunnel = await client.tunnels.provisionWithRetry();
+                if (progressCallback) {
+                    await progressCallback({ progress: 1, total: 4, message: 'Provisioning secure tunnel for localhost...' });
                 }
-                catch (provisionError) {
-                    const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
-                    const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
-                    throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
-                        `The remote browser needs a secure tunnel to reach your local dev server. ` +
-                        `(Detail: ${msg})${diag}`);
+                const reused = findExistingTunnel(ctx);
+                if (reused) {
+                    ctx = reused;
                 }
-                keyId = tunnel.keyId;
-                ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
-            }
-            // Bead 1om: post-tunnel health check — verify traffic actually flows.
-            if (ctx.targetUrl) {
-                const health = await probeTunnelHealth(ctx.targetUrl);
-                if (!health.healthy) {
-                    const payload = {
-                        error: 'TunnelTrafficBlocked',
-                        message: `Tunnel was established but traffic isn't reaching the dev server. ${health.detail ?? ''} Common causes: dev server binds to 0.0.0.0 or ::1 but not 127.0.0.1; dev server crashed; firewall.`,
-                        detail: {
-                            code: health.code,
-                            status: health.status,
-                            ngrokErrorCode: health.ngrokErrorCode,
-                            elapsedMs: health.elapsedMs,
-                        },
-                    };
-                    logger.warn(`Tunnel health probe failed for ${ctx.targetUrl}: ${health.code} ${health.ngrokErrorCode ?? ''} in ${health.elapsedMs}ms`);
-                    if (ctx.tunnelId) {
-                        tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                else {
+                    let tunnel;
+                    try {
+                        tunnel = await client.tunnels.provisionWithRetry();
+                    }
+                    catch (provisionError) {
+                        const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
+                        const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
+                        throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
+                            `The remote browser needs a secure tunnel to reach your local dev server. ` +
+                            `(Detail: ${msg})${diag}`);
+                    }
+                    keyId = tunnel.keyId;
+                    ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                }
+                // Bead 1om: post-tunnel health check — verify traffic actually flows.
+                if (ctx.targetUrl) {
+                    const health = await probeTunnelHealth(ctx.targetUrl);
+                    if (!health.healthy) {
+                        const payload = {
+                            error: 'TunnelTrafficBlocked',
+                            message: `Tunnel was established but traffic isn't reaching the dev server. ${health.detail ?? ''} Common causes: dev server binds to 0.0.0.0 or ::1 but not 127.0.0.1; dev server crashed; firewall.`,
+                            detail: {
+                                code: health.code,
+                                status: health.status,
+                                ngrokErrorCode: health.ngrokErrorCode,
+                                elapsedMs: health.elapsedMs,
+                            },
+                        };
+                        logger.warn(`Tunnel health probe failed for ${ctx.targetUrl}: ${health.code} ${health.ngrokErrorCode ?? ''} in ${health.elapsedMs}ms`);
+                        if (ctx.tunnelId) {
+                            tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                        }
+                        keyId = undefined;
+                        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                     }
-                    keyId = undefined;
-                    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                 }
             }
         }

package/dist/handlers/updateTestCaseHandler.js

@@ -0,0 +1,24 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+const logger = new Logger({ module: 'updateTestCaseHandler' });
+export async function updateTestCaseHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('update_test_case', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        const updated = await client.updateTestCase(input.testUuid, {
+            name: input.name,
+            description: input.description,
+            agentTaskDescription: input.agentTaskDescription,
+        });
+        logger.toolComplete('update_test_case', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(updated, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('update_test_case', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'update_test_case');
+    }
+}

package/dist/services/index.js

@@ -430,6 +430,151 @@ export class DebuggAIServerClient {
             throw new Error('Client not initialized — call init() first');
         await this.tx.post('api/v1/ngrok/revoke/', { ngrokKeyId });
     }
+    // ── E2E Suite Management ──────────────────────────────────────────────────
+    async createTestSuite(input) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const s = await this.tx.post('api/v1/test-suites/', {
+            name: input.name,
+            description: input.description,
+            project: input.projectUuid,
+        });
+        return this.mapTestSuite(s);
+    }
+    async listTestSuites(params) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const { makePageInfo } = await import('../utils/pagination.js');
+        const page = params.page ?? 1;
+        const pageSize = params.pageSize ?? 20;
+        const query = { project: params.projectUuid, page, pageSize };
+        if (params.search)
+            query.search = params.search;
+        const response = await this.tx.get('api/v1/test-suites/', query);
+        return {
+            pageInfo: makePageInfo(page, pageSize, response?.count ?? 0, response?.next),
+            suites: (response?.results ?? []).map((s) => ({
+                uuid: s.uuid,
+                name: s.name,
+                description: s.description ?? null,
+                runStatus: s.runStatus ?? s.run_status ?? 'NEVER_RUN',
+                testsCount: s.testsCount ?? s.tests_count ?? 0,
+                passRate: s.passRate ?? s.pass_rate ?? null,
+                lastRunAt: s.lastRunAt ?? s.last_run_at ?? null,
+            })),
+        };
+    }
+    async disableTestSuite(suiteUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        await this.tx.post(`api/v1/test-suites/${suiteUuid}/disable/`, {});
+        return { uuid: suiteUuid, isDisabled: true };
+    }
+    async createTestCase(input) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {
+            name: input.name,
+            description: input.description,
+            agent_task_description: input.agentTaskDescription,
+            suite: input.suiteUuid,
+            project: input.projectUuid,
+            run: false,
+        };
+        if (input.relativeUrl)
+            body.relative_url = input.relativeUrl;
+        if (input.maxSteps)
+            body.max_steps = input.maxSteps;
+        const t = await this.tx.post('api/v1/e2e-tests/', body);
+        return {
+            uuid: t.uuid,
+            name: t.name,
+            description: t.description,
+            agentTaskDescription: t.agentTaskDescription ?? t.agent_task_description ?? '',
+            suite: t.suite ?? input.suiteUuid,
+            project: t.project ?? input.projectUuid,
+            runCount: t.runCount ?? t.run_count ?? 0,
+        };
+    }
+    async updateTestCase(testUuid, patch) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {};
+        if (patch.name !== undefined)
+            body.name = patch.name;
+        if (patch.description !== undefined)
+            body.description = patch.description;
+        if (patch.agentTaskDescription !== undefined)
+            body.agent_task_description = patch.agentTaskDescription;
+        const t = await this.tx.patch(`api/v1/e2e-tests/${testUuid}/`, body);
+        return {
+            uuid: t.uuid,
+            name: t.name,
+            description: t.description,
+            agentTaskDescription: t.agentTaskDescription ?? t.agent_task_description ?? '',
+        };
+    }
+    async disableTestCase(testUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        await this.tx.post(`api/v1/e2e-tests/${testUuid}/disable/`, {});
+        return { uuid: testUuid, isDisabled: true };
+    }
+    async runTestSuite(suiteUuid, params) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {};
+        if (params.targetUrl)
+            body.target_url = params.targetUrl;
+        const s = await this.tx.post(`api/v1/test-suites/${suiteUuid}/run/`, body);
+        return {
+            suiteUuid,
+            runStatus: s?.runStatus ?? s?.run_status ?? 'PENDING',
+            testsTriggered: (s?.tests ?? []).length,
+        };
+    }
+    async getTestSuiteDetail(suiteUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const s = await this.tx.get(`api/v1/test-suites/${suiteUuid}/`);
+        const tests = s.tests ?? [];
+        return {
+            uuid: s.uuid,
+            name: s.name,
+            runStatus: s.runStatus ?? s.run_status ?? 'NEVER_RUN',
+            testsCount: tests.length,
+            passRate: s.passRate ?? s.pass_rate ?? null,
+            lastRunAt: s.lastRunAt ?? s.last_run_at ?? null,
+            tests: tests.map((t) => {
+                // Backend returns cur_run (latest run) per test in the suite detail view
+                const lastRun = t.curRun ?? t.cur_run ?? t.lastRun ?? t.last_run ?? null;
+                return {
+                    uuid: t.uuid,
+                    name: t.name,
+                    runCount: t.runCount ?? t.run_count ?? 0,
+                    passedRunsCount: t.passedRunsCount ?? t.passed_runs_count ?? 0,
+                    failedRunsCount: t.failedRunsCount ?? t.failed_runs_count ?? 0,
+                    passRate: t.passRate ?? t.pass_rate ?? null,
+                    lastRun: lastRun ? {
+                        uuid: lastRun.uuid,
+                        status: lastRun.status,
+                        outcome: lastRun.outcome,
+                        executionTime: lastRun.executionTime ?? lastRun.execution_time ?? null,
+                        timestamp: lastRun.timestamp,
+                    } : null,
+                };
+            }),
+        };
+    }
+    mapTestSuite(s) {
+        return {
+            uuid: s.uuid,
+            name: s.name,
+            description: s.description ?? null,
+            runStatus: s.runStatus ?? s.run_status ?? 'NEVER_RUN',
+            testsCount: s.testsCount ?? s.tests_count ?? 0,
+        };
+    }
 }
 /**
  * Create and initialize a service client

package/dist/services/workflows.js

@@ -29,7 +29,23 @@ export const createWorkflowsService = (tx) => {
             return match;
         },
         async findEvaluationTemplate() {
-            return service.findTemplateByName('app evaluation');
+            // Try keywords in priority order — allows prod ('app evaluation') and
+            // dev backends with different naming ('Browser Use Evaluation Workflow Template')
+            // to both resolve without config changes. 'evaluation workflow' is specific
+            // enough to exclude 'Browser Use Evaluation Brain'.
+            const envOverride = process.env.DEBUGGAI_EVAL_TEMPLATE;
+            const keywords = envOverride
+                ? [envOverride]
+                : ['app evaluation', 'evaluation workflow'];
+            for (const keyword of keywords) {
+                try {
+                    return await service.findTemplateByName(keyword);
+                }
+                catch {
+                    // keyword not matched on this backend, try next
+                }
+            }
+            return null;
         },
         async executeWorkflow(workflowUuid, contextData, env) {
             const body = { contextData };

package/dist/tools/index.js

@@ -10,6 +10,7 @@ import { buildDeleteEnvironmentTool, buildValidatedDeleteEnvironmentTool } from
 import { buildUpdateProjectTool, buildValidatedUpdateProjectTool } from './updateProject.js';
 import { buildDeleteProjectTool, buildValidatedDeleteProjectTool } from './deleteProject.js';
 import { buildCreateProjectTool, buildValidatedCreateProjectTool } from './createProject.js';
+import { buildCreateTestSuiteTool, buildValidatedCreateTestSuiteTool, buildSearchTestSuitesTool, buildValidatedSearchTestSuitesTool, buildDeleteTestSuiteTool, buildValidatedDeleteTestSuiteTool, buildCreateTestCaseTool, buildValidatedCreateTestCaseTool, buildUpdateTestCaseTool, buildValidatedUpdateTestCaseTool, buildDeleteTestCaseTool, buildValidatedDeleteTestCaseTool, buildRunTestSuiteTool, buildValidatedRunTestSuiteTool, buildGetTestSuiteResultsTool, buildValidatedGetTestSuiteResultsTool, } from './testSuiteTools.js';
 let _tools = null;
 let _validatedTools = null;
 const toolRegistry = new Map();
@@ -30,6 +31,14 @@ export function initTools(ctx) {
         buildDeleteProjectTool(),
         buildSearchExecutionsTool(),
         buildCreateProjectTool(),
+        buildCreateTestSuiteTool(),
+        buildSearchTestSuitesTool(),
+        buildDeleteTestSuiteTool(),
+        buildCreateTestCaseTool(),
+        buildUpdateTestCaseTool(),
+        buildDeleteTestCaseTool(),
+        buildRunTestSuiteTool(),
+        buildGetTestSuiteResultsTool(),
     ];
     const validated = [
         buildValidatedTestPageChangesTool(ctx),
@@ -44,6 +53,14 @@ export function initTools(ctx) {
         buildValidatedDeleteProjectTool(),
         buildValidatedSearchExecutionsTool(),
         buildValidatedCreateProjectTool(),
+        buildValidatedCreateTestSuiteTool(),
+        buildValidatedSearchTestSuitesTool(),
+        buildValidatedDeleteTestSuiteTool(),
+        buildValidatedCreateTestCaseTool(),
+        buildValidatedUpdateTestCaseTool(),
+        buildValidatedDeleteTestCaseTool(),
+        buildValidatedRunTestSuiteTool(),
+        buildValidatedGetTestSuiteResultsTool(),
     ];
     _tools = tools;
     _validatedTools = validated;