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

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/index.js

@@ -47,26 +47,30 @@ export class DebuggAIServerClient {
         this.tunnels = createTunnelsService(this.tx);
     }
     /**
-     * Look up a project by repo name. Uses ?search= then client-side filters
-     * on repo.name (which is "owner/repo-name" format).
-     * Returns the first match or null.
+     * Look up a project by repo name.
+     * Accepts "owner/repo" or bare "repo" — searches with the short name
+     * (more likely to match project names) then ranks results by match quality.
      */
     async findProjectByRepoName(repoName) {
         if (!this.tx)
             throw new Error('Client not initialized — call init() first');
-        const response = await this.tx.get('api/v1/projects/', { search: repoName });
+        // "debugg-ai/react-web-app" → short = "react-web-app"
+        const short = repoName.includes('/') ? repoName.split('/').pop() : repoName;
+        const response = await this.tx.get('api/v1/projects/', { search: short });
         const projects = response?.results ?? [];
         if (projects.length === 0)
             return null;
-        // Exact match on project name or slug first
-        const exact = projects.find(p => p.name === repoName || p.slug === repoName);
+        // Exact match on full "owner/repo" or short name against project name/slug
+        const exact = projects.find(p => p.name === repoName || p.name === short
+            || p.slug === repoName || p.slug === short);
         if (exact)
             return exact;
-        // Match on repo.name (owner/repo-name — check if it ends with /repoName)
-        const repoMatch = projects.find(p => p.repo?.name === repoName || p.repo?.name?.endsWith(`/${repoName}`));
+        // Match on repo.name — backend may store "owner/repo" or just "repo"
+        const repoMatch = projects.find(p => p.repo?.name === repoName || p.repo?.name === short
+            || p.repo?.name?.endsWith(`/${short}`));
         if (repoMatch)
             return repoMatch;
-        // Fallback to first result from search
+        // Fallback to first search result
         return projects[0];
     }
     /**

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: "Username to log in with (alternative to credentialId — 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."
+                },
             },
+            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.44",
+  "version": "1.0.46",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {