@debugg-ai/debugg-ai-mcp 2.6.1 → 2.8.1

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added — E2E test suite management (8 new MCP tools)
+
+Eight new tools for building and managing automated E2E test suites directly via MCP:
+
+- `create_test_suite` — Create a named test suite for a project
+- `search_test_suites` — List/search suites for a project with pagination and text filter
+- `delete_test_suite` — Soft-delete (disable) a test suite
+- `create_test_case` — Create a test case assigned to a suite (no auto-run)
+- `update_test_case` — Update a test case's name, description, or agent task description
+- `delete_test_case` — Soft-delete (disable) a test case
+- `run_test_suite` — Trigger all test cases in a suite asynchronously
+- `get_test_suite_results` — Fetch suite with per-test pass/fail outcomes and run history
+
+All tools support name-based resolution (projectName, suiteName) with the same case-insensitive exact-match + ambiguity handling as existing tools. All backed by `/api/v1/test-suites/` and `/api/v1/e2e-tests/` endpoints on the DebuggAI backend. 80 new unit + integration tests added.
+
 ### Fixed — MCP now validates local reachability BEFORE hitting the backend (fixes 5-min false-pass regression)
 
 - `check_app_in_browser` and `trigger_crawl` now do a pre-flight TCP probe to `127.0.0.1:<port>` before provisioning a backend tunnel key. If the dev server isn't listening, we return a structured `LocalServerUnreachable` error in ~ms instead of letting the browser agent burn its 5-minute step budget on `ERR_NGROK_8012`. Bead `1om`.

package/dist/config/index.js

@@ -40,6 +40,10 @@ function isTelemetryDisabled() {
     const v = (process.env.DEBUGGAI_TELEMETRY_DISABLED || '').toLowerCase();
     return v === '1' || v === 'true' || v === 'yes' || v === 'on';
 }
+function isDevMode() {
+    const v = (process.env.DEBUGGAI_DEV_MODE || '').toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
 function resolvePosthogKey() {
     if (isTelemetryDisabled())
         return undefined;
@@ -50,6 +54,7 @@ const configSchema = z.object({
         name: z.string().default('DebuggAI MCP Server'),
         version: z.string(),
     }),
+    devMode: z.boolean().default(false),
     api: z.object({
         // key is validated at tool-call time (not at boot) so MCP clients can surface
         // a proper error message instead of seeing the subprocess die → "Failed to
@@ -74,11 +79,12 @@ export function loadConfig() {
             name: 'DebuggAI MCP Server',
             version: _version,
         },
+        devMode: isDevMode(),
         api: {
             // Priority: DEBUGGAI_API_TOKEN → DEBUGGAI_JWT_TOKEN → DEBUGGAI_API_KEY
             key: process.env.DEBUGGAI_API_TOKEN || process.env.DEBUGGAI_JWT_TOKEN || process.env.DEBUGGAI_API_KEY || '',
             tokenType: process.env.DEBUGGAI_TOKEN_TYPE || 'token',
-            baseUrl: process.env.DEBUGGAI_API_URL || 'https://api.debugg.ai',
+            baseUrl: process.env.DEBUGGAI_API_URL || (isDevMode() ? 'http://localhost:8012' : 'https://api.debugg.ai'),
         },
         defaults: {},
         logging: {
@@ -106,6 +112,7 @@ export function loadConfig() {
 let _config;
 export const config = {
     get server() { return getConfig().server; },
+    get devMode() { return getConfig().devMode; },
     get api() { return getConfig().api; },
     get defaults() { return getConfig().defaults; },
     get logging() { return getConfig().logging; },
@@ -117,3 +124,6 @@ function getConfig() {
     }
     return _config;
 }
+export function _resetConfigForTest() {
+    _config = undefined;
+}

package/dist/handlers/createTestCaseHandler.js

@@ -0,0 +1,46 @@
+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 { resolveProject, resolveTestSuite } from '../utils/resolveProject.js';
+const logger = new Logger({ module: 'createTestCaseHandler' });
+function errorResp(error, message, extra = {}) {
+    return { content: [{ type: 'text', text: JSON.stringify({ error, message, ...extra }, null, 2) }], isError: true };
+}
+export async function createTestCaseHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('create_test_case', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        if (!projectUuid) {
+            const resolved = await resolveProject(client, input.projectName);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            projectUuid = resolved.uuid;
+        }
+        let suiteUuid = input.suiteUuid;
+        if (!suiteUuid) {
+            const resolved = await resolveTestSuite(client, input.suiteName, projectUuid);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            suiteUuid = resolved.uuid;
+        }
+        const testCase = await client.createTestCase({
+            name: input.name,
+            description: input.description,
+            agentTaskDescription: input.agentTaskDescription,
+            suiteUuid,
+            projectUuid,
+            relativeUrl: input.relativeUrl,
+            maxSteps: input.maxSteps,
+        });
+        logger.toolComplete('create_test_case', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(testCase, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('create_test_case', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'create_test_case');
+    }
+}

package/dist/handlers/createTestSuiteHandler.js

@@ -0,0 +1,31 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { config } from '../config/index.js';
+import { resolveProject } from '../utils/resolveProject.js';
+const logger = new Logger({ module: 'createTestSuiteHandler' });
+function errorResp(error, message, extra = {}) {
+    return { content: [{ type: 'text', text: JSON.stringify({ error, message, ...extra }, null, 2) }], isError: true };
+}
+export async function createTestSuiteHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('create_test_suite', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        if (!projectUuid) {
+            const resolved = await resolveProject(client, input.projectName);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            projectUuid = resolved.uuid;
+        }
+        const suite = await client.createTestSuite({ name: input.name, description: input.description, projectUuid });
+        logger.toolComplete('create_test_suite', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(suite, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('create_test_suite', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'create_test_suite');
+    }
+}

package/dist/handlers/deleteTestCaseHandler.js

@@ -0,0 +1,20 @@
+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: 'deleteTestCaseHandler' });
+export async function deleteTestCaseHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('delete_test_case', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        await client.disableTestCase(input.testUuid);
+        logger.toolComplete('delete_test_case', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify({ deleted: true, testUuid: input.testUuid }, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('delete_test_case', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'delete_test_case');
+    }
+}

package/dist/handlers/deleteTestSuiteHandler.js

@@ -0,0 +1,38 @@
+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 { resolveProject, resolveTestSuite } from '../utils/resolveProject.js';
+const logger = new Logger({ module: 'deleteTestSuiteHandler' });
+function errorResp(error, message, extra = {}) {
+    return { content: [{ type: 'text', text: JSON.stringify({ error, message, ...extra }, null, 2) }], isError: true };
+}
+export async function deleteTestSuiteHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('delete_test_suite', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let suiteUuid = input.suiteUuid;
+        if (!suiteUuid) {
+            let projectUuid = input.projectUuid;
+            if (!projectUuid) {
+                const resolved = await resolveProject(client, input.projectName);
+                if ('error' in resolved)
+                    return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+                projectUuid = resolved.uuid;
+            }
+            const resolved = await resolveTestSuite(client, input.suiteName, projectUuid);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            suiteUuid = resolved.uuid;
+        }
+        await client.disableTestSuite(suiteUuid);
+        logger.toolComplete('delete_test_suite', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify({ deleted: true, suiteUuid }, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('delete_test_suite', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'delete_test_suite');
+    }
+}

package/dist/handlers/getTestSuiteResultsHandler.js

@@ -0,0 +1,38 @@
+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 { resolveProject, resolveTestSuite } from '../utils/resolveProject.js';
+const logger = new Logger({ module: 'getTestSuiteResultsHandler' });
+function errorResp(error, message, extra = {}) {
+    return { content: [{ type: 'text', text: JSON.stringify({ error, message, ...extra }, null, 2) }], isError: true };
+}
+export async function getTestSuiteResultsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('get_test_suite_results', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let suiteUuid = input.suiteUuid;
+        if (!suiteUuid) {
+            let projectUuid = input.projectUuid;
+            if (!projectUuid) {
+                const resolved = await resolveProject(client, input.projectName);
+                if ('error' in resolved)
+                    return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+                projectUuid = resolved.uuid;
+            }
+            const resolved = await resolveTestSuite(client, input.suiteName, projectUuid);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            suiteUuid = resolved.uuid;
+        }
+        const detail = await client.getTestSuiteDetail(suiteUuid);
+        logger.toolComplete('get_test_suite_results', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(detail, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('get_test_suite_results', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'get_test_suite_results');
+    }
+}

package/dist/handlers/index.js

@@ -11,3 +11,11 @@ export * from './deleteEnvironmentHandler.js';
 export * from './updateProjectHandler.js';
 export * from './deleteProjectHandler.js';
 export * from './createProjectHandler.js';
+export * from './createTestSuiteHandler.js';
+export * from './searchTestSuitesHandler.js';
+export * from './deleteTestSuiteHandler.js';
+export * from './createTestCaseHandler.js';
+export * from './updateTestCaseHandler.js';
+export * from './deleteTestCaseHandler.js';
+export * from './runTestSuiteHandler.js';
+export * from './getTestSuiteResultsHandler.js';

package/dist/handlers/probePageHandler.js

@@ -89,53 +89,60 @@ export async function probePageHandler(input, context, rawProgressCallback) {
                         return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                     }
                 }
-                // Reuse existing tunnel for this port if any; otherwise provision.
-                const reused = findExistingTunnel(ctx);
-                if (reused) {
-                    targetContexts.push(reused);
+                if (config.devMode) {
+                    // Dev mode: local backend can reach localhost directly — no tunnel needed.
+                    logger.info(`probe_page: dev mode — using localhost URL directly: ${ctx.originalUrl}`);
+                    targetContexts.push(ctx);
                 }
                 else {
-                    let tunnel;
-                    try {
-                        tunnel = await client.tunnels.provisionWithRetry();
+                    // Reuse existing tunnel for this port if any; otherwise provision.
+                    const reused = findExistingTunnel(ctx);
+                    if (reused) {
+                        targetContexts.push(reused);
                     }
-                    catch (provisionError) {
-                        const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
-                        const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
-                        throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
-                            `(Detail: ${msg})${diag}`);
-                    }
-                    acquiredKeyIds.push(tunnel.keyId);
-                    let tunneled;
-                    try {
-                        tunneled = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
-                    }
-                    catch (tunnelError) {
-                        const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
-                        throw new Error(`Tunnel creation failed for ${ctx.originalUrl}. (Detail: ${msg})`);
-                    }
-                    // Tunnel health probe: catch the IPv4/IPv6 bind / dead-server case
-                    // before committing to a full backend execution.
-                    if (tunneled.targetUrl) {
-                        const health = await probeTunnelHealth(tunneled.targetUrl);
-                        if (!health.healthy) {
-                            const payload = {
-                                error: 'TunnelTrafficBlocked',
-                                message: `Tunnel established but traffic isn't reaching the dev server. ${health.detail ?? ''}`,
-                                detail: {
-                                    code: health.code,
-                                    status: health.status,
-                                    ngrokErrorCode: health.ngrokErrorCode,
-                                    elapsedMs: health.elapsedMs,
-                                },
-                            };
-                            if (tunneled.tunnelId) {
-                                tunnelManager.stopTunnel(tunneled.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${tunneled.tunnelId}: ${err}`));
+                    else {
+                        let tunnel;
+                        try {
+                            tunnel = await client.tunnels.provisionWithRetry();
+                        }
+                        catch (provisionError) {
+                            const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
+                            const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
+                            throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
+                                `(Detail: ${msg})${diag}`);
+                        }
+                        acquiredKeyIds.push(tunnel.keyId);
+                        let tunneled;
+                        try {
+                            tunneled = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                        }
+                        catch (tunnelError) {
+                            const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
+                            throw new Error(`Tunnel creation failed for ${ctx.originalUrl}. (Detail: ${msg})`);
+                        }
+                        // Tunnel health probe: catch the IPv4/IPv6 bind / dead-server case
+                        // before committing to a full backend execution.
+                        if (tunneled.targetUrl) {
+                            const health = await probeTunnelHealth(tunneled.targetUrl);
+                            if (!health.healthy) {
+                                const payload = {
+                                    error: 'TunnelTrafficBlocked',
+                                    message: `Tunnel established but traffic isn't reaching the dev server. ${health.detail ?? ''}`,
+                                    detail: {
+                                        code: health.code,
+                                        status: health.status,
+                                        ngrokErrorCode: health.ngrokErrorCode,
+                                        elapsedMs: health.elapsedMs,
+                                    },
+                                };
+                                if (tunneled.tunnelId) {
+                                    tunnelManager.stopTunnel(tunneled.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${tunneled.tunnelId}: ${err}`));
+                                }
+                                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                             }
-                            return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                         }
+                        targetContexts.push(tunneled);
                     }
-                    targetContexts.push(tunneled);
                 }
             }
             else {

package/dist/handlers/runTestSuiteHandler.js

@@ -0,0 +1,122 @@
+import { Logger } from '../utils/logger.js';
+import { handleExternalServiceError } from '../utils/errors.js';
+import { DebuggAIServerClient } from '../services/index.js';
+import { TunnelProvisionError } from '../services/tunnels.js';
+import { tunnelManager } from '../services/ngrok/tunnelManager.js';
+import { probeLocalPort, probeTunnelHealth } from '../utils/localReachability.js';
+import { extractLocalhostPort } from '../utils/urlParser.js';
+import { buildContext, findExistingTunnel, ensureTunnel } from '../utils/tunnelContext.js';
+import { config } from '../config/index.js';
+import { resolveProject, resolveTestSuite } from '../utils/resolveProject.js';
+const logger = new Logger({ module: 'runTestSuiteHandler' });
+function errorResp(error, message, extra = {}) {
+    return { content: [{ type: 'text', text: JSON.stringify({ error, message, ...extra }, null, 2) }], isError: true };
+}
+export async function runTestSuiteHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('run_test_suite', input);
+    const client = new DebuggAIServerClient(config.api.key);
+    await client.init();
+    let acquiredKeyId = null;
+    let tunnelId;
+    try {
+        let suiteUuid = input.suiteUuid;
+        if (!suiteUuid) {
+            let projectUuid = input.projectUuid;
+            if (!projectUuid) {
+                const resolved = await resolveProject(client, input.projectName);
+                if ('error' in resolved)
+                    return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+                projectUuid = resolved.uuid;
+            }
+            const resolved = await resolveTestSuite(client, input.suiteName, projectUuid);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            suiteUuid = resolved.uuid;
+        }
+        // Resolve the effective target URL — tunnel if localhost, pass-through otherwise.
+        let effectiveTargetUrl = input.targetUrl;
+        if (input.targetUrl) {
+            const ctx = buildContext(input.targetUrl);
+            if (ctx.isLocalhost) {
+                const port = extractLocalhostPort(ctx.originalUrl);
+                if (typeof port === 'number') {
+                    const probe = await probeLocalPort(port);
+                    if (!probe.reachable) {
+                        return errorResp('LocalServerUnreachable', `No server listening on 127.0.0.1:${port}. Start your dev server before running the suite. (${probe.code}: ${probe.detail ?? 'no detail'})`, { port, probeCode: probe.code, elapsedMs: probe.elapsedMs });
+                    }
+                }
+                if (config.devMode) {
+                    // Dev mode: local backend can reach localhost directly — no tunnel needed.
+                    logger.info(`run_test_suite: dev mode — using localhost URL directly: ${input.targetUrl}`);
+                }
+                else {
+                    // Reuse an existing tunnel for this port if one is already active.
+                    const reused = findExistingTunnel(ctx);
+                    if (reused) {
+                        effectiveTargetUrl = reused.targetUrl ?? input.targetUrl;
+                        tunnelId = reused.tunnelId;
+                    }
+                    else {
+                        // Provision a new tunnel.
+                        let tunnel;
+                        try {
+                            tunnel = await client.tunnels.provisionWithRetry();
+                        }
+                        catch (provisionError) {
+                            const msg = provisionError instanceof Error ? provisionError.message : String(provisionError);
+                            const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
+                            return errorResp('TunnelProvisionFailed', `Failed to provision tunnel for ${input.targetUrl}. (Detail: ${msg})${diag}`);
+                        }
+                        acquiredKeyId = tunnel.keyId;
+                        let tunneled;
+                        try {
+                            tunneled = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                        }
+                        catch (tunnelError) {
+                            const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
+                            return errorResp('TunnelCreationFailed', `Tunnel creation failed for ${input.targetUrl}. (Detail: ${msg})`);
+                        }
+                        // Health probe — catches ERR_NGROK_8012 and bind mismatches before
+                        // the remote agent wastes steps trying to reach the server.
+                        if (tunneled.targetUrl) {
+                            const health = await probeTunnelHealth(tunneled.targetUrl);
+                            if (!health.healthy) {
+                                if (tunneled.tunnelId) {
+                                    tunnelManager.stopTunnel(tunneled.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${tunneled.tunnelId}: ${err}`));
+                                }
+                                return errorResp('TunnelTrafficBlocked', `Tunnel established but traffic isn't reaching the dev server. ${health.detail ?? ''}`, { code: health.code, ngrokErrorCode: health.ngrokErrorCode, elapsedMs: health.elapsedMs });
+                            }
+                        }
+                        effectiveTargetUrl = tunneled.targetUrl ?? input.targetUrl;
+                        tunnelId = tunneled.tunnelId;
+                    }
+                    logger.info(`run_test_suite: localhost detected, tunneled ${input.targetUrl} → ${effectiveTargetUrl}`);
+                }
+            }
+        }
+        const result = await client.runTestSuite(suiteUuid, { targetUrl: effectiveTargetUrl });
+        logger.toolComplete('run_test_suite', Date.now() - start);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...result,
+                        ...(tunnelId ? { tunnelActive: true, originalUrl: input.targetUrl } : {}),
+                        note: 'Tests are running asynchronously. Use get_test_suite_results to check progress.',
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        logger.toolError('run_test_suite', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'run_test_suite');
+    }
+    finally {
+        // Tunnels are NOT torn down — reuse pattern + 55-min idle auto-shutoff.
+        // Only revoke an orphaned key (acquired but tunnel creation failed).
+        if (acquiredKeyId && !tunnelId) {
+            client.revokeNgrokKey(acquiredKeyId).catch((err) => logger.warn(`Failed to revoke unused ngrok key ${acquiredKeyId}: ${err}`));
+        }
+    }
+}

package/dist/handlers/searchTestSuitesHandler.js

@@ -0,0 +1,36 @@
+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 { resolveProject } from '../utils/resolveProject.js';
+const logger = new Logger({ module: 'searchTestSuitesHandler' });
+function errorResp(error, message, extra = {}) {
+    return { content: [{ type: 'text', text: JSON.stringify({ error, message, ...extra }, null, 2) }], isError: true };
+}
+export async function searchTestSuitesHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('search_test_suites', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        let projectUuid = input.projectUuid;
+        if (!projectUuid) {
+            const resolved = await resolveProject(client, input.projectName);
+            if ('error' in resolved)
+                return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
+            projectUuid = resolved.uuid;
+        }
+        const result = await client.listTestSuites({
+            projectUuid,
+            search: input.search,
+            page: input.page,
+            pageSize: input.pageSize,
+        });
+        logger.toolComplete('search_test_suites', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('search_test_suites', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'search_test_suites');
+    }
+}