@debugg-ai/debugg-ai-mcp 1.0.63 → 1.0.65

package/dist/tools/searchEnvironments.js

@@ -0,0 +1,35 @@
+import { SearchEnvironmentsInputSchema } from '../types/index.js';
+import { searchEnvironmentsHandler } from '../handlers/searchEnvironmentsHandler.js';
+const DESCRIPTION = `Search or look up environments, with credentials expanded inline per environment.
+
+Two modes:
+  - uuid mode: {"uuid": "<env-uuid>"} → single env with full detail + its credentials. NotFound if the uuid doesn't exist.
+  - filter mode: omit uuid, optionally {"q": "<keyword>", "projectUuid", "page", "pageSize"} → paginated envs, each with its credentials.
+
+Project resolution: if projectUuid is omitted, the current git repo's origin is auto-resolved to a DebuggAI project. Returns {error:"NoProjectResolved", environments:[]} if neither is available.
+
+Credentials are returned inline per env as {uuid, label, username, role}. Password is NEVER returned — the handler defensively strips it regardless of what the service layer provides.
+
+Response: {project, filter, pageInfo, environments[]} — each environment includes a credentials[] array.`;
+export function buildSearchEnvironmentsTool() {
+    return {
+        name: 'search_environments',
+        title: 'Search Environments',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'Environment UUID. Returns single env with credentials inline. Mutually exclusive with projectUuid/q filter params.' },
+                projectUuid: { type: 'string', description: 'Override the auto-detected project. Used in filter mode.' },
+                q: { type: 'string', description: 'Free-text search over environment name. Mutually exclusive with uuid.' },
+                page: { type: 'number', description: 'Page number (1-indexed).' },
+                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedSearchEnvironmentsTool() {
+    const tool = buildSearchEnvironmentsTool();
+    return { ...tool, inputSchema: SearchEnvironmentsInputSchema, handler: searchEnvironmentsHandler };
+}

package/dist/tools/searchExecutions.js

@@ -0,0 +1,31 @@
+import { SearchExecutionsInputSchema } from '../types/index.js';
+import { searchExecutionsHandler } from '../handlers/searchExecutionsHandler.js';
+const DESCRIPTION = `Search or look up workflow executions (history of check_app_in_browser, trigger_crawl, and other workflow runs).
+
+Two modes:
+  - uuid mode: {"uuid": "<execution-uuid>"} → single execution with FULL detail including nodeExecutions, state, errorInfo. NotFound if the uuid doesn't exist.
+  - filter mode: {"status": "completed"|"running"|"failed"|"cancelled", "projectUuid": "...", "page", "pageSize"} → paginated summaries.
+
+Response shape: {filter, pageInfo, executions[]}. Summary items have outcome/status/durationMs/timestamps; uuid-mode items additionally have nodeExecutions + state + errorInfo.`;
+export function buildSearchExecutionsTool() {
+    return {
+        name: 'search_executions',
+        title: 'Search Workflow Executions',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'Execution UUID. Returns single execution with full detail. Mutually exclusive with projectUuid/status filters.' },
+                projectUuid: { type: 'string', description: 'Filter by project UUID.' },
+                status: { type: 'string', description: 'Filter by status: completed | running | failed | cancelled | pending.' },
+                page: { type: 'number', description: 'Page number (1-indexed).' },
+                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedSearchExecutionsTool() {
+    const tool = buildSearchExecutionsTool();
+    return { ...tool, inputSchema: SearchExecutionsInputSchema, handler: searchExecutionsHandler };
+}

package/dist/tools/searchProjects.js

@@ -0,0 +1,30 @@
+import { SearchProjectsInputSchema } from '../types/index.js';
+import { searchProjectsHandler } from '../handlers/searchProjectsHandler.js';
+const DESCRIPTION = `Search or look up projects.
+
+Two modes:
+  - uuid mode: pass {"uuid": "<project-uuid>"} → returns that project with the curated detail view (uuid, name, slug, platform, repoName, description, status, language, framework, timestamp, lastMod), or isError:true NotFound.
+  - filter mode: omit uuid, optionally pass {"q": "<keyword>", "page": 1, "pageSize": 20} → returns a paginated list of summaries (uuid, name, slug, repoName).
+
+Response shape is always {filter, pageInfo, projects[]}. uuid mode returns exactly one project; filter mode returns summaries.`;
+export function buildSearchProjectsTool() {
+    return {
+        name: 'search_projects',
+        title: 'Search Projects',
+        description: DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'Project UUID. When provided, returns exactly that project with full detail. Mutually exclusive with q.' },
+                q: { type: 'string', description: 'Free-text search (backend-side). Mutually exclusive with uuid.' },
+                page: { type: 'number', description: 'Page number (1-indexed). Default 1.' },
+                pageSize: { type: 'number', description: 'Page size (1..200). Default 20.' },
+            },
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedSearchProjectsTool() {
+    const tool = buildSearchProjectsTool();
+    return { ...tool, inputSchema: SearchProjectsInputSchema, handler: searchProjectsHandler };
+}

package/dist/types/index.js

@@ -29,21 +29,50 @@ export const TriggerCrawlInputSchema = z.object({
     timeoutSeconds: z.number().int().positive().max(1800, 'timeoutSeconds cannot exceed 1800 (30 min)').optional(),
     repoName: z.string().optional(),
 }).strict();
-export const ListEnvironmentsInputSchema = z.object({
+// ── New consolidated search schemas (bead ddq) ─────────────────────────────
+// uuid and filter params are mutually exclusive: either look up one thing by
+// uuid, or filter the collection. Mixing them is ambiguous.
+export const SearchProjectsInputSchema = z.object({
+    uuid: z.string().uuid().optional(),
+    q: z.string().min(1).optional(),
+    page: z.number().int().min(1).optional(),
+    pageSize: z.number().int().min(1).optional(),
+}).strict().refine((v) => !(v.uuid && (v.q !== undefined)), { message: 'Cannot combine uuid with filter params (q). Pass one or the other.' });
+// projectUuid is a LOCATOR (required by the backend URL path for envs/creds), not a
+// filter — so it's compatible with uuid mode. Only q and uuid are mutually exclusive.
+export const SearchEnvironmentsInputSchema = z.object({
+    uuid: z.string().uuid().optional(),
     projectUuid: z.string().uuid().optional(),
     q: z.string().min(1).optional(),
     page: z.number().int().min(1).optional(),
     pageSize: z.number().int().min(1).optional(),
+}).strict().refine((v) => !(v.uuid && v.q !== undefined), { message: 'Cannot combine uuid with q (they are mutually exclusive — uuid mode returns one env; q filters a list).' });
+export const SearchExecutionsInputSchema = z.object({
+    uuid: z.string().uuid().optional(),
+    projectUuid: z.string().uuid().optional(),
+    status: z.string().min(1).optional(),
+    page: z.number().int().min(1).optional(),
+    pageSize: z.number().int().min(1).optional(),
+}).strict().refine((v) => !(v.uuid && (v.projectUuid || v.status)), { message: 'Cannot combine uuid with filter params (projectUuid, status).' });
+const CredentialSeedSchema = z.object({
+    label: z.string().min(1, 'label is required'),
+    username: z.string().min(1, 'username is required'),
+    password: z.string().min(1, 'password is required'),
+    role: z.string().min(1).optional(),
 }).strict();
 export const CreateEnvironmentInputSchema = z.object({
     name: z.string().min(1, 'name is required'),
     url: z.string().url('url is required for standard environments'),
     description: z.string().optional(),
     projectUuid: z.string().uuid().optional(),
+    credentials: z.array(CredentialSeedSchema).optional(),
 }).strict();
-export const GetEnvironmentInputSchema = z.object({
+const CredentialUpdateSchema = z.object({
     uuid: z.string().uuid(),
-    projectUuid: z.string().uuid().optional(),
+    label: z.string().min(1).optional(),
+    username: z.string().min(1).optional(),
+    password: z.string().min(1).optional(),
+    role: z.string().min(1).optional(),
 }).strict();
 export const UpdateEnvironmentInputSchema = z.object({
     uuid: z.string().uuid(),
@@ -51,33 +80,14 @@ export const UpdateEnvironmentInputSchema = z.object({
     url: z.string().url().optional(),
     description: z.string().optional(),
     projectUuid: z.string().uuid().optional(),
+    addCredentials: z.array(CredentialSeedSchema).optional(),
+    updateCredentials: z.array(CredentialUpdateSchema).optional(),
+    removeCredentialIds: z.array(z.string().uuid()).optional(),
 }).strict();
 export const DeleteEnvironmentInputSchema = z.object({
     uuid: z.string().uuid(),
     projectUuid: z.string().uuid().optional(),
 }).strict();
-export const GetCredentialInputSchema = z.object({
-    uuid: z.string().uuid(),
-    environmentId: z.string().uuid(),
-    projectUuid: z.string().uuid().optional(),
-}).strict();
-export const UpdateCredentialInputSchema = z.object({
-    uuid: z.string().uuid(),
-    environmentId: z.string().uuid(),
-    label: z.string().min(1).optional(),
-    username: z.string().min(1).optional(),
-    password: z.string().min(1).optional(),
-    role: z.string().min(1).optional(),
-    projectUuid: z.string().uuid().optional(),
-}).strict();
-export const DeleteCredentialInputSchema = z.object({
-    uuid: z.string().uuid(),
-    environmentId: z.string().uuid(),
-    projectUuid: z.string().uuid().optional(),
-}).strict();
-export const GetProjectInputSchema = z.object({
-    uuid: z.string().uuid(),
-}).strict();
 export const UpdateProjectInputSchema = z.object({
     uuid: z.string().uuid(),
     name: z.string().min(1).optional(),
@@ -86,55 +96,26 @@ export const UpdateProjectInputSchema = z.object({
 export const DeleteProjectInputSchema = z.object({
     uuid: z.string().uuid(),
 }).strict();
-export const ListExecutionsInputSchema = z.object({
-    status: z.string().min(1).optional(),
-    projectUuid: z.string().uuid().optional(),
-    page: z.number().int().min(1).optional(),
-    pageSize: z.number().int().min(1).optional(),
-}).strict();
-export const GetExecutionInputSchema = z.object({
-    uuid: z.string().uuid(),
-}).strict();
-export const CancelExecutionInputSchema = z.object({
-    uuid: z.string().uuid(),
-}).strict();
-export const ListCredentialsInputSchema = z.object({
-    environmentId: z.string().uuid().optional(),
-    projectUuid: z.string().uuid().optional(),
-    q: z.string().min(1).optional(),
-    role: z.string().min(1).optional(),
-    page: z.number().int().min(1).optional(),
-    pageSize: z.number().int().min(1).optional(),
-}).strict();
-export const CreateCredentialInputSchema = z.object({
-    environmentId: z.string().uuid(),
-    label: z.string().min(1, 'label is required'),
-    username: z.string().min(1, 'username is required'),
-    password: z.string().min(1, 'password is required'),
-    role: z.string().min(1).optional(),
-    projectUuid: z.string().uuid().optional(),
-}).strict();
-export const ListProjectsInputSchema = z.object({
-    q: z.string().min(1).optional(),
-    page: z.number().int().min(1).optional(),
-    pageSize: z.number().int().min(1).optional(),
-}).strict();
-export const ListTeamsInputSchema = z.object({
-    q: z.string().min(1).optional(),
-    page: z.number().int().min(1).optional(),
-    pageSize: z.number().int().min(1).optional(),
-}).strict();
-export const ListReposInputSchema = z.object({
-    q: z.string().min(1).optional(),
-    page: z.number().int().min(1).optional(),
-    pageSize: z.number().int().min(1).optional(),
-}).strict();
 export const CreateProjectInputSchema = z.object({
     name: z.string().min(1),
     platform: z.string().min(1),
-    teamUuid: z.string().uuid(),
-    repoUuid: z.string().uuid(),
-}).strict();
+    teamUuid: z.string().uuid().optional(),
+    teamName: z.string().min(1).optional(),
+    repoUuid: z.string().uuid().optional(),
+    repoName: z.string().min(1).optional(),
+}).strict()
+    .refine((v) => !(v.teamUuid && v.teamName), {
+    message: 'Provide teamUuid OR teamName, not both.',
+})
+    .refine((v) => !(v.repoUuid && v.repoName), {
+    message: 'Provide repoUuid OR repoName, not both.',
+})
+    .refine((v) => v.teamUuid || v.teamName, {
+    message: 'Must provide teamUuid or teamName.',
+})
+    .refine((v) => v.repoUuid || v.repoName, {
+    message: 'Must provide repoUuid or repoName.',
+});
 /**
  * Error types
  */

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "1.0.63",
+  "version": "1.0.65",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {
     "debugg-ai-mcp": "dist/index.js"
   },
+  "engines": {
+    "node": ">=20.20.0"
+  },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "lint": "eslint .",

package/dist/handlers/cancelExecutionHandler.js

@@ -1,41 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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/deleteCredentialHandler.js

@@ -1,51 +0,0 @@
-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/getCredentialHandler.js

@@ -1,49 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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');
-    }
-}