@debugg-ai/debugg-ai-mcp 2.5.0 → 2.6.0

package/dist/handlers/probePageHandler.js

@@ -7,16 +7,15 @@
  * (c) MCP-side aggregates per-target HAR slices into NetworkSummary[].
  *
  * The backend "Page Probe" workflow template runs:
- *   browser.setup → loop[targets](page.navigate → page.capture) → done
+ *   browser.setup → loop[targets](browser.navigate → browser.capture) → done
  *
- * Each page.capture node emits per-iteration outputData with consoleSlice
+ * Each browser.capture node emits per-iteration outputData with consoleSlice
  * + harSlice windowed to that URL's load span — that's what makes per-URL
  * networkSummary attribution accurate.
  */
 import { config } from '../config/index.js';
 import { Logger } from '../utils/logger.js';
 import { handleExternalServiceError } from '../utils/errors.js';
-import { imageContentBlock } from '../utils/imageUtils.js';
 import { DebuggAIServerClient } from '../services/index.js';
 import { TunnelProvisionError } from '../services/tunnels.js';
 import { tunnelManager } from '../services/ngrok/tunnelManager.js';
@@ -24,7 +23,7 @@ import { probeLocalPort, probeTunnelHealth } from '../utils/localReachability.js
 import { extractLocalhostPort } from '../utils/urlParser.js';
 import { buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
 import { getCachedTemplateUuid, invalidateTemplateCache } from '../utils/handlerCaches.js';
-import { summarizeHar, summarizeConsole } from '../utils/harSummarizer.js';
+import { reaggregateByOriginPath, mapConsoleSlice } from '../utils/harSummarizer.js';
 const logger = new Logger({ module: 'probePageHandler' });
 const TEMPLATE_KEYWORD = 'page probe';
 export async function probePageHandler(input, context, rawProgressCallback) {
@@ -155,13 +154,35 @@ export async function probePageHandler(input, context, rawProgressCallback) {
                 `Ensure the backend has a template matching "${TEMPLATE_KEYWORD}" seeded and accessible.`);
         }
         // ── Build contextData (camelCase; axiosTransport snake_cases on the wire) ──
+        // Backend's browser.setup node (shared with App Evaluation + Raw Crawl
+        // templates) requires `target_url` (singular). The Page Probe template
+        // currently uses that node as-is — the per-target loop primitive is
+        // pending. Send BOTH:
+        //   - targetUrl: first target's tunneled URL (satisfies browser.setup
+        //     today; will keep working when the loop wraps it later)
+        //   - targets[]: the full per-URL config for when the loop primitive
+        //     ships and iterates over them
+        const firstTargetUrl = targetContexts[0]?.targetUrl ?? input.targets[0].url;
         const contextData = {
+            targetUrl: firstTargetUrl,
             targets: input.targets.map((t, i) => ({
                 url: targetContexts[i].targetUrl ?? t.url,
-                waitForSelector: t.waitForSelector,
+                // Send null (not undefined) for optional fields so the field exists
+                // in the target object even when the caller didn't pass one. Backend
+                // placeholder resolver was fixed in commit 154e1e69 to type-preserve
+                // null in single-placeholder substitutions, so null flows through.
+                waitForSelector: t.waitForSelector ?? null,
                 waitForLoadState: t.waitForLoadState,
                 timeoutMs: t.timeoutMs,
             })),
+            // Backend's browser.capture template binds {{include_dom}} and
+            // {{include_screenshot}} from contextData (verified 2026-04-29).
+            // The MCP-facing schema keeps `includeHtml` / `captureScreenshots`
+            // for caller ergonomics; we just map them to what the template wants.
+            includeDom: input.includeHtml,
+            includeScreenshot: input.captureScreenshots,
+            // Keep the original keys too for any downstream node that reads them
+            // (cheap to send, future-proof against template field-name churn).
             includeHtml: input.includeHtml,
             captureScreenshots: input.captureScreenshots,
         };
@@ -182,7 +203,7 @@ export async function probePageHandler(input, context, rawProgressCallback) {
             }
             if (!progressCallback)
                 return;
-            const completedNodes = (exec.nodeExecutions ?? []).filter(n => n.nodeType === 'page.capture' && n.status === 'success').length;
+            const completedNodes = (exec.nodeExecutions ?? []).filter(n => n.nodeType === 'browser.capture' && n.status === 'success').length;
             if (completedNodes !== lastCompleted) {
                 lastCompleted = completedNodes;
                 await progressCallback({
@@ -195,22 +216,35 @@ export async function probePageHandler(input, context, rawProgressCallback) {
         // ── Format response ────────────────────────────────────────────────────
         const duration = Date.now() - startTime;
         const captureNodes = (finalExecution.nodeExecutions ?? [])
-            .filter(n => n.nodeType === 'page.capture')
+            .filter(n => n.nodeType === 'browser.capture')
             .sort((a, b) => a.executionOrder - b.executionOrder);
         const results = [];
-        const screenshotBlocks = [];
         for (let i = 0; i < input.targets.length; i++) {
             const target = input.targets[i];
             const node = captureNodes[i];
             const data = node?.outputData ?? {};
+            // Backend (post-154e1e69) emits browser.capture output_data with:
+            //   captured_url, status_code, title, load_time_ms,
+            //   console_slice (already per-capture, in {text, level, location, timestamp} shape),
+            //   network_summary (already pre-aggregated by FULL URL,
+            //                    in {url, count, methods[], statuses{}, resource_types[]} shape),
+            //   surfer_page_uuid (reference to SurferPage row for screenshot/title/visible_text),
+            //   error
+            // axiosTransport snake→camel'd at the wire, so JS-side these are
+            // capturedUrl / consoleSlice / networkSummary / surferPageUuid / etc.
+            // Re-aggregate networkSummary by origin+pathname so refetch loops
+            // collapse (preserves the original client-feedback contract).
             const result = {
                 url: target.url, // ORIGINAL caller URL — not the tunneled rewrite
-                finalUrl: typeof data.finalUrl === 'string' ? data.finalUrl : (typeof data.url === 'string' ? data.url : target.url),
+                finalUrl: typeof data.capturedUrl === 'string' ? data.capturedUrl
+                    : typeof data.finalUrl === 'string' ? data.finalUrl
+                        : typeof data.url === 'string' ? data.url
+                            : target.url,
                 statusCode: typeof data.statusCode === 'number' ? data.statusCode : 0,
                 title: typeof data.title === 'string' ? data.title : null,
                 loadTimeMs: typeof data.loadTimeMs === 'number' ? data.loadTimeMs : 0,
-                consoleErrors: summarizeConsole(Array.isArray(data.consoleSlice) ? data.consoleSlice : []),
-                networkSummary: summarizeHar(Array.isArray(data.harSlice) ? data.harSlice : []),
+                consoleErrors: mapConsoleSlice(Array.isArray(data.consoleSlice) ? data.consoleSlice : []),
+                networkSummary: reaggregateByOriginPath(Array.isArray(data.networkSummary) ? data.networkSummary : []),
             };
             if (input.includeHtml && typeof data.html === 'string') {
                 result.html = data.html;
@@ -218,10 +252,16 @@ export async function probePageHandler(input, context, rawProgressCallback) {
             if (typeof data.error === 'string' && data.error) {
                 result.error = data.error;
             }
-            results.push(result);
-            if (input.captureScreenshots && typeof data.screenshotB64 === 'string' && data.screenshotB64) {
-                screenshotBlocks.push(imageContentBlock(data.screenshotB64, 'image/png'));
+            if (typeof data.surferPageUuid === 'string' && data.surferPageUuid) {
+                result.surferPageUuid = data.surferPageUuid;
             }
+            results.push(result);
+            // Backend stores screenshots on the SurferPage row referenced by
+            // surfer_page_uuid; the inline screenshotB64 is no longer in capture
+            // output. v1: skip the per-result image content block; the screenshot
+            // is reachable via search_executions detail's surfer_page_uuid → SurferPage.
+            // (Future enhancement: fetch the SurferPage's presigned screenshot_url
+            // when input.captureScreenshots is true.)
         }
         const responsePayload = {
             executionId: executionUuid,
@@ -247,7 +287,6 @@ export async function probePageHandler(input, context, rawProgressCallback) {
         return {
             content: [
                 { type: 'text', text: JSON.stringify(sanitizedPayload, null, 2) },
-                ...screenshotBlocks,
             ],
         };
     }

package/dist/utils/harSummarizer.js

@@ -7,6 +7,94 @@
  * Pure functions — no I/O, no async — so they can be reused by the future
  * `summarize_execution` tool.
  */
+/**
+ * Re-aggregate backend's pre-grouped network_summary entries by
+ * `origin + pathname` (vs backend's full-URL key). Collapses refetch loops:
+ * 5 separate `/api/poll?n=0..4` entries become 1 entry with count: 5.
+ *
+ * Backend `browser.capture` (commit 154e1e69) emits network_summary already
+ * grouped by full URL with shape `{url, count, methods[], statuses{}, resource_types[]}`.
+ * That preserves the per-request granularity but defeats the original
+ * client #1 use case ("endpoint hit N times" refetch detection). MCP-side
+ * re-aggregation runs once over the small pre-grouped list — cheap.
+ */
+export function reaggregateByOriginPath(entries) {
+    if (!Array.isArray(entries))
+        return [];
+    const buckets = new Map();
+    for (const e of entries) {
+        try {
+            const url = e?.url;
+            if (typeof url !== 'string')
+                continue;
+            const parsed = new URL(url);
+            const key = `${parsed.origin}${parsed.pathname}`;
+            const count = typeof e.count === 'number' ? e.count : 0;
+            const statuses = e.statuses ?? {};
+            const existing = buckets.get(key);
+            if (existing) {
+                existing.count += count;
+                for (const [code, n] of Object.entries(statuses)) {
+                    if (typeof n === 'number') {
+                        existing.statuses[code] = (existing.statuses[code] ?? 0) + n;
+                    }
+                }
+            }
+            else {
+                const out = {
+                    url: key,
+                    count,
+                    statuses: { ...statuses },
+                    totalBytes: 0, // Backend's pre-grouped shape doesn't expose response bytes; placeholder until we wire fetched-bytes.
+                };
+                buckets.set(key, out);
+            }
+        }
+        catch {
+            // malformed URL — skip
+        }
+    }
+    return [...buckets.values()].sort((a, b) => b.count - a.count);
+}
+/**
+ * Map backend's console_slice entry shape to MCP's ConsoleErrorEntry.
+ * Backend shape: {text, level, location: {url, line}, timestamp}
+ * MCP shape:     {level, text, source?, lineNumber?, timestamp?}
+ */
+export function mapConsoleSlice(entries) {
+    if (!Array.isArray(entries))
+        return [];
+    const out = [];
+    for (const e of entries) {
+        if (typeof e !== 'object' || e === null)
+            continue;
+        const entry = {
+            level: typeof e.level === 'string' ? e.level : 'log',
+            text: typeof e.text === 'string' ? e.text : '',
+        };
+        const loc = e.location ?? {};
+        if (typeof loc.url === 'string' && loc.url)
+            entry.source = loc.url;
+        else if (typeof e.source === 'string' && e.source)
+            entry.source = e.source;
+        if (typeof loc.line === 'number')
+            entry.lineNumber = loc.line;
+        else if (typeof e.lineNumber === 'number')
+            entry.lineNumber = e.lineNumber;
+        // Backend timestamps are ISO strings; MCP type uses number (ms since epoch).
+        // Coerce when possible; otherwise pass through unchanged.
+        if (typeof e.timestamp === 'number') {
+            entry.timestamp = e.timestamp;
+        }
+        else if (typeof e.timestamp === 'string') {
+            const parsed = Date.parse(e.timestamp);
+            if (!isNaN(parsed))
+                entry.timestamp = parsed;
+        }
+        out.push(entry);
+    }
+    return out;
+}
 /**
  * Aggregate HAR `log.entries` into per-endpoint NetworkSummary[], sorted
  * descending by request count (hottest endpoints first). Malformed entries

package/package.json

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