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

package/README.md

@@ -30,20 +30,67 @@ Or with Docker:
 docker run -i --rm --init -e DEBUGGAI_API_KEY=your_api_key quinnosha/debugg-ai-mcp
 ```
 
-## `check_app_in_browser`
+## Tools
+
+The server exposes **18** tools. The headline one is `check_app_in_browser`; the rest manage projects, environments, credentials, and workflow execution history.
+
+### `check_app_in_browser`
 
 Runs an AI browser agent against your app. The agent navigates, interacts, and reports back with screenshots.
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
 | `description` | string **required** | What to test (natural language) |
-| `url` | string | Target URL — required if `localPort` not set |
-| `localPort` | number | Local dev server port — tunnel created automatically |
+| `url` | string **required** | Target URL — a localhost URL (`http://localhost:3000`) is auto-tunneled via ngrok |
 | `environmentId` | string | UUID of a specific environment |
 | `credentialId` | string | UUID of a specific credential |
 | `credentialRole` | string | Pick a credential by role (e.g. `admin`, `guest`) |
-| `username` | string | Username for login |
-| `password` | string | Password for login |
+| `username` | string | Username for login (ephemeral — not persisted) |
+| `password` | string | Password for login (ephemeral — not persisted) |
+| `repoName` | string | Override auto-detected git repo name (e.g. `my-org/my-repo`) |
+
+### Project management
+
+| Tool | Purpose |
+|------|---------|
+| `list_projects` | List projects accessible to your API key. Optional `q` for name/repo search. |
+| `get_project` | Fetch a project by `uuid`. Simplified shape (no team/runner internals). |
+| `update_project` | PATCH a project's `name` or `description`. |
+| `delete_project` | Destructive delete. Cascades envs, creds, and history. |
+
+### Environment management (scoped to a project)
+
+| Tool | Purpose |
+|------|---------|
+| `list_environments` | List envs for a project. Optional `q`, `projectUuid`. |
+| `create_environment` | Create a new env. Requires `name` + `url`. |
+| `get_environment` | Fetch an env by `uuid`. |
+| `update_environment` | PATCH `name` / `url` / `description`. |
+| `delete_environment` | Destructive delete. |
+
+### Credential management (scoped to an environment)
+
+| Tool | Purpose |
+|------|---------|
+| `list_credentials` | List creds. Optional `environmentId`, `q`, `role` (server-side filter). **Never returns passwords.** |
+| `create_credential` | Create a cred. Requires `environmentId`, `label`, `username`, `password`; optional `role`. |
+| `get_credential` | Fetch by `uuid` + `environmentId`. |
+| `update_credential` | Partial PATCH. Pass `password` to rotate — it is never echoed back. |
+| `delete_credential` | Destructive delete. |
+
+### Workflow execution history
+
+| Tool | Purpose |
+|------|---------|
+| `list_executions` | Paginated history. Optional `status`, `limit`. |
+| `get_execution` | Full detail for a single execution including node-level state. |
+| `cancel_execution` | Cancel an in-flight execution. |
+
+### Security invariants
+
+- Passwords are write-only. They never appear in any response body from any tool.
+- Tunnel URLs (`*.ngrok.debugg.ai`) are stripped from all browser-agent responses, including agent-authored text.
+- 404s from the backend surface as `isError: true` with `{error: 'NotFound', ...}`, never as thrown exceptions.
 
 ## Configuration
 
@@ -54,9 +101,13 @@ DEBUGGAI_API_KEY=your_api_key
 ## Local Development
 
 ```bash
-npm install && npm test && npm run build
+npm install
+npm run build
+npm run test:e2e        # real end-to-end evals against the backend
 ```
 
+The eval suite spawns the built MCP server as a subprocess, exercises every tool against a real backend, and writes per-flow artifacts to `scripts/evals/artifacts/<timestamp>/`. See `scripts/evals/flows/` for the individual scenarios.
+
 ## Links
 
 [Dashboard](https://app.debugg.ai) · [Docs](https://debugg.ai/docs) · [Issues](https://github.com/debugg-ai/debugg-ai-mcp/issues) · [Discord](https://debugg.ai/discord)

package/dist/handlers/cancelExecutionHandler.js

@@ -0,0 +1,41 @@
+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: 'cancelExecutionHandler' });
+function errorResponse(error, message, uuid) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ error, message, uuid }, null, 2) }],
+        isError: true,
+    };
+}
+export async function cancelExecutionHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('cancel_execution', { uuid: input.uuid });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        try {
+            await client.workflows.cancelExecution(input.uuid);
+            logger.toolComplete('cancel_execution', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ cancelled: true, uuid: input.uuid }, null, 2) }],
+            };
+        }
+        catch (err) {
+            const status = err?.statusCode ?? err?.response?.status;
+            const detail = err?.responseData?.error ?? err?.message ?? '';
+            if (status === 404) {
+                return errorResponse('NotFound', `Execution ${input.uuid} not found.`, input.uuid);
+            }
+            if (status === 409 || /already|completed|cannot.?cancel/i.test(detail)) {
+                return errorResponse('AlreadyCompleted', detail || `Execution ${input.uuid} cannot be cancelled.`, input.uuid);
+            }
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('cancel_execution', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'cancel_execution');
+    }
+}

package/dist/handlers/createCredentialHandler.js

@@ -0,0 +1,60 @@
+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: 'createCredentialHandler' });
+export async function createCredentialHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('create_credential', {
+        environmentId: input.environmentId,
+        label: input.label,
+        hasRole: !!input.role,
+        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 {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                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.',
+                            }, null, 2) }],
+                    isError: true,
+                };
+            }
+            const project = await client.findProjectByRepoName(repoName);
+            if (!project) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                error: 'NoProjectResolved',
+                                message: `No DebuggAI project found for repo "${repoName}". Pass projectUuid explicitly.`,
+                            }, null, 2) }],
+                    isError: true,
+                };
+            }
+            projectUuid = project.uuid;
+        }
+        const cred = await client.createCredential(projectUuid, input.environmentId, {
+            label: input.label,
+            username: input.username,
+            password: input.password,
+            role: input.role,
+        });
+        const payload = {
+            created: true,
+            projectUuid,
+            credential: cred,
+        };
+        logger.toolComplete('create_credential', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('create_credential', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'create_credential');
+    }
+}

package/dist/handlers/createEnvironmentHandler.js

@@ -0,0 +1,54 @@
+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: 'createEnvironmentHandler' });
+export async function createEnvironmentHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('create_environment', {
+        name: input.name,
+        hasUrl: !!input.url,
+        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) {
+                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.',
+                };
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
+            }
+            const project = await client.findProjectByRepoName(repoName);
+            if (!project) {
+                const payload = {
+                    error: 'NoProjectResolved',
+                    message: `No DebuggAI project found for repo "${repoName}". Pass projectUuid explicitly.`,
+                };
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
+            }
+            projectUuid = project.uuid;
+        }
+        const env = await client.createEnvironment(projectUuid, {
+            name: input.name,
+            url: input.url,
+            description: input.description,
+        });
+        const payload = {
+            created: true,
+            projectUuid,
+            environment: env,
+        };
+        logger.toolComplete('create_environment', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('create_environment', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'create_environment');
+    }
+}

package/dist/handlers/deleteCredentialHandler.js

@@ -0,0 +1,51 @@
+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: 'deleteCredentialHandler' });
+function notFound(uuid, context) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({
+                    error: 'NotFound',
+                    message: `Credential ${uuid} not found (${context}).`,
+                    uuid,
+                }, null, 2) }],
+        isError: true,
+    };
+}
+export async function deleteCredentialHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('delete_credential', { uuid: input.uuid, environmentId: input.environmentId });
+    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 {
+            await client.deleteCredential(projectUuid, input.environmentId, input.uuid);
+            logger.toolComplete('delete_credential', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ deleted: true, uuid: input.uuid }, 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('delete_credential', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'delete_credential');
+    }
+}

package/dist/handlers/deleteEnvironmentHandler.js

@@ -0,0 +1,51 @@
+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: 'deleteEnvironmentHandler' });
+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 deleteEnvironmentHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('delete_environment', { uuid: input.uuid, 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 {
+            await client.deleteEnvironment(projectUuid, input.uuid);
+            logger.toolComplete('delete_environment', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ deleted: true, uuid: input.uuid }, 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('delete_environment', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'delete_environment');
+    }
+}

package/dist/handlers/deleteProjectHandler.js

@@ -0,0 +1,39 @@
+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: 'deleteProjectHandler' });
+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 deleteProjectHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('delete_project', { uuid: input.uuid });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        try {
+            await client.deleteProject(input.uuid);
+            logger.toolComplete('delete_project', Date.now() - start);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ deleted: true, uuid: input.uuid }, null, 2) }],
+            };
+        }
+        catch (err) {
+            if (err?.statusCode === 404 || err?.response?.status === 404)
+                return notFound(input.uuid);
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('delete_project', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'delete_project');
+    }
+}

package/dist/handlers/getCredentialHandler.js

@@ -0,0 +1,49 @@
+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: 'getCredentialHandler' });
+function notFound(uuid, context) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({
+                    error: 'NotFound',
+                    message: `Credential ${uuid} not found (${context}).`,
+                    uuid,
+                }, null, 2) }],
+        isError: true,
+    };
+}
+export async function getCredentialHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('get_credential', { uuid: input.uuid, environmentId: input.environmentId, 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 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.getCredential(projectUuid, input.environmentId, input.uuid);
+            logger.toolComplete('get_credential', Date.now() - start);
+            return { content: [{ type: 'text', text: JSON.stringify({ 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('get_credential', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'get_credential');
+    }
+}

package/dist/handlers/getEnvironmentHandler.js

@@ -0,0 +1,49 @@
+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: 'getEnvironmentHandler' });
+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 getEnvironmentHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('get_environment', { uuid: input.uuid, 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.getEnvironment(projectUuid, input.uuid);
+            logger.toolComplete('get_environment', Date.now() - start);
+            return { content: [{ type: 'text', text: JSON.stringify({ 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('get_environment', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'get_environment');
+    }
+}

package/dist/handlers/getExecutionHandler.js

@@ -0,0 +1,37 @@
+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: 'getExecutionHandler' });
+function notFound(uuid) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({
+                    error: 'NotFound',
+                    message: `Execution ${uuid} not found.`,
+                    uuid,
+                }, null, 2) }],
+        isError: true,
+    };
+}
+export async function getExecutionHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('get_execution', { uuid: input.uuid });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        try {
+            const execution = await client.workflows.getExecution(input.uuid);
+            logger.toolComplete('get_execution', Date.now() - start);
+            return { content: [{ type: 'text', text: JSON.stringify({ execution }, null, 2) }] };
+        }
+        catch (err) {
+            if (err?.statusCode === 404 || err?.response?.status === 404)
+                return notFound(input.uuid);
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('get_execution', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'get_execution');
+    }
+}

package/dist/handlers/getProjectHandler.js

@@ -0,0 +1,37 @@
+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: 'getProjectHandler' });
+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 getProjectHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('get_project', { uuid: input.uuid });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        try {
+            const project = await client.getProject(input.uuid);
+            logger.toolComplete('get_project', Date.now() - start);
+            return { content: [{ type: 'text', text: JSON.stringify({ project }, null, 2) }] };
+        }
+        catch (err) {
+            if (err?.statusCode === 404 || err?.response?.status === 404)
+                return notFound(input.uuid);
+            throw err;
+        }
+    }
+    catch (error) {
+        logger.toolError('get_project', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'get_project');
+    }
+}

package/dist/handlers/index.js

@@ -1 +1,18 @@
 export * from './testPageChangesHandler.js';
+export * from './listEnvironmentsHandler.js';
+export * from './listCredentialsHandler.js';
+export * from './listProjectsHandler.js';
+export * from './createEnvironmentHandler.js';
+export * from './createCredentialHandler.js';
+export * from './getEnvironmentHandler.js';
+export * from './updateEnvironmentHandler.js';
+export * from './deleteEnvironmentHandler.js';
+export * from './getCredentialHandler.js';
+export * from './updateCredentialHandler.js';
+export * from './deleteCredentialHandler.js';
+export * from './getProjectHandler.js';
+export * from './updateProjectHandler.js';
+export * from './deleteProjectHandler.js';
+export * from './listExecutionsHandler.js';
+export * from './getExecutionHandler.js';
+export * from './cancelExecutionHandler.js';

package/dist/handlers/listCredentialsHandler.js

@@ -0,0 +1,71 @@
+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: 'listCredentialsHandler' });
+export async function listCredentialsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('list_credentials', {
+        environmentId: input.environmentId,
+        projectUuid: input.projectUuid,
+        q: input.q,
+        role: input.role,
+    });
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        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.',
+                    credentials: [],
+                };
+                logger.toolComplete('list_credentials', 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.`,
+                    credentials: [],
+                };
+                logger.toolComplete('list_credentials', Date.now() - start);
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+            }
+            projectUuid = project.uuid;
+        }
+        let credentials = [];
+        if (input.environmentId) {
+            credentials = await client.listCredentialsForEnvironment(projectUuid, input.environmentId, input.q, input.role);
+        }
+        else {
+            // No environment filter — iterate all envs for the project
+            const envs = await client.listEnvironmentsForProject(projectUuid);
+            for (const env of envs) {
+                const credsForEnv = await client.listCredentialsForEnvironment(projectUuid, env.uuid, input.q, input.role);
+                credentials.push(...credsForEnv);
+            }
+        }
+        const payload = {
+            project: { uuid: projectUuid },
+            filter: {
+                environmentId: input.environmentId ?? null,
+                q: input.q ?? null,
+                role: input.role ?? null,
+            },
+            count: credentials.length,
+            credentials,
+        };
+        logger.toolComplete('list_credentials', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('list_credentials', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'list_credentials');
+    }
+}