@debugg-ai/debugg-ai-mcp 1.0.46 → 1.0.48

package/dist/handlers/testPageChangesHandler.js

@@ -132,72 +132,69 @@ export async function testPageChangesHandler(input, context, progressCallback) {
         const executionUuid = executeResponse.executionUuid;
         logger.info(`Execution queued: ${executionUuid}`);
         // --- Poll ---
-        // Track execution progress via state.stepsTaken from the API.
-        // Setup is steps 1-3, execution maps stepsTaken into steps 4-28 (25 slots).
+        // Progress phases:
+        //   1-3:   MCP setup (tunnel, template, queue) — already sent above
+        //   4-6:   Backend setup (trigger, browser.setup, subworkflow starting)
+        //   7-27:  Agent steps (mapped from state.stepsTaken)
+        //   28:    Complete
+        const BACKEND_SETUP_END = 6;
         let lastStepsTaken = 0;
-        let lastNodeCount = 0;
         let observedMaxSteps = MAX_EXEC_STEPS;
         const finalExecution = await client.workflows.pollExecution(executionUuid, async (exec) => {
             // Keep the tunnel alive while the workflow is actively running
             if (ctx.tunnelId)
                 touchTunnelById(ctx.tunnelId);
-            const nodeCount = exec.nodeExecutions?.length ?? 0;
-            const brainStepCount = (exec.nodeExecutions ?? [])
-                .filter(n => n.nodeType === 'brain.step').length;
-            // Prefer actual brain.step node count over API stepsTaken (which may lag)
-            const stepsTaken = Math.max(brainStepCount, exec.state?.stepsTaken ?? 0);
-            if (nodeCount !== lastNodeCount || stepsTaken !== lastStepsTaken || exec.status !== 'pending') {
-                lastNodeCount = nodeCount;
+            const nodes = exec.nodeExecutions ?? [];
+            const stepsTaken = Math.max(nodes.filter(n => n.nodeType === 'brain.step').length, exec.state?.stepsTaken ?? 0);
+            if (stepsTaken !== lastStepsTaken) {
                 lastStepsTaken = stepsTaken;
-                logger.info(`Execution status: ${exec.status}, nodes: ${nodeCount}, steps: ${stepsTaken}`);
+                logger.info(`Execution status: ${exec.status}, nodes: ${nodes.length}, steps: ${stepsTaken}`);
             }
-            if (progressCallback) {
-                // If we see steps > our assumed max, bump our ceiling so progress never goes backwards
-                if (stepsTaken > observedMaxSteps) {
+            if (!progressCallback)
+                return;
+            // --- Compute progress number ---
+            let execProgress;
+            let message;
+            if (stepsTaken > 0) {
+                // Agent is actively stepping — map into slots 7..27
+                if (stepsTaken > observedMaxSteps)
                     observedMaxSteps = stepsTaken + 5;
-                }
-                // Map stepsTaken (0..observedMaxSteps) into progress (SETUP_STEPS+1 .. TOTAL_STEPS-1)
-                // Reserve the last tick for the "Complete" message
-                let execProgress;
-                if (stepsTaken > 0) {
-                    execProgress = SETUP_STEPS + Math.round((stepsTaken / observedMaxSteps) * (MAX_EXEC_STEPS - 1));
+                const stepSlots = TOTAL_STEPS - BACKEND_SETUP_END - 1; // 21 slots
+                execProgress = BACKEND_SETUP_END + Math.max(1, Math.round((stepsTaken / observedMaxSteps) * stepSlots));
+                execProgress = Math.min(execProgress, TOTAL_STEPS - 1);
+                // Use state.currentAction for the message (backend sends intent + actionType)
+                const ca = exec.state?.currentAction;
+                if (ca?.intent) {
+                    const action = ca.actionType ?? ca.action_type ?? 'working';
+                    message = `Step ${stepsTaken}: [${action}] ${ca.intent}`;
                 }
                 else {
-                    // No steps yet — show we're past setup but execution is starting
-                    execProgress = SETUP_STEPS + 1;
+                    message = `Agent evaluating... (step ${stepsTaken})`;
                 }
-                execProgress = Math.min(execProgress, TOTAL_STEPS - 1);
-                let message;
-                if (exec.status === 'running') {
-                    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)
-                            .sort((a, b) => b.executionOrder - a.executionOrder)[0];
-                        const d = latestStep?.outputData?.decision ?? latestStep?.outputData;
-                        if (d) {
-                            const action = d.actionType ?? d.action_type ?? 'working';
-                            const intent = d.intent;
-                            message = intent
-                                ? `Step ${stepsTaken}: [${action}] ${intent}`
-                                : `Step ${stepsTaken}: ${action}`;
-                        }
-                        else {
-                            message = `Agent evaluating app... (step ${stepsTaken})`;
-                        }
-                    }
-                    else if (nodeCount === 0) {
-                        message = 'Browser agent starting up...';
-                    }
-                    else {
-                        message = 'Browser ready, agent navigating...';
-                    }
+            }
+            else {
+                // No agent steps yet — show backend setup progress from node transitions
+                const hasSubworkflow = nodes.some(n => n.nodeType === 'subworkflow.run');
+                const hasBrowserSetup = nodes.some(n => n.nodeType === 'browser.setup');
+                const browserReady = nodes.some(n => n.nodeType === 'browser.setup' && n.status === 'success');
+                if (browserReady || hasSubworkflow) {
+                    execProgress = BACKEND_SETUP_END;
+                    message = 'Browser ready, agent starting...';
+                }
+                else if (hasBrowserSetup) {
+                    execProgress = SETUP_STEPS + 2;
+                    message = 'Launching browser...';
+                }
+                else if (nodes.length > 0) {
+                    execProgress = SETUP_STEPS + 1;
+                    message = 'Workflow triggered, preparing...';
                 }
                 else {
-                    message = exec.status;
+                    execProgress = SETUP_STEPS + 1;
+                    message = 'Waiting for execution to start...';
                 }
-                await progressCallback({ progress: execProgress, total: TOTAL_STEPS, message });
             }
+            await progressCallback({ progress: execProgress, total: TOTAL_STEPS, message });
         }, abortController.signal);
         const duration = Date.now() - startTime;
         // --- Format result ---

package/dist/index.js

@@ -199,6 +199,18 @@ process.on('SIGTERM', async () => {
     await Telemetry.shutdown();
     process.exit(0);
 });
+process.on('unhandledRejection', (reason) => {
+    logger.error('Unhandled promise rejection', {
+        error: reason instanceof Error ? reason.message : String(reason),
+        stack: reason instanceof Error ? reason.stack : undefined,
+    });
+});
+process.on('uncaughtException', (error) => {
+    logger.error('Uncaught exception', {
+        error: error.message,
+        stack: error.stack,
+    });
+});
 /**
  * Start the server
  */

package/dist/services/projectContext.js

@@ -14,6 +14,7 @@ let initialized = false;
  * Resolve the current project context: repo → project → environments → credentials.
  * Safe to call multiple times — caches after first successful resolution.
  */
+const STARTUP_TIMEOUT_MS = 10_000; // hard cap so we never block MCP connection
 export async function resolveProjectContext() {
     if (initialized)
         return cached;
@@ -23,6 +24,24 @@ export async function resolveProjectContext() {
         logger.info('No git repo detected — skipping project context');
         return null;
     }
+    try {
+        // Race against a timeout so a slow/unreachable backend never blocks startup
+        return await Promise.race([
+            resolveProjectContextInner(repoName),
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    logger.warn('Project context resolution timed out — continuing without it');
+                    resolve(null);
+                }, STARTUP_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    catch (err) {
+        logger.warn(`Failed to resolve project context: ${err}`);
+        return null;
+    }
+}
+async function resolveProjectContextInner(repoName) {
     try {
         const client = new DebuggAIServerClient(config.api.key);
         await client.init();

package/dist/services/workflows.js

@@ -71,13 +71,20 @@ export const createWorkflowsService = (tx) => {
                     });
                     return execution;
                 }
+                // Check abort before sleeping to avoid missing a signal fired between polls
+                if (signal?.aborted) {
+                    throw new Error(`Polling cancelled for execution ${executionUuid}`);
+                }
                 await new Promise((resolve, reject) => {
                     const timer = setTimeout(resolve, POLL_INTERVAL_MS);
                     if (signal) {
-                        signal.addEventListener('abort', () => {
+                        const onAbort = () => { clearTimeout(timer); reject(new Error(`Polling cancelled for execution ${executionUuid}`)); };
+                        if (signal.aborted) {
                             clearTimeout(timer);
                             reject(new Error(`Polling cancelled for execution ${executionUuid}`));
-                        }, { once: true });
+                            return;
+                        }
+                        signal.addEventListener('abort', onAbort, { once: true });
                     }
                 });
             }

package/dist/tools/testPageChanges.js

@@ -68,11 +68,11 @@ export function buildTestPageChangesTool(ctx) {
                 },
                 username: {
                     type: "string",
-                    description: "Username to log in with (alternative to credentialId — creates or updates a credential idempotently)"
+                    description: "A real, existing account email for the target app. Do NOT invent or guess credentials — use one from the available credentials listed above, or ask the user. The browser agent will type this into the login form."
                 },
                 password: {
                     type: "string",
-                    description: "Password to log in with (used together with username)"
+                    description: "The real password for the username above. Do NOT guess or use placeholder passwords — use credentials from the list above or ask the user."
                 },
                 repoName: {
                     type: "string",

package/dist/utils/axiosTransport.js

@@ -14,6 +14,7 @@ export class AxiosTransport {
             instance ??
                 axios.create({
                     baseURL: baseUrl.replace(/\/+$/, "/"),
+                    timeout: 30_000,
                     headers: {
                         Accept: "application/json",
                         "Content-Type": "application/json",

package/package.json

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