@debugg-ai/debugg-ai-mcp 1.0.45 → 1.0.47

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

@@ -20,7 +20,8 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { config } from "./config/index.js";
-import { tools, getTool } from "./tools/index.js";
+import { initTools, getTools, getTool } from "./tools/index.js";
+import { resolveProjectContext } from "./services/projectContext.js";
 import { Logger, validateInput, createErrorResponse, toMCPError, handleConfigurationError, Telemetry, TelemetryEvents, } from "./utils/index.js";
 // Initialize logger
 const logger = new Logger({ module: 'main' });
@@ -132,6 +133,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
  * Handle list tools requests
  */
 server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = getTools();
     logger.info('Tools list requested', { toolCount: tools.length });
     return {
         tools: tools,
@@ -162,12 +164,18 @@ async function main() {
             }));
             logger.info('Telemetry enabled (PostHog)');
         }
+        // Resolve project context (repo → project → environments/credentials)
+        // This enriches tool descriptions with available credentials for the detected project.
+        const projectCtx = await resolveProjectContext();
+        initTools(projectCtx);
         // Create and connect transport
         const transport = new StdioServerTransport();
         await server.connect(transport);
+        const tools = getTools();
         logger.info('DebuggAI MCP Server is running and ready to accept requests', {
             transport: 'stdio',
-            toolsAvailable: tools.map(t => t.name)
+            toolsAvailable: tools.map(t => t.name),
+            detectedProject: projectCtx?.project.name ?? null,
         });
     }
     catch (error) {

package/dist/services/projectContext.js

@@ -0,0 +1,78 @@
+/**
+ * Project Context Service
+ * At startup: detect repo → resolve project → fetch environments + credentials.
+ * Exposes the result so tool descriptions can be enriched dynamically.
+ */
+import { config } from '../config/index.js';
+import { DebuggAIServerClient } from './index.js';
+import { detectRepoName } from '../utils/gitContext.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger({ module: 'projectContext' });
+let cached = null;
+let initialized = false;
+/**
+ * Resolve the current project context: repo → project → environments → credentials.
+ * Safe to call multiple times — caches after first successful resolution.
+ */
+export async function resolveProjectContext() {
+    if (initialized)
+        return cached;
+    initialized = true;
+    const repoName = detectRepoName();
+    if (!repoName) {
+        logger.info('No git repo detected — skipping project context');
+        return null;
+    }
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        const project = await client.findProjectByRepoName(repoName);
+        if (!project) {
+            logger.info(`No project found for repo "${repoName}"`);
+            return null;
+        }
+        logger.info(`Resolved project: ${project.name} (${project.uuid})`);
+        // Fetch environments for this project
+        const envResponse = await client.tx.get(`api/v1/projects/${project.uuid}/environments/`);
+        const rawEnvs = envResponse?.results ?? [];
+        // Fetch credentials for each environment in parallel
+        const environments = await Promise.all(rawEnvs
+            .filter((e) => e.isActive)
+            .map(async (env) => {
+            let credentials = [];
+            try {
+                const credResponse = await client.tx.get(`api/v1/projects/${project.uuid}/environments/${env.uuid}/credentials/`);
+                credentials = (credResponse?.results ?? [])
+                    .filter((c) => c.isActive)
+                    .map((c) => ({
+                    uuid: c.uuid,
+                    label: c.label || c.username,
+                    username: c.username,
+                    role: c.role,
+                    environmentName: env.name,
+                    environmentUuid: env.uuid,
+                }));
+            }
+            catch {
+                // Some environments may not support credentials
+            }
+            return {
+                uuid: env.uuid,
+                name: env.name,
+                url: env.url || env.activeUrl || '',
+                credentials,
+            };
+        }));
+        cached = { repoName, project, environments };
+        const totalCreds = environments.reduce((n, e) => n + e.credentials.length, 0);
+        logger.info(`Project context ready: ${environments.length} environments, ${totalCreds} credentials`);
+        return cached;
+    }
+    catch (err) {
+        logger.warn(`Failed to resolve project context: ${err}`);
+        return null;
+    }
+}
+export function getProjectContext() {
+    return cached;
+}

package/dist/services/workflows.js

@@ -23,6 +23,10 @@ export const createWorkflowsService = (tx) => {
         },
         async executeWorkflow(workflowUuid, contextData, env) {
             const body = { contextData };
+            // Send projectId at top level too — backend may read it from either location
+            if (contextData.projectId) {
+                body.projectId = contextData.projectId;
+            }
             if (env && Object.keys(env).length > 0) {
                 body.env = env;
             }

package/dist/tools/index.js

@@ -1,17 +1,25 @@
-import { testPageChangesTool, validatedTestPageChangesTool } from './testPageChanges.js';
-export const tools = [
-    testPageChangesTool,
-];
-export const validatedTools = [
-    validatedTestPageChangesTool,
-];
-export const toolRegistry = new Map();
-for (const tool of validatedTools) {
-    toolRegistry.set(tool.name, tool);
+import { buildTestPageChangesTool, buildValidatedTestPageChangesTool } from './testPageChanges.js';
+let _tools = null;
+let _validatedTools = null;
+const toolRegistry = new Map();
+/**
+ * Initialize tools with project context (call once after resolveProjectContext).
+ */
+export function initTools(ctx) {
+    const tool = buildTestPageChangesTool(ctx);
+    const validated = buildValidatedTestPageChangesTool(ctx);
+    _tools = [tool];
+    _validatedTools = [validated];
+    toolRegistry.clear();
+    toolRegistry.set(validated.name, validated);
+}
+export function getTools() {
+    if (!_tools)
+        initTools(null);
+    return _tools;
 }
 export function getTool(name) {
+    if (!_validatedTools)
+        initTools(null);
     return toolRegistry.get(name);
 }
-export function hasToolTool(name) {
-    return toolRegistry.has(name);
-}

package/dist/tools/testPageChanges.js

@@ -1,62 +1,97 @@
 /**
  * Test Page Changes Tool Definition
- * Defines the check_app_in_browser tool with proper validation
+ * Defines the check_app_in_browser tool with proper validation.
+ * Tool description is enriched at startup with available environments/credentials.
  */
 import { TestPageChangesInputSchema } from '../types/index.js';
 import { testPageChangesHandler } from '../handlers/testPageChangesHandler.js';
+const BASE_DESCRIPTION = `Give an AI agent eyes on a live website or app. The agent browses it, interacts with it, and tells you whether a given task or check passed. Works on localhost or any URL. Use for visual QA, flow validation, regression checks, or anything that needs a real browser to verify.
+
+LOCALHOST SUPPORT: Pass any localhost URL (e.g. http://localhost:3000) and it Just Works. A secure tunnel is automatically created so the remote browser can reach your local dev server — no manual ngrok setup, no port forwarding, no config.`;
 /**
- * Tool definition for testing page changes with DebuggAI
+ * Build the dynamic tool description including available environments/credentials.
  */
-export const testPageChangesTool = {
-    name: "check_app_in_browser",
-    title: "Run E2E Browser Test",
-    description: "Give an AI agent eyes on a live website or app. The agent browses it, interacts with it, and tells you whether a given task or check passed. Works on localhost or any URL. Use for visual QA, flow validation, regression checks, or anything that needs a real browser to verify.\n\nLOCALHOST SUPPORT: Pass any localhost URL (e.g. http://localhost:3000) and it Just Works. A secure tunnel is automatically created so the remote browser can reach your local dev server — no manual ngrok setup, no port forwarding, no config. Supports localhost, 127.0.0.1, 0.0.0.0, [::1], and private IPs (192.168.x.x, 10.x.x.x). The tunnel stays alive for 55 minutes and is reused across calls to the same port.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            description: {
-                type: "string",
-                description: "Natural language description of what to test or evaluate (e.g., 'Does the login form validate empty fields?' or 'Navigate to the homepage and verify the hero section loads')",
-                minLength: 1
-            },
-            url: {
-                type: "string",
-                description: "URL to navigate to. Can be any public URL (https://example.com) OR a localhost/local dev server URL. For localhost URLs (http://localhost:3000, http://127.0.0.1:8080, etc.), a secure tunnel is automatically created so the remote browser can reach your machine — just make sure your dev server is running on that port. No extra setup needed."
-            },
-            environmentId: {
-                type: "string",
-                description: "UUID of a specific environment to use for this test"
-            },
-            credentialId: {
-                type: "string",
-                description: "UUID of a specific credential to use for login"
-            },
-            credentialRole: {
-                type: "string",
-                description: "Pick a credential by role (e.g. 'admin', 'guest') from the resolved environment"
-            },
-            username: {
-                type: "string",
-                description: "Username to log in with (creates or updates a credential idempotently)"
-            },
-            password: {
-                type: "string",
-                description: "Password to log in with (used together with username)"
-            },
-            repoName: {
-                type: "string",
-                description: "GitHub repository name (e.g. 'my-org/my-repo'). Auto-detected from the current git repo — only provide this if you want to run against a different project than the one you're in."
+export function buildToolDescription(ctx) {
+    if (!ctx)
+        return BASE_DESCRIPTION;
+    const envsWithCreds = ctx.environments.filter(e => e.credentials.length > 0);
+    if (envsWithCreds.length === 0) {
+        return `${BASE_DESCRIPTION}\n\nDETECTED PROJECT: "${ctx.project.name}" (repo: ${ctx.repoName}). No credentials configured — provide username/password if the app requires login.`;
+    }
+    const lines = [
+        `\n\nDETECTED PROJECT: "${ctx.project.name}" (repo: ${ctx.repoName})`,
+        `\nAVAILABLE ENVIRONMENTS & CREDENTIALS (pass environmentId + credentialId for authenticated testing):`,
+    ];
+    for (const env of envsWithCreds) {
+        lines.push(`\n  Environment: "${env.name}" (${env.uuid})${env.url ? ` — ${env.url}` : ''}`);
+        for (const cred of env.credentials) {
+            const parts = [`    - "${cred.label}" (${cred.uuid}) — user: ${cred.username}`];
+            if (cred.role)
+                parts[0] += `, role: ${cred.role}`;
+            lines.push(parts[0]);
+        }
+    }
+    lines.push(`\nTo use: pass environmentId and credentialId from above. Or provide username/password directly.`);
+    return BASE_DESCRIPTION + lines.join('\n');
+}
+/**
+ * Build the full tool definition, optionally enriched with project context.
+ */
+export function buildTestPageChangesTool(ctx) {
+    return {
+        name: "check_app_in_browser",
+        title: "Run E2E Browser Test",
+        description: buildToolDescription(ctx),
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "Natural language description of what to test or evaluate (e.g., 'Does the login form validate empty fields?' or 'Navigate to the homepage and verify the hero section loads')",
+                    minLength: 1
+                },
+                url: {
+                    type: "string",
+                    description: "URL to navigate to. Can be any public URL (https://example.com) OR a localhost/local dev server URL. For localhost URLs, a secure tunnel is automatically created — just make sure your dev server is running on that port."
+                },
+                environmentId: {
+                    type: "string",
+                    description: "UUID of a specific environment to use for this test. See available environments in the tool description above."
+                },
+                credentialId: {
+                    type: "string",
+                    description: "UUID of a specific credential to use for login. See available credentials in the tool description above."
+                },
+                credentialRole: {
+                    type: "string",
+                    description: "Pick a credential by role (e.g. 'admin', 'guest') from the resolved environment"
+                },
+                username: {
+                    type: "string",
+                    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: "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",
+                    description: "GitHub repository name (e.g. 'my-org/my-repo'). Auto-detected from the current git repo — only provide this if you want to run against a different project than the one you're in."
+                },
             },
+            required: ["description", "url"],
+            additionalProperties: false
         },
-        required: ["description", "url"],
-        additionalProperties: false
-    },
-};
+    };
+}
 /**
- * Validated tool with schema and handler
+ * Build the validated tool with schema and handler.
  */
-export const validatedTestPageChangesTool = {
-    ...testPageChangesTool,
-    inputSchema: TestPageChangesInputSchema,
-    handler: testPageChangesHandler,
-};
+export function buildValidatedTestPageChangesTool(ctx) {
+    const tool = buildTestPageChangesTool(ctx);
+    return {
+        ...tool,
+        inputSchema: TestPageChangesInputSchema,
+        handler: testPageChangesHandler,
+    };
+}

package/package.json

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