@debugg-ai/debugg-ai-mcp 2.3.0 → 2.3.1

package/dist/handlers/testPageChangesHandler.js

@@ -14,10 +14,9 @@ import { detectRepoName } from '../utils/gitContext.js';
 import { tunnelManager } from '../services/ngrok/tunnelManager.js';
 import { probeLocalPort, probeTunnelHealth } from '../utils/localReachability.js';
 import { extractLocalhostPort } from '../utils/urlParser.js';
+import { getCachedTemplateUuid, getCachedProjectUuid, invalidateTemplateCache, invalidateProjectCache, } from '../utils/handlerCaches.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;
-const projectUuidCache = new Map();
+const TEMPLATE_NAME = 'app evaluation';
 // Concurrency control — max 2 simultaneous browser checks.
 // Additional requests queue and run when a slot opens.
 const MAX_CONCURRENT = 2;
@@ -177,41 +176,33 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                 }
             }
         }
-        // --- Find workflow template ---
+        // --- Resolve template + project in parallel (both independent post-tunnel) ---
         if (progressCallback) {
             await progressCallback({ progress: 2, total: TOTAL_STEPS, message: 'Locating evaluation workflow template...' });
         }
-        if (!cachedTemplateUuid) {
-            const template = await client.workflows.findEvaluationTemplate();
-            if (!template) {
-                throw new Error('App Evaluation Workflow Template not found. ' +
-                    'Ensure the template is seeded in the backend (GET /api/v1/workflows/?is_template=true).');
-            }
-            cachedTemplateUuid = template.uuid;
-            logger.info(`Using workflow template: ${template.name} (${template.uuid})`);
-        }
-        // --- Resolve project UUID (best-effort, non-blocking) ---
-        // Use explicit repoName if provided, otherwise auto-detect from git remote
         const repoName = input.repoName || detectRepoName();
-        let projectUuid;
-        if (repoName) {
-            projectUuid = projectUuidCache.get(repoName);
-            if (!projectUuid) {
-                try {
-                    const project = await client.findProjectByRepoName(repoName);
-                    if (project) {
-                        projectUuid = project.uuid;
-                        projectUuidCache.set(repoName, projectUuid);
-                        logger.info(`Resolved project: ${project.name} (${project.uuid})`);
+        const [templateUuid, projectUuid] = await Promise.all([
+            getCachedTemplateUuid(TEMPLATE_NAME, async () => {
+                return client.workflows.findEvaluationTemplate();
+            }),
+            repoName
+                ? getCachedProjectUuid(repoName, async (repo) => {
+                    try {
+                        return await client.findProjectByRepoName(repo);
                     }
-                    else {
-                        logger.info(`No project found for repo "${repoName}" — proceeding without project_id`);
+                    catch (err) {
+                        logger.warn(`Failed to look up project for repo "${repo}": ${err}`);
+                        return null;
                     }
-                }
-                catch (err) {
-                    logger.warn(`Failed to look up project for repo "${repoName}": ${err}`);
-                }
-            }
+                })
+                : Promise.resolve(undefined),
+        ]);
+        if (!templateUuid) {
+            throw new Error('App Evaluation Workflow Template not found. ' +
+                'Ensure the template is seeded in the backend (GET /api/v1/workflows/?is_template=true).');
+        }
+        if (repoName && !projectUuid) {
+            logger.info(`No project found for repo "${repoName}" — proceeding without project_id`);
         }
         // --- Build context data (camelCase here — axiosTransport auto-converts to snake_case) ---
         const contextData = {
@@ -238,7 +229,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         if (progressCallback) {
             await progressCallback({ progress: 3, total: TOTAL_STEPS, message: 'Queuing workflow execution...' });
         }
-        const executeResponse = await client.workflows.executeWorkflow(cachedTemplateUuid, contextData, Object.keys(env).length > 0 ? env : undefined);
+        const executeResponse = await client.workflows.executeWorkflow(templateUuid, contextData, Object.keys(env).length > 0 ? env : undefined);
         const executionUuid = executeResponse.executionUuid;
         logger.info(`Execution queued: ${executionUuid}`);
         // --- Poll ---
@@ -475,7 +466,8 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         const duration = Date.now() - startTime;
         logger.toolError('check_app_in_browser', error, duration);
         if (error instanceof Error && (error.message.includes('not found') || error.message.includes('401'))) {
-            cachedTemplateUuid = null;
+            invalidateTemplateCache();
+            invalidateProjectCache();
         }
         throw handleExternalServiceError(error, 'DebuggAI', 'test execution');
     }

package/dist/handlers/triggerCrawlHandler.js

@@ -19,6 +19,7 @@ import { tunnelManager } from '../services/ngrok/tunnelManager.js';
 import { probeLocalPort, probeTunnelHealth } from '../utils/localReachability.js';
 import { extractLocalhostPort } from '../utils/urlParser.js';
 import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
+import { getCachedTemplateUuid, invalidateTemplateCache } from '../utils/handlerCaches.js';
 const logger = new Logger({ module: 'triggerCrawlHandler' });
 const TEMPLATE_KEYWORD = 'raw crawl';
 export async function triggerCrawlHandler(input, context, rawProgressCallback) {
@@ -114,17 +115,17 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
                 }
             }
         }
-        // --- Find the crawl workflow template ---
+        // --- Find the crawl workflow template (cached across calls) ---
         if (progressCallback) {
             await progressCallback({ progress: 2, total: 4, message: 'Locating crawl workflow template...' });
         }
-        const template = await client.workflows.findTemplateByName(TEMPLATE_KEYWORD);
-        if (!template) {
+        const templateUuid = await getCachedTemplateUuid(TEMPLATE_KEYWORD, async (name) => {
+            return client.workflows.findTemplateByName(name);
+        });
+        if (!templateUuid) {
             throw new Error(`Raw Crawl Workflow Template not found. ` +
                 `Ensure the backend has a template matching "${TEMPLATE_KEYWORD}" seeded and accessible.`);
         }
-        const templateUuid = template.uuid;
-        logger.info(`Using crawl template: ${template.name} (${templateUuid})`);
         // --- Build contextData + env ---
         const contextData = {
             targetUrl: ctx.targetUrl ?? ctx.originalUrl,
@@ -242,6 +243,9 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
     catch (error) {
         const duration = Date.now() - startTime;
         logger.toolError('trigger_crawl', error, duration);
+        if (error instanceof Error && (error.message.includes('not found') || error.message.includes('401'))) {
+            invalidateTemplateCache();
+        }
         throw handleExternalServiceError(error, 'DebuggAI', 'crawl execution');
     }
     finally {

package/dist/services/workflows.js

@@ -4,7 +4,13 @@
  */
 import { Telemetry, TelemetryEvents } from '../utils/telemetry.js';
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
-const POLL_INTERVAL_MS = 3000;
+// Exponential backoff polling: short executions (10-15s crawls) detect terminal
+// status quickly via the early polls; long executions (60-150s browser runs)
+// avoid hammering the backend with 20+ roundtrips. Cap at 5s so we never wait
+// more than 5s past terminal-state achievement.
+const POLL_INTERVAL_INITIAL_MS = 1000;
+const POLL_INTERVAL_MAX_MS = 5000;
+const POLL_BACKOFF_MULTIPLIER = 1.5;
 const EXECUTION_TIMEOUT_MS = 10 * 60 * 1000; // 10 min
 export const createWorkflowsService = (tx) => {
     const service = {
@@ -82,6 +88,7 @@ export const createWorkflowsService = (tx) => {
             const deadline = Date.now() + EXECUTION_TIMEOUT_MS;
             const pollStart = Date.now();
             let pollCount = 0;
+            let intervalMs = POLL_INTERVAL_INITIAL_MS;
             while (Date.now() < deadline) {
                 if (signal?.aborted) {
                     throw new Error(`Polling cancelled for execution ${executionUuid}`);
@@ -99,6 +106,7 @@ export const createWorkflowsService = (tx) => {
                         stepsTaken: execution.state?.stepsTaken ?? 0,
                         durationMs: Date.now() - pollStart,
                         pollCount,
+                        finalIntervalMs: intervalMs,
                     });
                     return execution;
                 }
@@ -106,8 +114,9 @@ export const createWorkflowsService = (tx) => {
                 if (signal?.aborted) {
                     throw new Error(`Polling cancelled for execution ${executionUuid}`);
                 }
+                const sleepMs = intervalMs;
                 await new Promise((resolve, reject) => {
-                    const timer = setTimeout(resolve, POLL_INTERVAL_MS);
+                    const timer = setTimeout(resolve, sleepMs);
                     if (signal) {
                         const onAbort = () => { clearTimeout(timer); reject(new Error(`Polling cancelled for execution ${executionUuid}`)); };
                         if (signal.aborted) {
@@ -118,6 +127,9 @@ export const createWorkflowsService = (tx) => {
                         signal.addEventListener('abort', onAbort, { once: true });
                     }
                 });
+                // Backoff for next iteration — capped at MAX so we don't wait too long
+                // past terminal-state achievement on the longest runs.
+                intervalMs = Math.min(Math.round(intervalMs * POLL_BACKOFF_MULTIPLIER), POLL_INTERVAL_MAX_MS);
             }
             throw new Error(`Execution ${executionUuid} timed out after ${EXECUTION_TIMEOUT_MS / 1000}s`);
         }

package/dist/utils/handlerCaches.js

@@ -0,0 +1,76 @@
+/**
+ * Shared, process-scoped caches for handler hot-path lookups.
+ *
+ * Replaces per-handler `let cachedX: string | null = null` singletons with
+ * a single source of truth. Two handlers (testPageChanges + triggerCrawl)
+ * resolve the same workflow templates and the same project UUIDs; sharing
+ * the cache avoids duplicate backend roundtrips when the user invokes both.
+ *
+ * Each lookup emits a telemetry event with `hit: boolean` so the cache
+ * effectiveness is observable in PostHog without log-grepping.
+ *
+ * Caches are NEVER persisted across processes. Cleared explicitly by the
+ * handlers on auth failures (so a rotated API key doesn't keep serving
+ * stale UUIDs).
+ */
+import { Telemetry, TelemetryEvents } from './telemetry.js';
+const templateUuidByName = new Map();
+const projectUuidByRepo = new Map();
+/**
+ * Get a workflow template UUID by name, populating the cache on miss.
+ * Returns null if the lookup function returns null (template doesn't exist).
+ */
+export async function getCachedTemplateUuid(name, lookup) {
+    const cached = templateUuidByName.get(name);
+    if (cached) {
+        Telemetry.capture(TelemetryEvents.TEMPLATE_LOOKUP, { templateName: name, hit: true });
+        return cached;
+    }
+    const t0 = Date.now();
+    const template = await lookup(name);
+    Telemetry.capture(TelemetryEvents.TEMPLATE_LOOKUP, {
+        templateName: name,
+        hit: false,
+        durationMs: Date.now() - t0,
+        found: !!template,
+    });
+    if (!template)
+        return null;
+    templateUuidByName.set(name, template.uuid);
+    return template.uuid;
+}
+/**
+ * Get a project UUID by repo name, populating the cache on miss.
+ * Returns undefined if the lookup function returns null (no matching project).
+ */
+export async function getCachedProjectUuid(repoName, lookup) {
+    const cached = projectUuidByRepo.get(repoName);
+    if (cached) {
+        Telemetry.capture(TelemetryEvents.PROJECT_LOOKUP, { repoName, hit: true });
+        return cached;
+    }
+    const t0 = Date.now();
+    const project = await lookup(repoName);
+    Telemetry.capture(TelemetryEvents.PROJECT_LOOKUP, {
+        repoName,
+        hit: false,
+        durationMs: Date.now() - t0,
+        found: !!project,
+    });
+    if (!project)
+        return undefined;
+    projectUuidByRepo.set(repoName, project.uuid);
+    return project.uuid;
+}
+/**
+ * Clear the template cache. Called by handlers on auth failures.
+ */
+export function invalidateTemplateCache() {
+    templateUuidByName.clear();
+}
+/**
+ * Clear the project cache. Same trigger as templates.
+ */
+export function invalidateProjectCache() {
+    projectUuidByRepo.clear();
+}

package/dist/utils/telemetry.js

@@ -55,4 +55,6 @@ export const TelemetryEvents = {
     TUNNEL_PROVISIONED: 'tunnel.provisioned',
     TUNNEL_PROVISION_RETRY: 'tunnel.provision_retry',
     TUNNEL_STOPPED: 'tunnel.stopped',
+    TEMPLATE_LOOKUP: 'template.lookup',
+    PROJECT_LOOKUP: 'project.lookup',
 };

package/package.json

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