@debugg-ai/debugg-ai-mcp 1.0.62 → 1.0.64

package/dist/tools/triggerCrawl.js

@@ -0,0 +1,99 @@
+/**
+ * Trigger Crawl Tool Definition
+ * Defines the trigger_crawl tool with proper validation.
+ * Tool description is enriched at startup with available environments/credentials.
+ */
+import { TriggerCrawlInputSchema } from '../types/index.js';
+import { triggerCrawlHandler } from '../handlers/triggerCrawlHandler.js';
+const BASE_DESCRIPTION = `Trigger a browser-agent crawl of a web app to build the project's knowledge graph. The crawl systematically explores pages, UI states, and navigation flows, then populates the backend's knowledge graph so future evaluations and tests have context about the app.
+
+LOCALHOST SUPPORT: Pass any localhost URL (e.g. http://localhost:3000) and it Just Works. A secure tunnel is automatically created so the remote browser can reach your local dev server.
+
+WHEN TO USE: after a significant new feature, a new environment, or when onboarding a project. NOT for per-change verification — use check_app_in_browser for that.
+
+SCOPE: one crawl per call against one URL. The crawl is long-running (minutes to tens of minutes depending on app size) and populates backend state asynchronously; the tool returns the execution status once the workflow completes. This does NOT return pass/fail — it returns executionId + status + outcome.`;
+export function buildTriggerCrawlDescription(ctx) {
+    if (!ctx)
+        return BASE_DESCRIPTION;
+    const envsWithCreds = ctx.environments.filter(e => e.credentials.length > 0);
+    if (envsWithCreds.length === 0) {
+        return `${BASE_DESCRIPTION}\n\nDETECTED PROJECT: "${ctx.project.name}" (repo: ${ctx.repoName}). No credentials configured — provide username/password if the app requires login to crawl authenticated areas.`;
+    }
+    const lines = [
+        `\n\nDETECTED PROJECT: "${ctx.project.name}" (repo: ${ctx.repoName})`,
+        `\nAVAILABLE ENVIRONMENTS & CREDENTIALS (pass environmentId + credentialId to crawl authenticated areas):`,
+    ];
+    for (const env of envsWithCreds) {
+        lines.push(`\n  Environment: "${env.name}" (${env.uuid})${env.url ? ` — ${env.url}` : ''}`);
+        for (const cred of env.credentials) {
+            const parts = [`    - "${cred.label}" (${cred.uuid}) — user: ${cred.username}`];
+            if (cred.role)
+                parts[0] += `, role: ${cred.role}`;
+            lines.push(parts[0]);
+        }
+    }
+    lines.push(`\nTo use: pass environmentId and credentialId from above. Or provide username/password directly.`);
+    return BASE_DESCRIPTION + lines.join('\n');
+}
+export function buildTriggerCrawlTool(ctx) {
+    return {
+        name: 'trigger_crawl',
+        title: 'Trigger App Crawl',
+        description: buildTriggerCrawlDescription(ctx),
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'URL to crawl. Can be any public URL or a localhost/local dev server URL. For localhost URLs, a secure tunnel is automatically created — just make sure your dev server is running on that port.',
+                },
+                projectUuid: {
+                    type: 'string',
+                    description: 'UUID of the project whose knowledge graph the crawl should populate. Auto-detected from the current git repo if omitted.',
+                },
+                environmentId: {
+                    type: 'string',
+                    description: 'UUID of a specific environment to use for the crawl. See available environments in the tool description above.',
+                },
+                credentialId: {
+                    type: 'string',
+                    description: 'UUID of a specific credential for authenticated crawls. See available credentials in the tool description above.',
+                },
+                credentialRole: {
+                    type: 'string',
+                    description: "Pick a credential by role (e.g. 'admin', 'guest') from the resolved environment.",
+                },
+                username: {
+                    type: 'string',
+                    description: 'A real, existing account email for the target app. Do NOT invent credentials — use one from the available credentials or ask the user.',
+                },
+                password: {
+                    type: 'string',
+                    description: 'The real password for the username above. Do NOT guess.',
+                },
+                headless: {
+                    type: 'boolean',
+                    description: 'Run the browser in headless mode. Defaults to backend configuration.',
+                },
+                timeoutSeconds: {
+                    type: 'number',
+                    description: 'Maximum wall-time the crawl may run, in seconds (1..1800). Backend enforces this per workflow execution.',
+                },
+                repoName: {
+                    type: 'string',
+                    description: "GitHub repository name (e.g. 'my-org/my-repo'). Auto-detected from the current git repo — only provide this to run against a different project.",
+                },
+            },
+            required: ['url'],
+            additionalProperties: false,
+        },
+    };
+}
+export function buildValidatedTriggerCrawlTool(ctx) {
+    const tool = buildTriggerCrawlTool(ctx);
+    return {
+        ...tool,
+        inputSchema: TriggerCrawlInputSchema,
+        handler: triggerCrawlHandler,
+    };
+}

package/dist/types/index.js

@@ -17,21 +17,62 @@ export const TestPageChangesInputSchema = z.object({
     password: z.string().optional(),
     repoName: z.string().optional(),
 });
-export const ListEnvironmentsInputSchema = z.object({
+export const TriggerCrawlInputSchema = z.object({
+    url: z.preprocess(normalizeUrl, z.string().url('Invalid URL. Pass a full URL like "http://localhost:3000" or "https://example.com". Localhost URLs are auto-tunneled to the remote browser.')),
     projectUuid: z.string().uuid().optional(),
+    environmentId: z.string().uuid().optional(),
+    credentialId: z.string().uuid().optional(),
+    credentialRole: z.string().optional(),
+    username: z.string().optional(),
+    password: z.string().optional(),
+    headless: z.boolean().optional(),
+    timeoutSeconds: z.number().int().positive().max(1800, 'timeoutSeconds cannot exceed 1800 (30 min)').optional(),
+    repoName: z.string().optional(),
+}).strict();
+// ── 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(),
@@ -39,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(),
@@ -74,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,11 +1,14 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "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"
   ],

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');
-    }
-}