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

package/dist/handlers/searchExecutionsHandler.js

@@ -0,0 +1,71 @@
+/**
+ * search_executions handler (bead 49b)
+ *
+ * Absorbs list_executions + get_execution.
+ *
+ * Modes:
+ *   uuid: {uuid} → {filter:{uuid}, pageInfo:{totalCount:1,...}, executions:[fullDetail]}
+ *                  fullDetail includes nodeExecutions, state, errorInfo.
+ *   filter: {status?, projectUuid?, page?, pageSize?} → {filter, pageInfo, executions:[summary]}
+ */
+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 { toPaginationParams } from '../utils/pagination.js';
+const logger = new Logger({ module: 'searchExecutionsHandler' });
+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 searchExecutionsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('search_executions', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        if (input.uuid) {
+            try {
+                const execution = await client.workflows.getExecution(input.uuid);
+                const payload = {
+                    filter: { uuid: input.uuid },
+                    pageInfo: { page: 1, pageSize: 1, totalCount: 1, totalPages: 1, hasMore: false },
+                    executions: [execution],
+                };
+                logger.toolComplete('search_executions', Date.now() - start);
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+            }
+            catch (err) {
+                if (err?.statusCode === 404 || err?.response?.status === 404)
+                    return notFound(input.uuid);
+                throw err;
+            }
+        }
+        const pagination = toPaginationParams({ page: input.page, pageSize: input.pageSize });
+        const { pageInfo, executions } = await client.workflows.listExecutions({
+            status: input.status,
+            projectId: input.projectUuid,
+            page: pagination.page,
+            pageSize: pagination.pageSize,
+        });
+        const payload = {
+            filter: {
+                status: input.status ?? null,
+                projectUuid: input.projectUuid ?? null,
+            },
+            pageInfo,
+            executions,
+        };
+        logger.toolComplete('search_executions', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('search_executions', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'search_executions');
+    }
+}

package/dist/handlers/searchProjectsHandler.js

@@ -0,0 +1,72 @@
+/**
+ * search_projects handler (bead ue3)
+ *
+ * Single tool covering both uuid-lookup and filter/list modes.
+ *
+ * Modes:
+ *   uuid mode:   {uuid} → {filter:{uuid}, pageInfo:{totalCount:1,...}, projects:[fullProject]}
+ *                — NotFound surfaces as isError:true
+ *   filter mode: {q?, page?, pageSize?} → {filter:{q}, pageInfo, projects:[summaries]}
+ *
+ * Response shape is uniform ({filter, pageInfo, projects}) but `projects[0]`
+ * richness differs by mode: uuid-mode returns the full project (all backend
+ * keys), filter-mode returns a summary (uuid/name/slug/repoName).
+ */
+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 { toPaginationParams } from '../utils/pagination.js';
+const logger = new Logger({ module: 'searchProjectsHandler' });
+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 searchProjectsHandler(input, _context) {
+    const start = Date.now();
+    logger.toolStart('search_projects', input);
+    try {
+        const client = new DebuggAIServerClient(config.api.key);
+        await client.init();
+        if (input.uuid) {
+            try {
+                const project = await client.getProject(input.uuid);
+                const payload = {
+                    filter: { uuid: input.uuid },
+                    pageInfo: { page: 1, pageSize: 1, totalCount: 1, totalPages: 1, hasMore: false },
+                    projects: [project],
+                };
+                logger.toolComplete('search_projects', Date.now() - start);
+                return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+            }
+            catch (err) {
+                if (err?.statusCode === 404 || err?.response?.status === 404)
+                    return notFound(input.uuid);
+                throw err;
+            }
+        }
+        const pagination = toPaginationParams({ page: input.page, pageSize: input.pageSize });
+        const { pageInfo, projects } = await client.listProjects(pagination, input.q);
+        const payload = {
+            filter: { q: input.q ?? null },
+            pageInfo,
+            projects: projects.map((p) => ({
+                uuid: p.uuid,
+                name: p.name,
+                slug: p.slug,
+                repoName: p.repo?.name ?? null,
+            })),
+        };
+        logger.toolComplete('search_projects', Date.now() - start);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    catch (error) {
+        logger.toolError('search_projects', error, Date.now() - start);
+        throw handleExternalServiceError(error, 'DebuggAI', 'search_projects');
+    }
+}

package/dist/handlers/testPageChangesHandler.js

@@ -43,16 +43,40 @@ export async function testPageChangesHandler(input, context, progressCallback) {
         releaseSlot();
     }
 }
-async function testPageChangesHandlerInner(input, context, progressCallback) {
+async function testPageChangesHandlerInner(input, context, rawProgressCallback) {
     const startTime = Date.now();
     logger.toolStart('check_app_in_browser', input);
+    // Bead 0bq: wrap the progress callback in a circuit-breaker so a single
+    // client-side rejection of a stale progressToken (which would normally
+    // throw up the stack and abort the handler, or — worse — arrive post-response
+    // and tear down the stdio transport) is swallowed and disables further
+    // emissions in this request.
+    let progressDisabled = false;
+    const progressCallback = rawProgressCallback
+        ? async (update) => {
+            if (progressDisabled)
+                return;
+            try {
+                await rawProgressCallback(update);
+            }
+            catch (err) {
+                progressDisabled = true;
+                logger.warn('Progress emission failed; disabling further emissions for this request', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        : undefined;
     const client = new DebuggAIServerClient(config.api.key);
     await client.init();
     const originalUrl = resolveTargetUrl(input);
     let ctx = buildContext(originalUrl);
     let keyId;
     const abortController = new AbortController();
-    const onStdinClose = () => abortController.abort();
+    const onStdinClose = () => {
+        abortController.abort();
+        progressDisabled = true; // client is gone — stop emitting
+    };
     process.stdin.once('close', onStdinClose);
     // Progress budget: 3 setup steps + 25 execution steps = 28 total
     const SETUP_STEPS = 3;
@@ -168,6 +192,7 @@ async function testPageChangesHandlerInner(input, context, progressCallback) {
         const BACKEND_SETUP_END = 6;
         let lastStepsTaken = 0;
         let observedMaxSteps = MAX_EXEC_STEPS;
+        const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
         const finalExecution = await client.workflows.pollExecution(executionUuid, async (exec) => {
             // Keep the tunnel alive while the workflow is actively running
             if (ctx.tunnelId)
@@ -180,6 +205,19 @@ async function testPageChangesHandlerInner(input, context, progressCallback) {
             }
             if (!progressCallback)
                 return;
+            // Bead 0bq: emit the final "Complete:" progress INSIDE this callback
+            // when terminal status is detected. pollExecution will return on the
+            // next line (line 183 in services/workflows.ts), so there's no
+            // post-pollExecution progress emission that could race the response.
+            if (TERMINAL_STATUSES.has(exec.status)) {
+                const terminalOutcome = exec.state?.outcome ?? exec.status;
+                await progressCallback({
+                    progress: TOTAL_STEPS,
+                    total: TOTAL_STEPS,
+                    message: `Complete: ${terminalOutcome}`,
+                });
+                return;
+            }
             // --- Compute progress number ---
             let execProgress;
             let message;
@@ -308,9 +346,12 @@ async function testPageChangesHandlerInner(input, context, progressCallback) {
             responsePayload.surferOutput = sanitizeResponseUrls(surferNode.outputData, ctx);
         }
         logger.toolComplete('check_app_in_browser', duration);
-        if (progressCallback) {
-            await progressCallback({ progress: TOTAL_STEPS, total: TOTAL_STEPS, message: `Complete: ${outcome}` });
-        }
+        // NOTE (bead 0bq): the final "Complete:" progress is emitted INSIDE
+        // pollExecution's onUpdate when terminal status is detected — see the
+        // TERMINAL_STATUSES block above. Emitting it here (post-resolve) creates
+        // a race where the progress can arrive AFTER the response on the wire,
+        // making the client reject it as an unknown progressToken and close the
+        // transport, breaking ALL subsequent tool calls.
         // Sanitize the whole payload so no tunnel URL leaks anywhere — including
         // agent-authored strings in actionTrace[*].intent, evaluation.reason, etc.
         const sanitizedPayload = sanitizeResponseUrls(responsePayload, ctx);

package/dist/handlers/triggerCrawlHandler.js

@@ -17,16 +17,36 @@ import { DebuggAIServerClient } from '../services/index.js';
 import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
 const logger = new Logger({ module: 'triggerCrawlHandler' });
 const TEMPLATE_KEYWORD = 'raw crawl';
-export async function triggerCrawlHandler(input, context, progressCallback) {
+export async function triggerCrawlHandler(input, context, rawProgressCallback) {
     const startTime = Date.now();
     logger.toolStart('trigger_crawl', input);
+    // Bead 0bq: progress circuit-breaker — see testPageChangesHandler for rationale.
+    let progressDisabled = false;
+    const progressCallback = rawProgressCallback
+        ? async (update) => {
+            if (progressDisabled)
+                return;
+            try {
+                await rawProgressCallback(update);
+            }
+            catch (err) {
+                progressDisabled = true;
+                logger.warn('Progress emission failed; disabling further emissions for this request', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        : undefined;
     const client = new DebuggAIServerClient(config.api.key);
     await client.init();
     const originalUrl = resolveTargetUrl(input);
     let ctx = buildContext(originalUrl);
     let keyId;
     const abortController = new AbortController();
-    const onStdinClose = () => abortController.abort();
+    const onStdinClose = () => {
+        abortController.abort();
+        progressDisabled = true;
+    };
     process.stdin.once('close', onStdinClose);
     try {
         // --- Tunnel: reuse existing or provision a fresh one ---
@@ -93,15 +113,25 @@ export async function triggerCrawlHandler(input, context, progressCallback) {
         const executionUuid = executeResponse.executionUuid;
         logger.info(`Crawl execution queued: ${executionUuid}`);
         // --- Poll ---
+        // Bead 0bq: emit the final progress (4/4 "Complete:...") INSIDE onUpdate
+        // when terminal status detected, so there's no post-resolve emission that
+        // could race the response and cause stale-progressToken transport tear-down.
+        const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
         const finalExecution = await client.workflows.pollExecution(executionUuid, async (exec) => {
             if (ctx.tunnelId)
                 touchTunnelById(ctx.tunnelId);
             if (!progressCallback)
                 return;
             const nodeCount = (exec.nodeExecutions ?? []).length;
+            if (TERMINAL_STATUSES.has(exec.status)) {
+                await progressCallback({
+                    progress: 4, total: 4,
+                    message: `Crawl ${exec.status} (${nodeCount} nodes)`,
+                });
+                return;
+            }
             await progressCallback({
-                progress: 4,
-                total: 4,
+                progress: 4, total: 4,
                 message: `Crawl ${exec.status} (${nodeCount} nodes)`,
             });
         }, abortController.signal);
@@ -154,9 +184,9 @@ export async function triggerCrawlHandler(input, context, progressCallback) {
             };
         }
         logger.toolComplete('trigger_crawl', duration);
-        if (progressCallback) {
-            await progressCallback({ progress: 4, total: 4, message: `Crawl ${finalExecution.status}` });
-        }
+        // Bead 0bq: final progress is emitted INSIDE pollExecution's onUpdate when
+        // terminal status is detected. Emitting it here would race the response
+        // and could cause stale-progressToken transport tear-down.
         const sanitizedPayload = sanitizeResponseUrls(responsePayload, ctx);
         return {
             content: [{ type: 'text', text: JSON.stringify(sanitizedPayload, null, 2) }],

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/services/index.js

@@ -191,7 +191,7 @@ export class DebuggAIServerClient {
      * List environments for a project. Paginated.
      * Optional q filters by name via backend ?search=.
      * The bare-array variant (no pagination) is still used internally by
-     * list_credentials when iterating across all envs.
+     * search_environments when iterating across all envs to inline credentials.
      */
     async listEnvironmentsForProject(projectUuid, q) {
         if (!this.tx)
@@ -298,8 +298,8 @@ export class DebuggAIServerClient {
     /**
      * List credentials for a specific environment. Unpaginated (fetches up to
      * backend max pageSize). q filters label/username server-side via ?search=;
-     * role filters server-side. Used internally by list_credentials when
-     * iterating across envs.
+     * role filters server-side. Used internally by search_environments when
+     * inlining credentials on each env in a page.
      */
     async listCredentialsForEnvironment(projectUuid, envUuid, q, role) {
         if (!this.tx)

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/createProject.js

@@ -1,6 +1,6 @@
 import { CreateProjectInputSchema } from '../types/index.js';
 import { createProjectHandler } from '../handlers/createProjectHandler.js';
-const DESCRIPTION = `Create a new DebuggAI project. Required: name, platform (e.g. "web"), teamUuid (from list_teams), repoUuid (from list_repos). Returns {created: true, project: {uuid, name, slug, platform, repoName, ...}}. The repo must be GitHub-linked to the account. Use list_teams + list_repos first to discover valid UUIDs.`;
+const DESCRIPTION = `Create a new DebuggAI project. Required: name, platform (e.g. "web"), plus a team and a repo. Team and repo each accept EITHER a UUID or a name: pass teamUuid OR teamName, and repoUuid OR repoName. Name resolution does a backend search with case-insensitive exact match (returns AmbiguousMatch with candidates on multiple hits, NotFound on no hit). The repo must be GitHub-linked to the account. Returns {created: true, project: {uuid, name, slug, platform, repoName, ...}}.`;
 export function buildCreateProjectTool() {
     return {
         name: 'create_project',
@@ -11,10 +11,12 @@ export function buildCreateProjectTool() {
             properties: {
                 name: { type: 'string', description: 'Project name. Required.', minLength: 1 },
                 platform: { type: 'string', description: 'Platform (e.g. "web"). Required.', minLength: 1 },
-                teamUuid: { type: 'string', description: 'Team UUID (from list_teams). Required.' },
-                repoUuid: { type: 'string', description: 'GitHub repo UUID (from list_repos). Required — repo must be GitHub-linked.' },
+                teamUuid: { type: 'string', description: 'Team UUID. Provide teamUuid OR teamName, not both.' },
+                teamName: { type: 'string', description: 'Team name (backend-resolved, case-insensitive exact match). Provide teamUuid OR teamName, not both.' },
+                repoUuid: { type: 'string', description: 'GitHub repo UUID. Provide repoUuid OR repoName, not both. Repo must be GitHub-linked.' },
+                repoName: { type: 'string', description: 'GitHub repo name, e.g. "org/repo" (backend-resolved, case-insensitive exact match). Provide repoUuid OR repoName, not both.' },
             },
-            required: ['name', 'platform', 'teamUuid', 'repoUuid'],
+            required: ['name', 'platform'],
             additionalProperties: false,
         },
     };

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;