@debugg-ai/debugg-ai-mcp 3.5.3 → 3.6.0

package/dist/handlers/testPageChangesHandler.js

@@ -91,12 +91,26 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
     const originalUrl = resolveTargetUrl(input);
     let ctx = buildContext(originalUrl);
     let keyId;
+    // Cancellation is driven by the MCP request/transport lifecycle, not
+    // process.stdin. The SDK aborts context.signal when the client cancels the
+    // call OR the transport closes — e.g. an HTTP client drops the connection.
+    // Under the stateless HTTP transport that is the ONLY signal we get: stdin is
+    // not the transport, so the old stdin 'close' listener never fired and a
+    // dropped client kept polling for up to ~10 min, holding one of just
+    // MAX_CONCURRENT=2 slots. Wiring to context.signal cancels the poll and frees
+    // the slot immediately.
     const abortController = new AbortController();
-    const onStdinClose = () => {
+    const onAbort = () => {
         abortController.abort();
         progressDisabled = true; // client is gone — stop emitting
     };
-    process.stdin.once('close', onStdinClose);
+    const requestSignal = context.signal;
+    if (requestSignal) {
+        if (requestSignal.aborted)
+            onAbort();
+        else
+            requestSignal.addEventListener('abort', onAbort, { once: true });
+    }
     // Progress budget: 3 setup steps + 25 execution steps = 28 total
     const SETUP_STEPS = 3;
     const MAX_EXEC_STEPS = 25;
@@ -226,8 +240,22 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
             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`);
+        // Fail fast + actionable when project_id can't be resolved (pinned backend
+        // semantics: project_id is required). Surfacing "link this repo to a
+        // project" now — before executeWorkflow — beats letting a backend workflow
+        // node fail mid-run several minutes into the evaluation.
+        if (!projectUuid) {
+            const detail = repoName
+                ? `Repo "${repoName}" isn't linked to a DebuggAI project.`
+                : 'No git repository was detected to resolve a project from.';
+            const payload = {
+                error: 'ProjectRequired',
+                message: `project_id is required but could not be resolved. ${detail} ` +
+                    'Link this repo to a project at https://debugg.ai (Projects → connect your repository), then retry. ' +
+                    'To evaluate a different repo than the current one, pass repoName.',
+            };
+            logger.warn(`check_app_in_browser: ${payload.message}`);
+            return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
         }
         // --- Build context data (camelCase here — axiosTransport auto-converts to snake_case) ---
         const contextData = {
@@ -593,7 +621,8 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         throw handleExternalServiceError(error, 'DebuggAI', 'test execution');
     }
     finally {
-        process.stdin.removeListener('close', onStdinClose);
+        if (requestSignal)
+            requestSignal.removeEventListener('abort', onAbort);
         // Tunnel is intentionally NOT torn down here — tunnelManager reuses it on
         // subsequent calls to the same port and auto-shutoffs after 55 min idle.
         // Process-exit cleanup happens via stopAllTunnels() in the SIGINT/SIGTERM

package/dist/index.js

@@ -90,7 +90,7 @@ export function buildConfiguredServer() {
  * singleton in main(), and once per request by the HTTP transport (stateless).
  */
 function registerHandlers(srv) {
-    srv.setRequestHandler(CallToolRequestSchema, async (req) => {
+    srv.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
         const typedReq = req;
         const requestId = `req_${Date.now()}`;
         const requestLogger = logger.child({ requestId });
@@ -123,6 +123,9 @@ function registerHandlers(srv) {
                 progressToken: typeof progressToken === 'string' ? progressToken : undefined,
                 requestId,
                 timestamp: new Date(),
+                // Cancellation source for long-running handlers: the SDK aborts this
+                // signal when the client cancels the call or the transport closes.
+                signal: extra?.signal,
             };
             const progressCallback = createProgressCallback(srv, typeof progressToken === 'string' || typeof progressToken === 'number' ? String(progressToken) : undefined);
             requestLogger.info(`Executing tool: ${name}`);

package/dist/services/projectContext.js

@@ -1,7 +1,12 @@
 /**
  * Project Context Service
- * At startup: detect repo → resolve project → fetch environments + credentials.
- * Exposes the result so tool descriptions can be enriched dynamically.
+ * At startup (lazily, on first tool call): detect repo → resolve project →
+ * fetch environments + credential LABELS. Exposes the result so tool
+ * descriptions can be enriched dynamically (see tools/index.ts).
+ *
+ * Thin relay: we consume the backend's environment/credential contract and
+ * surface LABELS ONLY — never a password or any other secret. The
+ * backend→internal field mapping lives in ONE place: mapEnvironments().
  */
 import { config } from '../config/index.js';
 import { DebuggAIServerClient } from './index.js';
@@ -10,14 +15,54 @@ import { Logger } from '../utils/logger.js';
 const logger = new Logger({ module: 'projectContext' });
 let cached = null;
 let inFlight = null;
+const STARTUP_TIMEOUT_MS = 10_000;
 /**
- * Resolve the current project context: repo → project → environments → credentials.
+ * The ONE place the backend environment/credential contract is mapped to our
+ * internal shape. Pinned contract (backend epic sentinal-k8x1f.8):
+ *
+ *   GET /api/v1/environments/?project=<uuid>
+ *     → [{ uuid, name, url, is_default, is_active, endpoint_type,
+ *          credentials: [{ label, username }] }]
+ *
+ * (The axios transport auto-converts snake_case → camelCase, so we read
+ * `isDefault`/`isActive`/`endpointType` here.) Password is write-only and
+ * NEVER returned; we defensively copy only label/username (+ uuid/role if the
+ * backend ever includes them) — we never spread a raw credential object, so a
+ * secret can't leak into a tool description even if the contract regresses.
+ */
+export function mapEnvironments(rawEnvs) {
+    return (rawEnvs ?? [])
+        // Surface only active environments (is_active !== false).
+        .filter((e) => e?.isActive !== false)
+        .map((env) => ({
+        uuid: env.uuid,
+        name: env.name,
+        url: env.url || env.activeUrl || '',
+        isDefault: env.isDefault ?? false,
+        isActive: env.isActive ?? true,
+        endpointType: env.endpointType ?? null,
+        credentials: (env.credentials ?? [])
+            .filter((c) => c && c.isActive !== false)
+            .map((c) => ({
+            label: c.label || c.username,
+            username: c.username,
+            ...(c.uuid ? { uuid: c.uuid } : {}),
+            ...(c.role !== undefined ? { role: c.role } : {}),
+            environmentName: env.name,
+            environmentUuid: env.uuid,
+        })),
+    }));
+}
+/**
+ * Resolve the current project context: repo → project → environments →
+ * credential labels.
  *
  * Caches the first successful result. Concurrent calls share a single in-flight
- * promise. Failures are NOT cached — the next call will retry — so a transient
- * network error on the first tool call doesn't permanently disable the service.
+ * promise. Failures are NOT cached — the next call retries — so a transient
+ * network error on the first tool call doesn't permanently disable enrichment.
+ * The whole resolution is bounded by STARTUP_TIMEOUT_MS so a slow/hung backend
+ * can never block boot or a tool call.
  */
-const STARTUP_TIMEOUT_MS = 10_000;
 export async function resolveProjectContext() {
     if (cached)
         return cached;
@@ -67,40 +112,15 @@ async function resolveProjectContextInner(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,
-            };
-        }));
+        // Pinned contract: environments (with credentials inlined) for the project.
+        const envResponse = await client.tx.get('api/v1/environments/', {
+            project: project.uuid,
+        });
+        const rawEnvs = Array.isArray(envResponse) ? envResponse : (envResponse?.results ?? []);
+        const environments = mapEnvironments(rawEnvs);
         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`);
+        logger.info(`Project context ready: ${environments.length} environments, ${totalCreds} credential labels`);
         return cached;
     }
     catch (err) {
@@ -111,3 +131,8 @@ async function resolveProjectContextInner(repoName) {
 export function getProjectContext() {
     return cached;
 }
+/** Test-only: reset the module cache so each test starts clean. */
+export function __resetProjectContextForTests() {
+    cached = null;
+    inFlight = null;
+}

package/dist/tools/index.js

@@ -6,9 +6,36 @@ import { buildEnvironmentTool, buildValidatedEnvironmentTool } from './environme
 import { buildExecutionsTool, buildValidatedExecutionsTool } from './executions.js';
 import { buildTestSuiteTool, buildValidatedTestSuiteTool } from './testSuite.js';
 import { buildTestCaseTool, buildValidatedTestCaseTool } from './testCase.js';
+import { resolveProjectContext } from '../services/projectContext.js';
 let _tools = null;
 let _validatedTools = null;
 const toolRegistry = new Map();
+let enrichmentTriggered = false;
+/**
+ * Lazily resolve project → environments → credential labels ON FIRST USE and
+ * rebuild the tool definitions so the enriched description (available
+ * environments + credential labels) is served on the next tools/list.
+ *
+ * Fire-and-forget: this never blocks the triggering call. resolveProjectContext
+ * has its own 10s timeout, so boot and the first tool call are never gated on a
+ * slow backend. Idempotent — the first invocation wins; the cached context
+ * makes subsequent resolves free.
+ */
+function triggerEnrichmentOnce() {
+    if (enrichmentTriggered)
+        return;
+    enrichmentTriggered = true;
+    resolveProjectContext()
+        .then((ctx) => {
+        // Only rebuild when we actually resolved a linked project; otherwise the
+        // base description stays (no project detected / not linked).
+        if (ctx)
+            initTools(ctx);
+    })
+        .catch(() => {
+        // Best-effort enrichment — a failure leaves the base description in place.
+    });
+}
 /**
  * Initialize tools with project context (call once after resolveProjectContext).
  *
@@ -46,10 +73,12 @@ export function initTools(ctx) {
 export function getTools() {
     if (!_tools)
         initTools(null);
+    triggerEnrichmentOnce();
     return _tools;
 }
 export function getTool(name) {
     if (!_validatedTools)
         initTools(null);
+    triggerEnrichmentOnce();
     return toolRegistry.get(name);
 }

package/dist/tools/testPageChanges.js

@@ -26,12 +26,16 @@ export function buildToolDescription(ctx) {
         `\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}` : ''}`);
+        const defaultTag = env.isDefault ? ' [default]' : '';
+        lines.push(`\n  Environment: "${env.name}" (${env.uuid})${defaultTag}${env.url ? ` — ${env.url}` : ''}`);
         for (const cred of env.credentials) {
-            const parts = [`    - "${cred.label}" (${cred.uuid}) — user: ${cred.username}`];
+            // The backend contract surfaces credential LABELS (never passwords). The
+            // uuid/role are optional — shown only when the backend includes them.
+            const idPart = cred.uuid ? ` (${cred.uuid})` : '';
+            let line = `    - "${cred.label}"${idPart} — user: ${cred.username}`;
             if (cred.role)
-                parts[0] += `, role: ${cred.role}`;
-            lines.push(parts[0]);
+                line += `, role: ${cred.role}`;
+            lines.push(line);
         }
     }
     lines.push(`\nTo use: pass environmentId and credentialId from above. Or provide username/password directly.`);

package/package.json

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