@debugg-ai/debugg-ai-mcp 1.0.54 → 1.0.56

package/dist/handlers/listEnvironmentsHandler.js

@@ -0,0 +1,59 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+import { detectRepoName } from '../utils/gitContext.js';
+const logger = new Logger({ module: 'listEnvironmentsHandler' });
+export async function listEnvironmentsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('list_environments', { projectUuid: input.projectUuid, q: input.q });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        let projectName = null;
+        let projectRepoName = null;
+        if (!projectUuid) {
+            const repoName = detectRepoName();
+            if (!repoName) {
+                const payload = {
+                    error: 'NoProjectResolved',
+                    message: 'No git repo detected and no projectUuid provided. Pass projectUuid (get it from list_projects) or invoke from a directory with a git origin.',
+                    environments: [],
+                };
+                logger.toolComplete('list_environments', Date.now() - start);
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+            }
+            const project = await client.findProjectByRepoName(repoName);
+            if (!project) {
+                const payload = {
+                    error: 'NoProjectResolved',
+                    message: `No DebuggAI project found for repo "${repoName}". Pass projectUuid explicitly or call list_projects to discover.`,
+                    environments: [],
+                };
+                logger.toolComplete('list_environments', Date.now() - start);
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+            }
+            projectUuid = project.uuid;
+            projectName = project.name;
+            projectRepoName = project.repo?.name ?? repoName;
+        }
+        const environments = await client.listEnvironmentsForProject(projectUuid, input.q);
+        const payload = {
+            project: {
+                uuid: projectUuid,
+                name: projectName,
+                repoName: projectRepoName,
+            },
+            query: input.q ?? null,
+            count: environments.length,
+            environments,
+        };
+        logger.toolComplete('list_environments', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('list_environments', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'list_environments');
+    }
+}

package/dist/handlers/listExecutionsHandler.js

@@ -0,0 +1,31 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+const logger = new Logger({ module: 'listExecutionsHandler' });
+export async function listExecutionsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('list_executions', { status: input.status, limit: input.limit });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        const { count, executions } = await client.workflows.listExecutions({
+            status: input.status,
+            limit: input.limit,
+        });
+        const payload = {
+            filter: {
+                status: input.status ?? null,
+                limit: input.limit ?? null,
+            },
+            count,
+            executions,
+        };
+        logger.toolComplete('list_executions', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('list_executions', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'list_executions');
+    }
+}

package/dist/handlers/listProjectsHandler.js

@@ -0,0 +1,30 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+const logger = new Logger({ module: 'listProjectsHandler' });
+export async function listProjectsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('list_projects', { q: input.q });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        const projects = await client.listProjects(input.q);
+        const payload = {
+            query: input.q ?? null,
+            count: projects.length,
+            projects: projects.map(p => ({
+                uuid: p.uuid,
+                name: p.name,
+                slug: p.slug,
+                repoName: p.repo?.name ?? null,
+            })),
+        };
+        logger.toolComplete('list_projects', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('list_projects', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'list_projects');
+    }
+}

package/dist/handlers/testPageChangesHandler.js

@@ -312,8 +312,11 @@ async function testPageChangesHandlerInner(input, context, progressCallback) {
         if (progressCallback) {
             await progressCallback({ progress: TOTAL_STEPS, total: TOTAL_STEPS, message: `Complete: ${outcome}` });
         }
+        // Sanitize the whole payload so no tunnel URL leaks anywhere — including
+        // agent-authored strings in actionTrace[*].intent, evaluation.reason, etc.
+        const sanitizedPayload = sanitizeResponseUrls(responsePayload, ctx);
         const content = [
-            { type: 'text', text: JSON.stringify(responsePayload, null, 2) },
+            { type: 'text', text: JSON.stringify(sanitizedPayload, null, 2) },
         ];
         // Screenshot: check for already-base64 field first (subworkflow.run), then URL-based fields
         const SCREENSHOT_URL_KEYS = ['finalScreenshot', 'screenshot', 'screenshotUrl', 'screenshotUri'];

package/dist/handlers/updateCredentialHandler.js

@@ -0,0 +1,70 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+import { detectRepoName } from '../utils/gitContext.js';
+const logger = new Logger({ module: 'updateCredentialHandler' });
+function notFound(uuid, context) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({
+                    error: 'NotFound',
+                    message: `Credential ${uuid} not found (${context}).`,
+                    uuid,
+                }, null, 2) }],
+        isError: true,
+    };
+}
+// Defensive stripper: ensure no password/secret keys slip through into responses.
+function stripSecrets(obj) {
+    const copy = { ...obj };
+    delete copy.password;
+    delete copy.secret;
+    return copy;
+}
+export async function updateCredentialHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('update_credential', {
+        uuid: input.uuid,
+        environmentId: input.environmentId,
+        patchKeys: Object.keys(input).filter(k => !['uuid', 'environmentId', 'projectUuid', 'password'].includes(k)).concat(input.password !== undefined ? ['password'] : []),
+    });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        if (!projectUuid) {
+            const repoName = detectRepoName();
+            if (!repoName)
+                return notFound(input.uuid, 'no git repo and no projectUuid');
+            const project = await client.findProjectByRepoName(repoName);
+            if (!project)
+                return notFound(input.uuid, `no project for repo "${repoName}"`);
+            projectUuid = project.uuid;
+        }
+        try {
+            const credential = await client.updateCredential(projectUuid, input.environmentId, input.uuid, {
+                label: input.label,
+                username: input.username,
+                password: input.password,
+                role: input.role,
+            });
+            logger.toolComplete('update_credential', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            updated: true,
+                            credential: stripSecrets(credential),
+                        }, null, 2) }],
+            };
+        }
+        catch (err) {
+            if (err?.statusCode === 404 || err?.response?.status === 404) {
+                return notFound(input.uuid, `backend 404 for env ${input.environmentId}`);
+            }
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('update_credential', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'update_credential');
+    }
+}

package/dist/handlers/updateEnvironmentHandler.js

@@ -0,0 +1,59 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+import { detectRepoName } from '../utils/gitContext.js';
+const logger = new Logger({ module: 'updateEnvironmentHandler' });
+function notFound(uuid, context) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({
+                    error: 'NotFound',
+                    message: `Environment ${uuid} not found (${context}).`,
+                    uuid,
+                }, null, 2) }],
+        isError: true,
+    };
+}
+export async function updateEnvironmentHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('update_environment', {
+        uuid: input.uuid,
+        patchKeys: Object.keys(input).filter(k => k !== 'uuid' && k !== 'projectUuid'),
+        projectUuid: input.projectUuid,
+    });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        if (!projectUuid) {
+            const repoName = detectRepoName();
+            if (!repoName)
+                return notFound(input.uuid, 'no git repo detected and no projectUuid provided');
+            const project = await client.findProjectByRepoName(repoName);
+            if (!project)
+                return notFound(input.uuid, `no project found for repo "${repoName}"`);
+            projectUuid = project.uuid;
+        }
+        try {
+            const environment = await client.updateEnvironment(projectUuid, input.uuid, {
+                name: input.name,
+                url: input.url,
+                description: input.description,
+            });
+            logger.toolComplete('update_environment', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ updated: true, environment }, null, 2) }],
+            };
+        }
+        catch (err) {
+            if (err?.statusCode === 404 || err?.response?.status === 404) {
+                return notFound(input.uuid, `backend returned 404 for project ${projectUuid}`);
+            }
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('update_environment', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'update_environment');
+    }
+}

package/dist/handlers/updateProjectHandler.js

@@ -0,0 +1,45 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+const logger = new Logger({ module: 'updateProjectHandler' });
+function notFound(uuid) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({
+                    error: 'NotFound',
+                    message: `Project ${uuid} not found.`,
+                    uuid,
+                }, null, 2) }],
+        isError: true,
+    };
+}
+export async function updateProjectHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('update_project', {
+        uuid: input.uuid,
+        patchKeys: Object.keys(input).filter(k => k !== 'uuid'),
+    });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        try {
+            const project = await client.updateProject(input.uuid, {
+                name: input.name,
+                description: input.description,
+            });
+            logger.toolComplete('update_project', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ updated: true, project }, null, 2) }],
+            };
+        }
+        catch (err) {
+            if (err?.statusCode === 404 || err?.response?.status === 404)
+                return notFound(input.uuid);
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('update_project', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'update_project');
+    }
+}

package/dist/index.js

@@ -21,7 +21,6 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { config } from "./config/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";
 // Logger and server are initialized lazily in main() to avoid triggering
 // config loading at module load time. If config validation fails (bad env vars),
@@ -155,8 +154,8 @@ async function main() {
             }));
             logger.info('Telemetry enabled (PostHog)');
         }
-        // Connect transport FIRST so the MCP client handshake succeeds immediately.
-        // Tools start with no project context; enriched once the API responds.
+        // No API calls at boot. Project context is resolved lazily on first tool
+        // invocation (list_environments / list_credentials / check_app_in_browser).
         initTools(null);
         const transport = new StdioServerTransport();
         await server.connect(transport);
@@ -164,22 +163,6 @@ async function main() {
             transport: 'stdio',
             toolsAvailable: getTools().map(t => t.name),
         });
-        // Resolve project context in the background — enriches tool descriptions
-        // with available environments/credentials once the API responds.
-        resolveProjectContext().then((projectCtx) => {
-            if (projectCtx) {
-                initTools(projectCtx);
-                logger.info('Tool descriptions enriched with project context', {
-                    project: projectCtx.project.name,
-                    environments: projectCtx.environments.length,
-                    credentials: projectCtx.environments.reduce((n, e) => n + e.credentials.length, 0),
-                });
-            }
-        }).catch((err) => {
-            logger.warn('Background project context resolution failed', {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        });
     }
     catch (error) {
         logger.error('Failed to start DebuggAI MCP Server', {

package/dist/services/index.js

@@ -73,6 +73,249 @@ export class DebuggAIServerClient {
         // Fallback to first search result
         return projects[0];
     }
+    /**
+     * Simplified project shape used by get/update tools — drops heavy internal
+     * fields (team, runner_configuration, github_auth_details) that most MCP
+     * clients don't need.
+     */
+    mapProjectDetail(p) {
+        return {
+            uuid: p.uuid,
+            name: p.name,
+            slug: p.slug,
+            platform: p.platform ?? null,
+            repoName: p.repo?.name ?? null,
+            description: p.description ?? null,
+            status: p.status ?? null,
+            language: p.language ?? null,
+            framework: p.framework ?? null,
+            timestamp: p.timestamp,
+            lastMod: p.lastMod,
+        };
+    }
+    async getProject(uuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const p = await this.tx.get(`api/v1/projects/${uuid}/`);
+        return this.mapProjectDetail(p);
+    }
+    async updateProject(uuid, patch) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {};
+        if (patch.name !== undefined)
+            body.name = patch.name;
+        if (patch.description !== undefined)
+            body.description = patch.description;
+        const p = await this.tx.patch(`api/v1/projects/${uuid}/`, body);
+        return this.mapProjectDetail(p);
+    }
+    async deleteProject(uuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        await this.tx.delete(`api/v1/projects/${uuid}/`);
+    }
+    /**
+     * List projects accessible to the current API key.
+     * Optional q filters by project name / repo name server-side (backend `?search=`).
+     * Returns the first page only; pagination can be added if needed.
+     */
+    async listProjects(q) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const params = q ? { search: q } : undefined;
+        const response = await this.tx.get('api/v1/projects/', params);
+        return response?.results ?? [];
+    }
+    /**
+     * List environments for a project. Optional q filters by name via backend ?search=.
+     */
+    async listEnvironmentsForProject(projectUuid, q) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const params = q ? { search: q } : undefined;
+        const response = await this.tx.get(`api/v1/projects/${projectUuid}/environments/`, params);
+        return (response?.results ?? []).map((e) => ({
+            uuid: e.uuid,
+            name: e.name,
+            url: e.url || e.activeUrl || '',
+            isActive: e.isActive,
+        }));
+    }
+    /**
+     * Create a new environment under a project.
+     * Backend requires `name`. Other fields optional.
+     */
+    async createEnvironment(projectUuid, input) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = { name: input.name };
+        if (input.url)
+            body.url = input.url;
+        if (input.description)
+            body.description = input.description;
+        const response = await this.tx.post(`api/v1/projects/${projectUuid}/environments/`, body);
+        return {
+            uuid: response.uuid,
+            name: response.name,
+            url: response.url || response.activeUrl || '',
+            isActive: response.isActive,
+        };
+    }
+    /**
+     * Delete an environment. Used by evals to clean up throwaway test envs.
+     */
+    async deleteEnvironment(projectUuid, envUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        await this.tx.delete(`api/v1/projects/${projectUuid}/environments/${envUuid}/`);
+    }
+    /**
+     * Fetch a single environment by UUID. Throws AxiosError with status 404 if not found.
+     */
+    async getEnvironment(projectUuid, envUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const e = await this.tx.get(`api/v1/projects/${projectUuid}/environments/${envUuid}/`);
+        return {
+            uuid: e.uuid,
+            name: e.name,
+            url: e.url ?? '',
+            isActive: e.isActive,
+            description: e.description ?? null,
+            endpointType: e.endpointType,
+            activeUrl: e.activeUrl ?? null,
+            timestamp: e.timestamp,
+            lastMod: e.lastMod,
+        };
+    }
+    /**
+     * Patch an environment. Backend PATCH response omits uuid — caller should echo it.
+     */
+    async updateEnvironment(projectUuid, envUuid, patch) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {};
+        if (patch.name !== undefined)
+            body.name = patch.name;
+        if (patch.url !== undefined)
+            body.url = patch.url;
+        if (patch.description !== undefined)
+            body.description = patch.description;
+        const e = await this.tx.patch(`api/v1/projects/${projectUuid}/environments/${envUuid}/`, body);
+        return {
+            uuid: envUuid, // echo from input; backend PATCH response omits it
+            name: e.name,
+            url: e.url ?? '',
+            isActive: e.isActive,
+            description: e.description ?? null,
+            endpointType: e.endpointType,
+        };
+    }
+    /**
+     * List credentials for a specific environment. q filters label/username client-side.
+     * role filters for exact match.
+     */
+    async listCredentialsForEnvironment(projectUuid, envUuid, q, role) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const response = await this.tx.get(`api/v1/projects/${projectUuid}/environments/${envUuid}/credentials/`);
+        let creds = (response?.results ?? [])
+            .filter((c) => c.isActive)
+            .map((c) => ({
+            uuid: c.uuid,
+            label: c.label || c.username,
+            username: c.username,
+            role: c.role,
+            environmentUuid: envUuid,
+        }));
+        if (q) {
+            const needle = q.toLowerCase();
+            creds = creds.filter(c => c.label.toLowerCase().includes(needle) ||
+                c.username.toLowerCase().includes(needle));
+        }
+        if (role) {
+            creds = creds.filter(c => c.role === role);
+        }
+        return creds;
+    }
+    /**
+     * Create a credential on an environment. password is write-only — never echoed back.
+     */
+    async createCredential(projectUuid, envUuid, input) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {
+            label: input.label,
+            username: input.username,
+            password: input.password,
+        };
+        if (input.role)
+            body.role = input.role;
+        const response = await this.tx.post(`api/v1/projects/${projectUuid}/environments/${envUuid}/credentials/`, body);
+        return {
+            uuid: response.uuid,
+            label: response.label || response.username,
+            username: response.username,
+            role: response.role,
+            environmentUuid: envUuid,
+        };
+    }
+    /**
+     * Delete a credential. Used by evals to clean up throwaway test creds.
+     */
+    async deleteCredential(projectUuid, envUuid, credUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        await this.tx.delete(`api/v1/projects/${projectUuid}/environments/${envUuid}/credentials/${credUuid}/`);
+    }
+    /**
+     * Fetch a single credential by UUID. Throws AxiosError wrapper with statusCode=404 if not found.
+     * Response shape omits any password field — backend credential schema has no password field.
+     */
+    async getCredential(projectUuid, envUuid, credUuid) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const c = await this.tx.get(`api/v1/projects/${projectUuid}/environments/${envUuid}/credentials/${credUuid}/`);
+        return {
+            uuid: c.uuid,
+            label: c.label ?? c.username,
+            username: c.username,
+            role: c.role ?? null,
+            environmentUuid: envUuid,
+            environmentName: c.environmentName ?? null,
+            isActive: c.isActive,
+            isDefault: c.isDefault,
+            description: c.description ?? null,
+            timestamp: c.timestamp,
+            lastMod: c.lastMod,
+        };
+    }
+    /**
+     * Update a credential via partial PATCH. Only the specified fields change.
+     */
+    async updateCredential(projectUuid, envUuid, credUuid, patch) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        const body = {};
+        if (patch.label !== undefined)
+            body.label = patch.label;
+        if (patch.username !== undefined)
+            body.username = patch.username;
+        if (patch.password !== undefined)
+            body.password = patch.password;
+        if (patch.role !== undefined)
+            body.role = patch.role;
+        const c = await this.tx.patch(`api/v1/projects/${projectUuid}/environments/${envUuid}/credentials/${credUuid}/`, body);
+        return {
+            uuid: credUuid, // echo from input; backend PATCH response omits it
+            label: c.label,
+            username: c.username,
+            role: c.role ?? null,
+            environmentUuid: envUuid,
+            isActive: c.isActive,
+        };
+    }
     /**
      * Revoke an ngrok API key by its key ID.
      * Call this after workflow execution completes to clean up the short-lived key.