@debugg-ai/debugg-ai-mcp 1.0.40 → 1.0.42

package/dist/handlers/testPageChangesHandler.js

@@ -9,6 +9,7 @@ import { handleExternalServiceError } from '../utils/errors.js';
 import { fetchImageAsBase64, imageContentBlock } from '../utils/imageUtils.js';
 import { DebuggAIServerClient } from '../services/index.js';
 import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
+import { tunnelManager } from '../services/ngrok/tunnelManager.js';
 const logger = new Logger({ module: 'testPageChangesHandler' });
 // Cache the template UUID and project UUIDs within a server session to avoid re-fetching
 let cachedTemplateUuid = null;
@@ -168,10 +169,10 @@ export async function testPageChangesHandler(input, context, progressCallback) {
                     if (stepsTaken > 0) {
                         // Extract the latest brain.step to show what the agent is doing
                         const latestStep = (exec.nodeExecutions ?? [])
-                            .filter(n => n.nodeType === 'brain.step' && n.outputData?.decision)
+                            .filter(n => n.nodeType === 'brain.step' && n.outputData)
                             .sort((a, b) => b.executionOrder - a.executionOrder)[0];
-                        if (latestStep?.outputData?.decision) {
-                            const d = latestStep.outputData.decision;
+                        const d = latestStep?.outputData?.decision ?? latestStep?.outputData;
+                        if (d) {
                             const action = d.actionType ?? d.action_type ?? 'working';
                             const intent = d.intent;
                             message = intent
@@ -196,15 +197,27 @@ export async function testPageChangesHandler(input, context, progressCallback) {
             }
         }, abortController.signal);
         const duration = Date.now() - startTime;
+        // If the execution failed because the tunnel URL was unreachable, evict the dead tunnel
+        // so the next call re-provisions a fresh one instead of reusing a dead entry.
+        const tunnelErrorMsg = finalExecution.errorMessage ?? finalExecution.state?.error ?? '';
+        if (ctx.tunnelId && tunnelErrorMsg.includes('unreachable') && tunnelErrorMsg.includes('ngrok')) {
+            logger.warn(`Tunnel ${ctx.tunnelId} appears dead (unreachable) — evicting from cache`);
+            tunnelManager.stopTunnel(ctx.tunnelId).catch(() => { });
+            ctx = { ...ctx, tunnelId: undefined };
+        }
         // --- Format result ---
         const outcome = finalExecution.state?.outcome ?? finalExecution.status;
         const nodes = finalExecution.nodeExecutions ?? [];
-        // Extract step-by-step action trace from brain.step nodes
+        // subworkflow.run is the current graph shape — carries outcome, actionHistory, screenshot
+        const subworkflowNode = nodes.find(n => n.nodeType === 'subworkflow.run');
+        // surfer.execute_task and brain.step/brain.evaluate are older graph shapes
+        const surferNode = nodes.find(n => n.nodeType === 'surfer.execute_task');
+        // Action trace: brain.step nodes (old) → subworkflow.run actionHistory (new)
         const brainSteps = nodes
-            .filter(n => n.nodeType === 'brain.step' && n.outputData?.decision)
+            .filter(n => n.nodeType === 'brain.step' && n.outputData)
             .sort((a, b) => a.executionOrder - b.executionOrder);
         const actionTrace = brainSteps.map((n, i) => {
-            const d = n.outputData.decision;
+            const d = n.outputData.decision ?? n.outputData;
             return {
                 step: i + 1,
                 action: d.actionType ?? d.action_type,
@@ -215,33 +228,52 @@ export async function testPageChangesHandler(input, context, progressCallback) {
                 durationMs: n.executionTimeMs,
             };
         });
-        // Extract evaluation from brain.evaluate node
+        const subworkflowHistory = subworkflowNode?.outputData?.actionHistory;
+        if (actionTrace.length === 0 && Array.isArray(subworkflowHistory) && subworkflowHistory.length > 0) {
+            subworkflowHistory.forEach((step, i) => {
+                actionTrace.push({
+                    step: i + 1,
+                    action: step.actionType ?? step.action_type ?? step.action,
+                    intent: step.intent,
+                    target: step.target,
+                    value: step.value ?? undefined,
+                    success: step.success ?? true,
+                    durationMs: step.durationMs ?? step.duration_ms ?? undefined,
+                });
+            });
+        }
+        // Evaluation: brain.evaluate (old) → subworkflow.run outcome/success (new)
         const evalNode = nodes.find(n => n.nodeType === 'brain.evaluate');
-        const evaluation = evalNode?.outputData ? {
-            passed: evalNode.outputData.passed,
-            outcome: evalNode.outputData.outcome,
-            reason: evalNode.outputData.reason,
-            verifications: evalNode.outputData.verifications,
-        } : undefined;
-        // Also check for surfer.execute_task (older workflow graphs)
-        const surferNode = nodes.find(n => n.nodeType === 'surfer.execute_task');
+        let evaluation;
+        if (evalNode?.outputData) {
+            evaluation = {
+                passed: evalNode.outputData.passed,
+                outcome: evalNode.outputData.outcome,
+                reason: evalNode.outputData.reason,
+                verifications: evalNode.outputData.verifications,
+            };
+        }
+        else if (subworkflowNode?.outputData) {
+            const sw = subworkflowNode.outputData;
+            evaluation = {
+                passed: sw.success,
+                outcome: sw.outcome,
+                reason: sw.error || undefined,
+            };
+        }
         const responsePayload = {
             outcome,
-            success: finalExecution.state?.success ?? false,
+            success: finalExecution.state?.success ?? subworkflowNode?.outputData?.success ?? false,
             status: finalExecution.status,
-            stepsTaken: finalExecution.state?.stepsTaken ?? actionTrace.length ?? 0,
+            stepsTaken: finalExecution.state?.stepsTaken ?? subworkflowNode?.outputData?.stepsTaken ?? actionTrace.length,
             targetUrl: originalUrl,
             executionId: executionUuid,
             durationMs: finalExecution.durationMs ?? duration,
         };
-        // The step-by-step action trace — what the browser agent did and why
-        if (actionTrace.length > 0) {
+        if (actionTrace.length > 0)
             responsePayload.actionTrace = actionTrace;
-        }
-        // The final evaluation — pass/fail with reasoning
-        if (evaluation) {
+        if (evaluation)
             responsePayload.evaluation = evaluation;
-        }
         if (finalExecution.state?.error)
             responsePayload.agentError = finalExecution.state.error;
         if (finalExecution.errorMessage)
@@ -262,15 +294,23 @@ export async function testPageChangesHandler(input, context, progressCallback) {
         const content = [
             { type: 'text', text: JSON.stringify(responsePayload, null, 2) },
         ];
-        // Search all node outputs for screenshot/gif URLs — not just the surfer node
-        const SCREENSHOT_KEYS = ['finalScreenshot', 'screenshot', 'screenshotUrl', 'screenshotUri'];
+        // Screenshot: check for already-base64 field first (subworkflow.run), then URL-based fields
+        const SCREENSHOT_URL_KEYS = ['finalScreenshot', 'screenshot', 'screenshotUrl', 'screenshotUri'];
         const GIF_KEYS = ['runGif', 'gifUrl', 'gif', 'videoUrl', 'recordingUrl'];
-        let screenshotUrl = null;
+        let screenshotEmbedded = false;
         let gifUrl = null;
-        for (const node of finalExecution.nodeExecutions ?? []) {
+        // subworkflow.run carries screenshotB64 directly — no fetch needed
+        const screenshotB64 = subworkflowNode?.outputData?.screenshotB64;
+        if (typeof screenshotB64 === 'string' && screenshotB64) {
+            logger.info('Embedding inline base64 screenshot from subworkflow.run');
+            content.push(imageContentBlock(screenshotB64, 'image/png'));
+            screenshotEmbedded = true;
+        }
+        let screenshotUrl = null;
+        for (const node of nodes) {
             const data = node.outputData ?? {};
-            if (!screenshotUrl) {
-                for (const key of SCREENSHOT_KEYS) {
+            if (!screenshotEmbedded && !screenshotUrl) {
+                for (const key of SCREENSHOT_URL_KEYS) {
                     if (typeof data[key] === 'string' && data[key]) {
                         screenshotUrl = data[key];
                         break;
@@ -285,10 +325,10 @@ export async function testPageChangesHandler(input, context, progressCallback) {
                     }
                 }
             }
-            if (screenshotUrl && gifUrl)
+            if ((screenshotEmbedded || screenshotUrl) && gifUrl)
                 break;
         }
-        if (screenshotUrl) {
+        if (!screenshotEmbedded && screenshotUrl) {
             logger.info(`Embedding screenshot: ${screenshotUrl}`);
             const img = await fetchImageAsBase64(screenshotUrl).catch(() => null);
             if (img)

package/package.json

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