@debugg-ai/debugg-ai-mcp 1.0.55 → 1.0.57

package/dist/services/projectContext.js

@@ -9,41 +9,53 @@ import { detectRepoName } from '../utils/gitContext.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger({ module: 'projectContext' });
 let cached = null;
-let initialized = false;
+let inFlight = null;
 /**
  * Resolve the current project context: repo → project → environments → credentials.
- * Safe to call multiple times — caches after first successful resolution.
+ *
+ * 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.
  */
-const STARTUP_TIMEOUT_MS = 10_000; // hard cap so we never block MCP connection
+const STARTUP_TIMEOUT_MS = 10_000;
 export async function resolveProjectContext() {
-    if (initialized)
+    if (cached)
         return cached;
-    initialized = true;
-    const repoName = detectRepoName();
-    if (!repoName) {
-        logger.info('No git repo detected — skipping project context');
-        return null;
-    }
-    try {
-        // Race against a timeout so a slow/unreachable backend never blocks startup.
-        // Cancel the timer when the inner promise settles to prevent leaked callbacks.
-        let timer;
-        const result = await Promise.race([
-            resolveProjectContextInner(repoName),
-            new Promise((resolve) => {
-                timer = setTimeout(() => {
-                    logger.warn('Project context resolution timed out — continuing without it');
-                    resolve(null);
-                }, STARTUP_TIMEOUT_MS);
-            }),
-        ]);
-        clearTimeout(timer);
-        return result;
-    }
-    catch (err) {
-        logger.warn(`Failed to resolve project context: ${err}`);
-        return null;
-    }
+    if (inFlight)
+        return inFlight;
+    inFlight = (async () => {
+        const repoName = detectRepoName();
+        if (!repoName) {
+            logger.info('No git repo detected — skipping project context');
+            return null;
+        }
+        let timer = null;
+        try {
+            const result = await Promise.race([
+                resolveProjectContextInner(repoName),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => {
+                        logger.warn('Project context resolution timed out');
+                        resolve(null);
+                    }, STARTUP_TIMEOUT_MS);
+                }),
+            ]);
+            if (result)
+                cached = result;
+            return result;
+        }
+        catch (err) {
+            logger.warn(`Failed to resolve project context: ${err}`);
+            return null;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    })().finally(() => {
+        inFlight = null;
+    });
+    return inFlight;
 }
 async function resolveProjectContextInner(repoName) {
     try {

package/dist/services/workflows.js

@@ -47,6 +47,32 @@ export const createWorkflowsService = (tx) => {
             }
             return response;
         },
+        async listExecutions(filters) {
+            const params = {};
+            if (filters.status)
+                params.status = filters.status;
+            if (filters.limit)
+                params.pageSize = filters.limit; // backend uses page_size (snake_case via transport)
+            const response = await tx.get('api/v1/workflows/executions/', params);
+            return {
+                count: response?.count ?? 0,
+                executions: (response?.results ?? []).map((e) => ({
+                    uuid: e.uuid,
+                    workflow: e.workflow,
+                    status: e.status,
+                    mode: e.mode,
+                    source: e.source,
+                    outcome: e.outcome ?? null,
+                    startedAt: e.startedAt,
+                    completedAt: e.completedAt,
+                    durationMs: e.durationMs,
+                    timestamp: e.timestamp,
+                })),
+            };
+        },
+        async cancelExecution(executionUuid) {
+            await tx.post(`api/v1/workflows/executions/${executionUuid}/cancel/`, {});
+        },
         async pollExecution(executionUuid, onUpdate, signal) {
             const deadline = Date.now() + EXECUTION_TIMEOUT_MS;
             const pollStart = Date.now();

package/dist/tools/cancelExecution.js

@@ -0,0 +1,22 @@
+import { CancelExecutionInputSchema } from '../types/index.js';
+import { cancelExecutionHandler } from '../handlers/cancelExecutionHandler.js';
+const DESCRIPTION = `Cancel an in-flight workflow execution by UUID. Returns {cancelled:true, uuid} on success. Returns isError:true + AlreadyCompleted when the execution is already done (backend 409). Returns isError:true + NotFound when uuid doesn't exist.`;
+export function buildCancelExecutionTool() {
+    return {
+        name: 'cancel_execution',
+        title: 'Cancel Workflow Execution',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'Execution UUID. Required.' },
+            },
+            required: ['uuid'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedCancelExecutionTool() {
+    const tool = buildCancelExecutionTool();
+    return { ...tool, inputSchema: CancelExecutionInputSchema, handler: cancelExecutionHandler };
+}

package/dist/tools/createCredential.js

@@ -0,0 +1,52 @@
+import { CreateCredentialInputSchema } from '../types/index.js';
+import { createCredentialHandler } from '../handlers/createCredentialHandler.js';
+const DESCRIPTION = `Create a new credential under an environment. Required: environmentId, label, username, password. Optional role (e.g. "admin", "guest"). password is write-only — the response returns only uuid/label/username/role/environmentUuid, never the raw password. Defaults to the project resolved from the current git repo; pass projectUuid to target a different project (get UUIDs via list_projects). Returns the created credential's uuid for use with check_app_in_browser via credentialId.`;
+export function buildCreateCredentialTool() {
+    return {
+        name: 'create_credential',
+        title: 'Create Environment Credential',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                environmentId: {
+                    type: 'string',
+                    description: 'UUID of the environment this credential belongs to. Required.',
+                },
+                label: {
+                    type: 'string',
+                    description: 'Human-readable label for the credential (e.g. "Admin Account"). Required.',
+                    minLength: 1,
+                },
+                username: {
+                    type: 'string',
+                    description: 'Username or email used to log in. Required.',
+                    minLength: 1,
+                },
+                password: {
+                    type: 'string',
+                    description: 'Password. Write-only — never echoed in any MCP tool response. Required.',
+                    minLength: 1,
+                },
+                role: {
+                    type: 'string',
+                    description: 'Optional: role string (e.g. "admin", "guest"). Persists on the credential and can be used with credentialRole resolution.',
+                },
+                projectUuid: {
+                    type: 'string',
+                    description: 'Optional: UUID of the target project. Defaults to the project resolved from the current git repo.',
+                },
+            },
+            required: ['environmentId', 'label', 'username', 'password'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedCreateCredentialTool() {
+    const tool = buildCreateCredentialTool();
+    return {
+        ...tool,
+        inputSchema: CreateCredentialInputSchema,
+        handler: createCredentialHandler,
+    };
+}

package/dist/tools/createEnvironment.js

@@ -0,0 +1,42 @@
+import { CreateEnvironmentInputSchema } from '../types/index.js';
+import { createEnvironmentHandler } from '../handlers/createEnvironmentHandler.js';
+const DESCRIPTION = `Create a new environment under a DebuggAI project. Both name and url are required (backend rejects standard environments without a URL). Optional description. Defaults to the project resolved from the current git repo; pass projectUuid to target a different project (get UUIDs via list_projects). Returns the created environment's uuid so you can reference it when running check_app_in_browser or creating credentials.`;
+export function buildCreateEnvironmentTool() {
+    return {
+        name: 'create_environment',
+        title: 'Create Project Environment',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Short label for the environment (e.g. "staging", "production"). Required.',
+                    minLength: 1,
+                },
+                url: {
+                    type: 'string',
+                    description: 'Base URL for the environment (e.g. https://staging.example.com). Required.',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional: free-text description.',
+                },
+                projectUuid: {
+                    type: 'string',
+                    description: 'Optional: UUID of the target project. Defaults to the project resolved from the current git repo.',
+                },
+            },
+            required: ['name', 'url'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedCreateEnvironmentTool() {
+    const tool = buildCreateEnvironmentTool();
+    return {
+        ...tool,
+        inputSchema: CreateEnvironmentInputSchema,
+        handler: createEnvironmentHandler,
+    };
+}

package/dist/tools/deleteCredential.js

@@ -0,0 +1,24 @@
+import { DeleteCredentialInputSchema } from '../types/index.js';
+import { deleteCredentialHandler } from '../handlers/deleteCredentialHandler.js';
+const DESCRIPTION = `Delete a credential by UUID. Returns {deleted:true, uuid}. Requires environmentId. Destructive — the credential is gone. Returns isError:true + NotFound when already deleted or uuid doesn't exist.`;
+export function buildDeleteCredentialTool() {
+    return {
+        name: 'delete_credential',
+        title: 'Delete Credential',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the credential. Required.' },
+                environmentId: { type: 'string', description: 'UUID of the environment the cred belongs to. Required.' },
+                projectUuid: { type: 'string', description: 'Optional: project UUID. Defaults to git-auto-detect.' },
+            },
+            required: ['uuid', 'environmentId'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedDeleteCredentialTool() {
+    const tool = buildDeleteCredentialTool();
+    return { ...tool, inputSchema: DeleteCredentialInputSchema, handler: deleteCredentialHandler };
+}

package/dist/tools/deleteEnvironment.js

@@ -0,0 +1,23 @@
+import { DeleteEnvironmentInputSchema } from '../types/index.js';
+import { deleteEnvironmentHandler } from '../handlers/deleteEnvironmentHandler.js';
+const DESCRIPTION = `Delete an environment by UUID. Returns {deleted: true, uuid}. Destructive — cascades per backend behavior (credentials under the env are typically removed). Defaults to the project resolved from the current git repo; pass projectUuid to target a different project. Returns isError:true with NotFound when the uuid doesn't exist or was already deleted.`;
+export function buildDeleteEnvironmentTool() {
+    return {
+        name: 'delete_environment',
+        title: 'Delete Environment',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the environment to delete. Required.' },
+                projectUuid: { type: 'string', description: 'Optional: UUID of the target project. Defaults to git-auto-detect.' },
+            },
+            required: ['uuid'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedDeleteEnvironmentTool() {
+    const tool = buildDeleteEnvironmentTool();
+    return { ...tool, inputSchema: DeleteEnvironmentInputSchema, handler: deleteEnvironmentHandler };
+}

package/dist/tools/deleteProject.js

@@ -0,0 +1,22 @@
+import { DeleteProjectInputSchema } from '../types/index.js';
+import { deleteProjectHandler } from '../handlers/deleteProjectHandler.js';
+const DESCRIPTION = `Delete a project by UUID. Returns {deleted:true, uuid}. **DESTRUCTIVE** — removes the project and its associated environments, credentials, and test history. No undo. Returns isError:true + NotFound when already deleted or uuid doesn't exist.`;
+export function buildDeleteProjectTool() {
+    return {
+        name: 'delete_project',
+        title: 'Delete Project',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the project to delete. Required.' },
+            },
+            required: ['uuid'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedDeleteProjectTool() {
+    const tool = buildDeleteProjectTool();
+    return { ...tool, inputSchema: DeleteProjectInputSchema, handler: deleteProjectHandler };
+}

package/dist/tools/getCredential.js

@@ -0,0 +1,24 @@
+import { GetCredentialInputSchema } from '../types/index.js';
+import { getCredentialHandler } from '../handlers/getCredentialHandler.js';
+const DESCRIPTION = `Fetch a single credential by UUID. Returns {credential:{uuid,label,username,role,environmentUuid,environmentName,isActive,isDefault,description,timestamp,lastMod}}. Never returns the password. Requires environmentId. Returns isError:true + NotFound when the uuid doesn't exist.`;
+export function buildGetCredentialTool() {
+    return {
+        name: 'get_credential',
+        title: 'Get Credential by UUID',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the credential. Required.' },
+                environmentId: { type: 'string', description: 'UUID of the environment the cred belongs to. Required.' },
+                projectUuid: { type: 'string', description: 'Optional: project UUID. Defaults to git-auto-detect.' },
+            },
+            required: ['uuid', 'environmentId'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedGetCredentialTool() {
+    const tool = buildGetCredentialTool();
+    return { ...tool, inputSchema: GetCredentialInputSchema, handler: getCredentialHandler };
+}

package/dist/tools/getEnvironment.js

@@ -0,0 +1,23 @@
+import { GetEnvironmentInputSchema } from '../types/index.js';
+import { getEnvironmentHandler } from '../handlers/getEnvironmentHandler.js';
+const DESCRIPTION = `Fetch a single environment by UUID. Returns full detail (uuid, name, url, isActive, description, endpointType, activeUrl, timestamp, lastMod). Defaults to the project resolved from the current git repo; pass projectUuid to target a different project. Returns isError:true with NotFound when the uuid doesn't exist.`;
+export function buildGetEnvironmentTool() {
+    return {
+        name: 'get_environment',
+        title: 'Get Environment by UUID',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the environment to fetch. Required.' },
+                projectUuid: { type: 'string', description: 'Optional: UUID of the target project. Defaults to git-auto-detect.' },
+            },
+            required: ['uuid'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedGetEnvironmentTool() {
+    const tool = buildGetEnvironmentTool();
+    return { ...tool, inputSchema: GetEnvironmentInputSchema, handler: getEnvironmentHandler };
+}

package/dist/tools/getExecution.js

@@ -0,0 +1,22 @@
+import { GetExecutionInputSchema } from '../types/index.js';
+import { getExecutionHandler } from '../handlers/getExecutionHandler.js';
+const DESCRIPTION = `Fetch full detail for a single workflow execution. Returns {execution:{uuid,status,state,outcome,startedAt,completedAt,durationMs,nodeExecutions,executionSummary,errorInfo,contextData,...}}. Returns isError:true + NotFound when uuid doesn't exist.`;
+export function buildGetExecutionTool() {
+    return {
+        name: 'get_execution',
+        title: 'Get Execution Detail',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'Execution UUID. Required.' },
+            },
+            required: ['uuid'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedGetExecutionTool() {
+    const tool = buildGetExecutionTool();
+    return { ...tool, inputSchema: GetExecutionInputSchema, handler: getExecutionHandler };
+}

package/dist/tools/getProject.js

@@ -0,0 +1,22 @@
+import { GetProjectInputSchema } from '../types/index.js';
+import { getProjectHandler } from '../handlers/getProjectHandler.js';
+const DESCRIPTION = `Fetch a single project by UUID. Returns {project:{uuid,name,slug,platform,repoName,description,status,language,framework,timestamp,lastMod}}. Response is simplified — heavy internal fields (team, runner_configuration, github internals) are omitted. Returns isError:true + NotFound when uuid doesn't exist.`;
+export function buildGetProjectTool() {
+    return {
+        name: 'get_project',
+        title: 'Get Project by UUID',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the project. Required.' },
+            },
+            required: ['uuid'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedGetProjectTool() {
+    const tool = buildGetProjectTool();
+    return { ...tool, inputSchema: GetProjectInputSchema, handler: getProjectHandler };
+}

package/dist/tools/index.js

@@ -1,4 +1,21 @@
 import { buildTestPageChangesTool, buildValidatedTestPageChangesTool } from './testPageChanges.js';
+import { buildListEnvironmentsTool, buildValidatedListEnvironmentsTool } from './listEnvironments.js';
+import { buildListCredentialsTool, buildValidatedListCredentialsTool } from './listCredentials.js';
+import { buildListProjectsTool, buildValidatedListProjectsTool } from './listProjects.js';
+import { buildCreateEnvironmentTool, buildValidatedCreateEnvironmentTool } from './createEnvironment.js';
+import { buildCreateCredentialTool, buildValidatedCreateCredentialTool } from './createCredential.js';
+import { buildGetEnvironmentTool, buildValidatedGetEnvironmentTool } from './getEnvironment.js';
+import { buildUpdateEnvironmentTool, buildValidatedUpdateEnvironmentTool } from './updateEnvironment.js';
+import { buildDeleteEnvironmentTool, buildValidatedDeleteEnvironmentTool } from './deleteEnvironment.js';
+import { buildGetCredentialTool, buildValidatedGetCredentialTool } from './getCredential.js';
+import { buildUpdateCredentialTool, buildValidatedUpdateCredentialTool } from './updateCredential.js';
+import { buildDeleteCredentialTool, buildValidatedDeleteCredentialTool } from './deleteCredential.js';
+import { buildGetProjectTool, buildValidatedGetProjectTool } from './getProject.js';
+import { buildUpdateProjectTool, buildValidatedUpdateProjectTool } from './updateProject.js';
+import { buildDeleteProjectTool, buildValidatedDeleteProjectTool } from './deleteProject.js';
+import { buildListExecutionsTool, buildValidatedListExecutionsTool } from './listExecutions.js';
+import { buildGetExecutionTool, buildValidatedGetExecutionTool } from './getExecution.js';
+import { buildCancelExecutionTool, buildValidatedCancelExecutionTool } from './cancelExecution.js';
 let _tools = null;
 let _validatedTools = null;
 const toolRegistry = new Map();
@@ -6,12 +23,51 @@ 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];
+    const tools = [
+        buildTestPageChangesTool(ctx),
+        buildListProjectsTool(),
+        buildListEnvironmentsTool(),
+        buildListCredentialsTool(),
+        buildCreateEnvironmentTool(),
+        buildCreateCredentialTool(),
+        buildGetEnvironmentTool(),
+        buildUpdateEnvironmentTool(),
+        buildDeleteEnvironmentTool(),
+        buildGetCredentialTool(),
+        buildUpdateCredentialTool(),
+        buildDeleteCredentialTool(),
+        buildGetProjectTool(),
+        buildUpdateProjectTool(),
+        buildDeleteProjectTool(),
+        buildListExecutionsTool(),
+        buildGetExecutionTool(),
+        buildCancelExecutionTool(),
+    ];
+    const validated = [
+        buildValidatedTestPageChangesTool(ctx),
+        buildValidatedListProjectsTool(),
+        buildValidatedListEnvironmentsTool(),
+        buildValidatedListCredentialsTool(),
+        buildValidatedCreateEnvironmentTool(),
+        buildValidatedCreateCredentialTool(),
+        buildValidatedGetEnvironmentTool(),
+        buildValidatedUpdateEnvironmentTool(),
+        buildValidatedDeleteEnvironmentTool(),
+        buildValidatedGetCredentialTool(),
+        buildValidatedUpdateCredentialTool(),
+        buildValidatedDeleteCredentialTool(),
+        buildValidatedGetProjectTool(),
+        buildValidatedUpdateProjectTool(),
+        buildValidatedDeleteProjectTool(),
+        buildValidatedListExecutionsTool(),
+        buildValidatedGetExecutionTool(),
+        buildValidatedCancelExecutionTool(),
+    ];
+    _tools = tools;
+    _validatedTools = validated;
     toolRegistry.clear();
-    toolRegistry.set(validated.name, validated);
+    for (const v of validated)
+        toolRegistry.set(v.name, v);
 }
 export function getTools() {
     if (!_tools)

package/dist/tools/listCredentials.js

@@ -0,0 +1,40 @@
+import { ListCredentialsInputSchema } from '../types/index.js';
+import { listCredentialsHandler } from '../handlers/listCredentialsHandler.js';
+const DESCRIPTION = `List credentials for a DebuggAI project. By default targets the project resolved from the current git repo. Optional environmentId filters to a single environment. Optional q filters by label or username. Optional role filters for exact match (server-side). Optional projectUuid overrides the auto-detected project. Never returns passwords or secret values.`;
+export function buildListCredentialsTool() {
+    return {
+        name: 'list_credentials',
+        title: 'List Project Credentials',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                environmentId: {
+                    type: 'string',
+                    description: 'Optional: filter credentials to a single environment UUID.',
+                },
+                projectUuid: {
+                    type: 'string',
+                    description: 'Optional: UUID of the target project. Defaults to the project resolved from the current git repo.',
+                },
+                q: {
+                    type: 'string',
+                    description: 'Optional: filter by label or username (case-insensitive substring).',
+                },
+                role: {
+                    type: 'string',
+                    description: 'Optional: filter by exact role match (e.g. "admin", "guest").',
+                },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedListCredentialsTool() {
+    const tool = buildListCredentialsTool();
+    return {
+        ...tool,
+        inputSchema: ListCredentialsInputSchema,
+        handler: listCredentialsHandler,
+    };
+}

package/dist/tools/listEnvironments.js

@@ -0,0 +1,32 @@
+import { ListEnvironmentsInputSchema } from '../types/index.js';
+import { listEnvironmentsHandler } from '../handlers/listEnvironmentsHandler.js';
+const DESCRIPTION = `List environments for a DebuggAI project. By default targets the project resolved from the current git repo; pass projectUuid to target a different project (get UUIDs via list_projects). Optional q filters by environment name via the backend search. Returns each environment's uuid, name, url, and isActive flag.`;
+export function buildListEnvironmentsTool() {
+    return {
+        name: 'list_environments',
+        title: 'List Project Environments',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectUuid: {
+                    type: 'string',
+                    description: 'Optional: UUID of the project to query. Defaults to the project resolved from the current git repo.',
+                },
+                q: {
+                    type: 'string',
+                    description: 'Optional: filter environments by name (server-side search).',
+                },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedListEnvironmentsTool() {
+    const tool = buildListEnvironmentsTool();
+    return {
+        ...tool,
+        inputSchema: ListEnvironmentsInputSchema,
+        handler: listEnvironmentsHandler,
+    };
+}

package/dist/tools/listExecutions.js

@@ -0,0 +1,22 @@
+import { ListExecutionsInputSchema } from '../types/index.js';
+import { listExecutionsHandler } from '../handlers/listExecutionsHandler.js';
+const DESCRIPTION = `List workflow execution history. Optional status filter (e.g. "completed", "running", "failed", "cancelled") passed to backend ?status=. Optional limit caps the page size (default 10). Returns {count, executions:[{uuid,workflow,status,mode,source,outcome,startedAt,completedAt,durationMs,timestamp}]} — summary shape only. Use get_execution for full detail on a single uuid.`;
+export function buildListExecutionsTool() {
+    return {
+        name: 'list_executions',
+        title: 'List Workflow Executions',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', description: 'Optional: filter by execution status.' },
+                limit: { type: 'number', description: 'Optional: page size cap.', minimum: 1, maximum: 200 },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedListExecutionsTool() {
+    const tool = buildListExecutionsTool();
+    return { ...tool, inputSchema: ListExecutionsInputSchema, handler: listExecutionsHandler };
+}

package/dist/tools/listProjects.js

@@ -0,0 +1,28 @@
+import { ListProjectsInputSchema } from '../types/index.js';
+import { listProjectsHandler } from '../handlers/listProjectsHandler.js';
+const DESCRIPTION = `List DebuggAI projects accessible to the current API key. Optional "q" input filters by project name or repo name (passed through to the backend search). Returns uuid, name, slug, and repo for each project. Use this when you don't know which project to target or when the current git repo doesn't resolve to a DebuggAI project.`;
+export function buildListProjectsTool() {
+    return {
+        name: 'list_projects',
+        title: 'List DebuggAI Projects',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                q: {
+                    type: 'string',
+                    description: 'Optional search query to filter projects by name or repo name.',
+                },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedListProjectsTool() {
+    const tool = buildListProjectsTool();
+    return {
+        ...tool,
+        inputSchema: ListProjectsInputSchema,
+        handler: listProjectsHandler,
+    };
+}

package/dist/tools/updateCredential.js

@@ -0,0 +1,28 @@
+import { UpdateCredentialInputSchema } from '../types/index.js';
+import { updateCredentialHandler } from '../handlers/updateCredentialHandler.js';
+const DESCRIPTION = `Patch a credential by UUID. Optional fields: label, username, password, role. Password is write-only — set it to rotate, but it is never returned in any response. Requires environmentId. Returns {updated:true, credential:{...}}.`;
+export function buildUpdateCredentialTool() {
+    return {
+        name: 'update_credential',
+        title: 'Update Credential',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the credential. Required.' },
+                environmentId: { type: 'string', description: 'UUID of the environment the cred belongs to. Required.' },
+                label: { type: 'string', description: 'Optional: new label.', minLength: 1 },
+                username: { type: 'string', description: 'Optional: new username.', minLength: 1 },
+                password: { type: 'string', description: 'Optional: new password (write-only — never echoed).', minLength: 1 },
+                role: { type: 'string', description: 'Optional: new role (note: backend currently drops role, see bead hpo).', minLength: 1 },
+                projectUuid: { type: 'string', description: 'Optional: project UUID. Defaults to git-auto-detect.' },
+            },
+            required: ['uuid', 'environmentId'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedUpdateCredentialTool() {
+    const tool = buildUpdateCredentialTool();
+    return { ...tool, inputSchema: UpdateCredentialInputSchema, handler: updateCredentialHandler };
+}