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

package/dist/handlers/updateEnvironmentHandler.js

@@ -14,11 +14,23 @@ function notFound(uuid, context) {
         isError: true,
     };
 }
+function stripPassword(c) {
+    return {
+        uuid: c.uuid,
+        label: c.label,
+        username: c.username,
+        role: c.role ?? null,
+        environmentUuid: c.environmentUuid,
+    };
+}
 export async function updateEnvironmentHandler(input, _context) {
     const start = Date.now();
     logger.toolStart('update_environment', {
         uuid: input.uuid,
-        patchKeys: Object.keys(input).filter(k => k !== 'uuid' && k !== 'projectUuid'),
+        hasEnvPatch: !!(input.name || input.url || input.description),
+        addCount: input.addCredentials?.length ?? 0,
+        updateCount: input.updateCredentials?.length ?? 0,
+        removeCount: input.removeCredentialIds?.length ?? 0,
         projectUuid: input.projectUuid,
     });
     try {
@@ -34,23 +46,90 @@ export async function updateEnvironmentHandler(input, _context) {
                 return notFound(input.uuid, `no project found for repo "${repoName}"`);
             projectUuid = project.uuid;
         }
-        try {
-            const environment = await client.updateEnvironment(projectUuid, input.uuid, {
-                name: input.name,
-                url: input.url,
-                description: input.description,
-            });
-            logger.toolComplete('update_environment', Date.now() - start);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ updated: true, environment }, null, 2) }],
-            };
+        // ── Env field patch (only if any env field is present) ──────────────────
+        const hasEnvPatch = input.name !== undefined || input.url !== undefined || input.description !== undefined;
+        let environment = null;
+        if (hasEnvPatch) {
+            try {
+                environment = await client.updateEnvironment(projectUuid, input.uuid, {
+                    name: input.name, url: input.url, description: input.description,
+                });
+            }
+            catch (err) {
+                if (err?.statusCode === 404 || err?.response?.status === 404) {
+                    return notFound(input.uuid, `backend returned 404 for project ${projectUuid}`);
+                }
+                throw err;
+            }
+        }
+        else {
+            // Echo the uuid so the response shape stays consistent. Include projectUuid
+            // for downstream tooling. Only populate `environment` if we patched.
+            environment = { uuid: input.uuid };
+        }
+        // ── Cred sub-actions (remove → update → add) ────────────────────────────
+        const warnings = [];
+        const addedCredentials = [];
+        const updatedCredentials = [];
+        const removedCredentialIds = [];
+        if (input.removeCredentialIds) {
+            for (const credUuid of input.removeCredentialIds) {
+                try {
+                    await client.deleteCredential(projectUuid, input.uuid, credUuid);
+                    removedCredentialIds.push(credUuid);
+                }
+                catch (err) {
+                    warnings.push({ op: 'remove', uuid: credUuid, error: err?.message ?? String(err) });
+                }
+            }
+        }
+        if (input.updateCredentials) {
+            for (const patch of input.updateCredentials) {
+                try {
+                    const updated = await client.updateCredential(projectUuid, input.uuid, patch.uuid, {
+                        label: patch.label,
+                        username: patch.username,
+                        password: patch.password,
+                        role: patch.role,
+                    });
+                    updatedCredentials.push(stripPassword(updated));
+                }
+                catch (err) {
+                    warnings.push({ op: 'update', uuid: patch.uuid, error: err?.message ?? String(err) });
+                }
+            }
         }
-        catch (err) {
-            if (err?.statusCode === 404 || err?.response?.status === 404) {
-                return notFound(input.uuid, `backend returned 404 for project ${projectUuid}`);
+        if (input.addCredentials) {
+            for (const seed of input.addCredentials) {
+                try {
+                    const cred = await client.createCredential(projectUuid, input.uuid, {
+                        label: seed.label,
+                        username: seed.username,
+                        password: seed.password,
+                        role: seed.role,
+                    });
+                    addedCredentials.push(stripPassword(cred));
+                }
+                catch (err) {
+                    warnings.push({ op: 'add', label: seed.label, error: err?.message ?? String(err) });
+                }
             }
-            throw err;
         }
+        // ── Build response ──────────────────────────────────────────────────────
+        const payload = {
+            updated: hasEnvPatch,
+            environment,
+        };
+        if (addedCredentials.length > 0)
+            payload.addedCredentials = addedCredentials;
+        if (updatedCredentials.length > 0)
+            payload.updatedCredentials = updatedCredentials;
+        if (removedCredentialIds.length > 0)
+            payload.removedCredentialIds = removedCredentialIds;
+        if (warnings.length > 0)
+            payload.credentialWarnings = warnings;
+        logger.toolComplete('update_environment', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
     }
     catch (error) {
         logger.toolError('update_environment', error, Date.now() - start);

package/dist/index.js

@@ -22,6 +22,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import { config } from "./config/index.js";
 import { initTools, getTools, getTool } from "./tools/index.js";
 import { Logger, validateInput, createErrorResponse, toMCPError, handleConfigurationError, Telemetry, TelemetryEvents, } from "./utils/index.js";
+import { MCPErrorCode, MCPError, } from "./types/index.js";
 // Logger and server are initialized lazily in main() to avoid triggering
 // config loading at module load time. If config validation fails (bad env vars),
 // the error is caught by main()'s try-catch instead of crashing before any
@@ -91,6 +92,16 @@ function registerHandlers() {
             requestLogger.warn(`Tool not found: ${name}`);
             throw new Error(`Unknown tool: ${name}`);
         }
+        // Deferred config validation (bead cma): if DEBUGGAI_API_KEY is missing,
+        // return a structured error MCP clients can surface in their UI — instead
+        // of letting the backend return a cryptic 401.
+        if (!config.api.key) {
+            const mcpError = new MCPError(MCPErrorCode.CONFIGURATION_ERROR, 'DEBUGGAI_API_KEY is not set. ' +
+                'Configure it in your MCP server registration (e.g. `claude mcp add debugg-ai -s user -e DEBUGGAI_API_KEY=<your-key> -- npx -y @debugg-ai/debugg-ai-mcp`). ' +
+                'Get a key at https://debugg.ai.', { missingEnvVars: ['DEBUGGAI_API_KEY'] });
+            requestLogger.warn('Tool call blocked — DEBUGGAI_API_KEY missing', { tool: name });
+            return createErrorResponse(mcpError, name);
+        }
         try {
             const validatedInput = validateInput(tool.inputSchema, args, name);
             const context = {
@@ -141,9 +152,11 @@ async function main() {
             architecture: process.arch,
             pid: process.pid
         });
-        // Validate required environment variables
+        // NOTE: DEBUGGAI_API_KEY validation is deferred to the first tool call so
+        // MCP clients see a proper initialize response + a structured tool error,
+        // rather than the subprocess dying with "Failed to reconnect" (bead cma).
         if (!config.api.key) {
-            throw new Error('Missing required environment variable: DEBUGGAI_API_KEY');
+            logger.warn('DEBUGGAI_API_KEY is not set. Server will boot but every tool call will return a ConfigurationError until the env var is configured.');
         }
         // Initialize telemetry (PostHog when key is set, Noop otherwise)
         Telemetry.setDistinctId(config.api.key);

package/dist/tools/createEnvironment.js

@@ -1,6 +1,10 @@
 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.`;
+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 search_projects).
+
+OPTIONAL credentials seed: pass \`credentials: [{label, username, password, role?}]\` to create login credentials alongside the environment in a single call. Each cred is created best-effort; failures go to \`credentialWarnings\` without blocking env creation. Passwords are write-only and NEVER returned.
+
+Returns the created environment's uuid (and the seeded credentials, if any). Reference the env uuid when running check_app_in_browser.`;
 export function buildCreateEnvironmentTool() {
     return {
         name: 'create_environment',

package/dist/tools/index.js

@@ -1,24 +1,13 @@
 import { buildTestPageChangesTool, buildValidatedTestPageChangesTool } from './testPageChanges.js';
 import { buildTriggerCrawlTool, buildValidatedTriggerCrawlTool } from './triggerCrawl.js';
-import { buildListEnvironmentsTool, buildValidatedListEnvironmentsTool } from './listEnvironments.js';
-import { buildListCredentialsTool, buildValidatedListCredentialsTool } from './listCredentials.js';
-import { buildListProjectsTool, buildValidatedListProjectsTool } from './listProjects.js';
+import { buildSearchProjectsTool, buildValidatedSearchProjectsTool } from './searchProjects.js';
+import { buildSearchEnvironmentsTool, buildValidatedSearchEnvironmentsTool } from './searchEnvironments.js';
+import { buildSearchExecutionsTool, buildValidatedSearchExecutionsTool } from './searchExecutions.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';
-import { buildListTeamsTool, buildValidatedListTeamsTool } from './listTeams.js';
-import { buildListReposTool, buildValidatedListReposTool } from './listRepos.js';
 import { buildCreateProjectTool, buildValidatedCreateProjectTool } from './createProject.js';
 let _tools = null;
 let _validatedTools = null;
@@ -30,49 +19,27 @@ export function initTools(ctx) {
     const tools = [
         buildTestPageChangesTool(ctx),
         buildTriggerCrawlTool(ctx),
-        buildListProjectsTool(),
-        buildListEnvironmentsTool(),
-        buildListCredentialsTool(),
+        buildSearchProjectsTool(),
+        buildSearchEnvironmentsTool(),
         buildCreateEnvironmentTool(),
-        buildCreateCredentialTool(),
-        buildGetEnvironmentTool(),
         buildUpdateEnvironmentTool(),
         buildDeleteEnvironmentTool(),
-        buildGetCredentialTool(),
-        buildUpdateCredentialTool(),
-        buildDeleteCredentialTool(),
-        buildGetProjectTool(),
         buildUpdateProjectTool(),
         buildDeleteProjectTool(),
-        buildListExecutionsTool(),
-        buildGetExecutionTool(),
-        buildCancelExecutionTool(),
-        buildListTeamsTool(),
-        buildListReposTool(),
+        buildSearchExecutionsTool(),
         buildCreateProjectTool(),
     ];
     const validated = [
         buildValidatedTestPageChangesTool(ctx),
         buildValidatedTriggerCrawlTool(ctx),
-        buildValidatedListProjectsTool(),
-        buildValidatedListEnvironmentsTool(),
-        buildValidatedListCredentialsTool(),
+        buildValidatedSearchProjectsTool(),
+        buildValidatedSearchEnvironmentsTool(),
         buildValidatedCreateEnvironmentTool(),
-        buildValidatedCreateCredentialTool(),
-        buildValidatedGetEnvironmentTool(),
         buildValidatedUpdateEnvironmentTool(),
         buildValidatedDeleteEnvironmentTool(),
-        buildValidatedGetCredentialTool(),
-        buildValidatedUpdateCredentialTool(),
-        buildValidatedDeleteCredentialTool(),
-        buildValidatedGetProjectTool(),
         buildValidatedUpdateProjectTool(),
         buildValidatedDeleteProjectTool(),
-        buildValidatedListExecutionsTool(),
-        buildValidatedGetExecutionTool(),
-        buildValidatedCancelExecutionTool(),
-        buildValidatedListTeamsTool(),
-        buildValidatedListReposTool(),
+        buildValidatedSearchExecutionsTool(),
         buildValidatedCreateProjectTool(),
     ];
     _tools = tools;

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,11 +1,14 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "1.0.63",
+  "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');
-    }
-}