@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/mcp/tools/deploy.js

@@ -0,0 +1,797 @@
+"use strict";
+/**
+ * Deploy domain — workflow-shaped tools over scai's Deploy API surface.
+ *
+ * The library exports ~40 fetch/mutate primitives in `@/deploy/api`.
+ * Here, those primitives are recomposed into ~9 task-shaped tools that
+ * match how an agent actually reasons about an XM Cloud tenant:
+ *
+ *   - `*_inspect` tools fan out to read multiple resources in one call
+ *     and return a coherent "snapshot" structure.
+ *   - `*_manage` / `*_lifecycle` tools take a discriminated `action`
+ *     input and route to the right write primitive. The dispatcher's
+ *     allowWrite gate runs before any side-effecting library call.
+ *
+ * Never expose secret-returning library calls (edge token, editing
+ * secret, source-control access tokens). Auth flows are server-side
+ * only; agents reason about the bound env via deploy_environment_inspect.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDeployTools = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../deploy/api");
+const errors_1 = require("../../shared/errors");
+const auth_1 = require("../auth");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const paginate = (values, limit, cursor) => {
+    const start = cursor ? Number.parseInt(cursor, 10) || 0 : 0;
+    const slice = values.slice(start, start + limit);
+    const nextStart = start + slice.length;
+    return {
+        items: slice,
+        nextCursor: nextStart < values.length ? String(nextStart) : undefined,
+    };
+};
+const asArray = (value) => (Array.isArray(value) ? value : []);
+const apiOptionsFromContext = (token) => ({ accessToken: token });
+const registerDeployTools = (registry) => {
+    registry.registerTool({
+        name: "deploy_organization_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_organization_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect XM Cloud organization",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            const organization = await (0, api_1.fetchOrganization)(options);
+            const organizationId = organization.id ?? organization.organizationId;
+            const [health, license] = await Promise.all([
+                (0, api_1.fetchOrganizationHealth)(options, organizationId).catch(() => null),
+                organizationId
+                    ? (0, api_1.fetchOrganizationLicense)(options, organizationId).catch(() => null)
+                    : Promise.resolve(null),
+            ]);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Organization '${organization.name ?? organizationId ?? "(unknown)"}' resolved with health + license.`,
+                    },
+                ],
+                structuredContent: { organization, health, license },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_project_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_project_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect XM Cloud project",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            projectId: zod_1.z
+                .string()
+                .optional()
+                .describe("Project ID. When omitted, returns the full project listing."),
+            ...common_1.paginationShape,
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            if (!input.projectId) {
+                const projects = await (0, api_1.fetchProjects)(options);
+                const page = paginate(projects, input.limit, input.cursor);
+                return {
+                    content: [{ type: "text", text: `Listed ${page.items.length} project(s).` }],
+                    structuredContent: {
+                        projects: page.items,
+                        nextCursor: page.nextCursor,
+                        hasMore: page.nextCursor !== undefined,
+                    },
+                };
+            }
+            const [project, environments, limitation] = await Promise.all([
+                (0, api_1.fetchProject)(options, input.projectId),
+                (0, api_1.fetchProjectEnvironments)(options, input.projectId).catch(() => []),
+                Promise.resolve(null),
+            ]);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Project '${project.name ?? input.projectId}' with ${environments.length} environment(s).`,
+                    },
+                ],
+                structuredContent: { project, environments, limitation },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_project_manage",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_project_manage,
+        auth: "write",
+        annotations: {
+            title: "Create / update / delete project",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            action: zod_1.z.enum(["create", "update", "delete"]),
+            projectId: zod_1.z.string().optional().describe("Project ID. Required for update + delete."),
+            name: zod_1.z.string().optional().describe("Project name. Required for create."),
+            body: zod_1.z
+                .record(zod_1.z.string(), zod_1.z.unknown())
+                .optional()
+                .describe("Additional create/update fields passed through to the Deploy API."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            switch (input.action) {
+                case "create": {
+                    if (!input.name) {
+                        throw (0, errors_1.createScaiError)("`name` is required for action=create.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.createProject)(options, { name: input.name, ...(input.body ?? {}) });
+                    return {
+                        content: [{ type: "text", text: `Created project '${input.name}'.` }],
+                        structuredContent: { action: "create", result },
+                    };
+                }
+                case "update": {
+                    if (!input.projectId) {
+                        throw (0, errors_1.createScaiError)("`projectId` is required for action=update.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.updateProject)(options, input.projectId, input.body ?? {});
+                    return {
+                        content: [{ type: "text", text: `Updated project '${input.projectId}'.` }],
+                        structuredContent: { action: "update", projectId: input.projectId, result },
+                    };
+                }
+                case "delete": {
+                    if (!input.projectId) {
+                        throw (0, errors_1.createScaiError)("`projectId` is required for action=delete.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.deleteProject)(options, input.projectId);
+                    return {
+                        content: [
+                            { type: "text", text: `Deleted project '${input.projectId}' (irreversible).` },
+                        ],
+                        structuredContent: { action: "delete", projectId: input.projectId, result },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "deploy_environment_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_environment_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect XM Cloud environment",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            environmentId: zod_1.z
+                .string()
+                .optional()
+                .describe("Environment ID. When omitted, lists all environments for the bound project."),
+            projectId: zod_1.z
+                .string()
+                .optional()
+                .describe("Project filter when listing. Defaults to the bound project."),
+            ...common_1.paginationShape,
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            const env = binding.resolved.environment;
+            if (!input.environmentId) {
+                const projectId = input.projectId ?? env.projectId;
+                const environments = projectId
+                    ? asArray(await (0, api_1.fetchProjectEnvironments)(options, projectId))
+                    : asArray(await (0, api_1.fetchEnvironments)(options));
+                const page = paginate(environments, input.limit, input.cursor);
+                return {
+                    content: [{ type: "text", text: `Listed ${page.items.length} environment(s).` }],
+                    structuredContent: {
+                        environments: page.items,
+                        nextCursor: page.nextCursor,
+                        hasMore: page.nextCursor !== undefined,
+                    },
+                };
+            }
+            const environmentId = input.environmentId;
+            const [environment, variables, deployments, restartStatus] = await Promise.all([
+                (0, api_1.fetchEnvironment)(options, environmentId),
+                (0, api_1.fetchEnvironmentVariables)(options, environmentId).catch(() => []),
+                (0, api_1.fetchEnvironmentDeployments)(options, environmentId).catch(() => []),
+                (0, api_1.fetchEnvironmentRestartStatus)(options, environmentId).catch(() => null),
+            ]);
+            const host = (0, api_1.resolveHostFromEnvironment)(environment);
+            const health = host ? await (0, api_1.probeEnvironmentHealth)(host).catch(() => null) : null;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Environment '${environment.name ?? environmentId}' resolved (variables, deployments, restartStatus, health probe).`,
+                    },
+                ],
+                structuredContent: { environment, variables, deployments, restartStatus, health },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_environment_lifecycle",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_environment_lifecycle,
+        auth: "write",
+        annotations: {
+            title: "Environment lifecycle write",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            action: zod_1.z.enum(["create", "update", "delete", "restart", "promote", "regenerate-context"]),
+            environmentId: zod_1.z
+                .string()
+                .optional()
+                .describe("Environment ID. Required for update / delete / restart / promote / regenerate-context."),
+            projectId: zod_1.z.string().optional().describe("Project ID. Required for create."),
+            deploymentId: zod_1.z.string().optional().describe("Deployment ID. Required for promote."),
+            body: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().describe("Create or update payload."),
+            force: zod_1.z.boolean().optional().describe("Optional force flag for delete."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            switch (input.action) {
+                case "create": {
+                    if (!input.projectId) {
+                        throw (0, errors_1.createScaiError)("`projectId` is required for action=create.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.createProjectEnvironment)(options, input.projectId, input.body ?? {});
+                    return {
+                        content: [
+                            { type: "text", text: `Created environment under project '${input.projectId}'.` },
+                        ],
+                        structuredContent: { action: "create", projectId: input.projectId, result },
+                    };
+                }
+                case "update": {
+                    if (!input.environmentId) {
+                        throw (0, errors_1.createScaiError)("`environmentId` is required for action=update.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.updateEnvironment)(options, input.environmentId, input.body ?? {});
+                    return {
+                        content: [{ type: "text", text: `Updated environment '${input.environmentId}'.` }],
+                        structuredContent: { action: "update", environmentId: input.environmentId, result },
+                    };
+                }
+                case "delete": {
+                    if (!input.environmentId) {
+                        throw (0, errors_1.createScaiError)("`environmentId` is required for action=delete.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.deleteEnvironment)(options, input.environmentId, input.force);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Deleted environment '${input.environmentId}' (irreversible).`,
+                            },
+                        ],
+                        structuredContent: { action: "delete", environmentId: input.environmentId, result },
+                    };
+                }
+                case "restart": {
+                    if (!input.environmentId) {
+                        throw (0, errors_1.createScaiError)("`environmentId` is required for action=restart.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.restartEnvironment)(options, input.environmentId);
+                    return {
+                        content: [{ type: "text", text: `Restart requested for '${input.environmentId}'.` }],
+                        structuredContent: { action: "restart", environmentId: input.environmentId, result },
+                    };
+                }
+                case "promote": {
+                    if (!input.environmentId || !input.deploymentId) {
+                        throw (0, errors_1.createScaiError)("`environmentId` and `deploymentId` are required for action=promote.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.promoteEnvironmentDeployment)(options, input.environmentId, input.deploymentId);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Promoted deployment '${input.deploymentId}' to '${input.environmentId}'.`,
+                            },
+                        ],
+                        structuredContent: {
+                            action: "promote",
+                            environmentId: input.environmentId,
+                            deploymentId: input.deploymentId,
+                            result,
+                        },
+                    };
+                }
+                case "regenerate-context": {
+                    if (!input.environmentId) {
+                        throw (0, errors_1.createScaiError)("`environmentId` is required for action=regenerate-context.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.regenerateEnvironmentContext)(options, input.environmentId);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Regenerated context for environment '${input.environmentId}'.`,
+                            },
+                        ],
+                        structuredContent: {
+                            action: "regenerate-context",
+                            environmentId: input.environmentId,
+                            result,
+                        },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "deploy_environment_variables",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_environment_variables,
+        auth: "write",
+        annotations: {
+            title: "Upsert / delete environment variable",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            action: zod_1.z.enum(["upsert", "delete"]),
+            environmentId: zod_1.z.string(),
+            name: zod_1.z.string().describe("Variable name."),
+            value: zod_1.z.string().optional().describe("Variable value. Required for upsert."),
+            target: zod_1.z
+                .string()
+                .optional()
+                .describe("Target (e.g. cm, eh) the variable applies to. Optional; defaults to the env target."),
+            secret: zod_1.z.boolean().optional().describe("Mark as secret (true) on upsert."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            if (input.action === "upsert") {
+                if (input.value === undefined) {
+                    throw (0, errors_1.createScaiError)("`value` is required for action=upsert.", "INPUT_INVALID");
+                }
+                const body = { value: input.value };
+                if (input.target !== undefined) {
+                    body.target = input.target;
+                }
+                if (input.secret !== undefined) {
+                    body.secret = input.secret;
+                }
+                const result = await (0, api_1.upsertEnvironmentVariable)(options, input.environmentId, input.name, body);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Upserted variable '${input.name}' on '${input.environmentId}'.`,
+                        },
+                    ],
+                    structuredContent: {
+                        action: "upsert",
+                        environmentId: input.environmentId,
+                        name: input.name,
+                        result,
+                    },
+                };
+            }
+            const result = await (0, api_1.deleteEnvironmentVariable)(options, input.environmentId, input.name);
+            return {
+                content: [
+                    { type: "text", text: `Deleted variable '${input.name}' on '${input.environmentId}'.` },
+                ],
+                structuredContent: {
+                    action: "delete",
+                    environmentId: input.environmentId,
+                    name: input.name,
+                    result,
+                },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_repository_manage",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_repository_manage,
+        auth: "write",
+        annotations: {
+            title: "Link / unlink repository (project or environment)",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            scope: zod_1.z.enum(["environment", "project"]),
+            action: zod_1.z.enum(["link", "unlink"]),
+            environmentId: zod_1.z.string().optional().describe("Required when scope=environment."),
+            projectId: zod_1.z.string().optional().describe("Required when scope=project."),
+            body: zod_1.z
+                .record(zod_1.z.string(), zod_1.z.unknown())
+                .optional()
+                .describe("Repository link payload (integrationId, repository, branch, ...). Required for action=link."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            if (input.scope === "environment") {
+                if (!input.environmentId) {
+                    throw (0, errors_1.createScaiError)("`environmentId` is required for scope=environment.", "INPUT_INVALID");
+                }
+                if (input.action === "link") {
+                    if (!input.body) {
+                        throw (0, errors_1.createScaiError)("`body` is required for action=link.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.linkEnvironmentRepository)(options, input.environmentId, input.body);
+                    return {
+                        content: [{ type: "text", text: `Linked repository on '${input.environmentId}'.` }],
+                        structuredContent: {
+                            scope: "environment",
+                            action: "link",
+                            environmentId: input.environmentId,
+                            result,
+                        },
+                    };
+                }
+                const result = await (0, api_1.unlinkEnvironmentRepository)(options, input.environmentId);
+                return {
+                    content: [{ type: "text", text: `Unlinked repository on '${input.environmentId}'.` }],
+                    structuredContent: {
+                        scope: "environment",
+                        action: "unlink",
+                        environmentId: input.environmentId,
+                        result,
+                    },
+                };
+            }
+            if (!input.projectId) {
+                throw (0, errors_1.createScaiError)("`projectId` is required for scope=project.", "INPUT_INVALID");
+            }
+            if (input.action === "link") {
+                if (!input.body) {
+                    throw (0, errors_1.createScaiError)("`body` is required for action=link.", "INPUT_INVALID");
+                }
+                const result = await (0, api_1.linkProjectRepository)(options, input.projectId, input.body);
+                return {
+                    content: [{ type: "text", text: `Linked repository on project '${input.projectId}'.` }],
+                    structuredContent: {
+                        scope: "project",
+                        action: "link",
+                        projectId: input.projectId,
+                        result,
+                    },
+                };
+            }
+            const result = await (0, api_1.unlinkProjectRepository)(options, input.projectId);
+            return {
+                content: [{ type: "text", text: `Unlinked repository on project '${input.projectId}'.` }],
+                structuredContent: {
+                    scope: "project",
+                    action: "unlink",
+                    projectId: input.projectId,
+                    result,
+                },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_run_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_run_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect deployment run",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            deploymentId: zod_1.z
+                .string()
+                .optional()
+                .describe("Deployment ID. When omitted, lists recent deployments."),
+            includeLogs: zod_1.z
+                .boolean()
+                .default(false)
+                .describe("When deploymentId is given, include the deployment logs payload."),
+            ...common_1.paginationShape,
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            const env = binding.resolved.environment;
+            if (!input.deploymentId) {
+                const list = env.environmentId
+                    ? asArray(await (0, api_1.fetchEnvironmentDeployments)(options, env.environmentId))
+                    : asArray(await (0, api_1.fetchDeployments)(options));
+                const page = paginate(list, input.limit, input.cursor);
+                return {
+                    content: [{ type: "text", text: `Listed ${page.items.length} deployment(s).` }],
+                    structuredContent: {
+                        deployments: page.items,
+                        nextCursor: page.nextCursor,
+                        hasMore: page.nextCursor !== undefined,
+                    },
+                };
+            }
+            const orgId = env.organizationId;
+            const deployment = await (0, api_1.fetchDeployment)(options, input.deploymentId, orgId);
+            let logs = null;
+            if (input.includeLogs) {
+                try {
+                    logs = await (0, api_1.fetchDeploymentLogs)(input.deploymentId, binding.deployToken);
+                }
+                catch {
+                    logs = null;
+                }
+            }
+            return {
+                content: [{ type: "text", text: `Resolved deployment '${input.deploymentId}'.` }],
+                structuredContent: { deployment, logs },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_run_start",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_run_start,
+        auth: "write",
+        annotations: {
+            title: "Start a deployment run",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            environmentId: zod_1.z.string(),
+            redeploy: zod_1.z
+                .boolean()
+                .optional()
+                .describe("When true, redeploys the current source instead of starting a fresh deployment."),
+            deploymentId: zod_1.z
+                .string()
+                .optional()
+                .describe("Existing deployment to (re-)run via /api/deployments/v1/{id}/deploy instead of creating a new env deployment."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            if (input.deploymentId) {
+                const result = await (0, api_1.deployDeployment)(options, input.deploymentId, binding.resolved.environment.organizationId);
+                return {
+                    content: [{ type: "text", text: `Triggered deployment '${input.deploymentId}'.` }],
+                    structuredContent: { mode: "deploy-existing", deploymentId: input.deploymentId, result },
+                };
+            }
+            const result = await (0, api_1.createEnvironmentDeployment)(options, input.environmentId, input.redeploy);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Created${input.redeploy ? " (redeploy)" : ""} deployment for '${input.environmentId}'.`,
+                    },
+                ],
+                structuredContent: { mode: "create", environmentId: input.environmentId, result },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_run_cancel",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_run_cancel,
+        auth: "write",
+        annotations: {
+            title: "Cancel a deployment run",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            deploymentId: zod_1.z.string(),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            const result = await (0, api_1.cancelDeployment)(options, input.deploymentId, binding.resolved.environment.organizationId);
+            return {
+                content: [
+                    { type: "text", text: `Requested cancel for deployment '${input.deploymentId}'.` },
+                ],
+                structuredContent: { deploymentId: input.deploymentId, result },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "deploy_source_control_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_source_control_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect source-control surface",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            scope: zod_1.z.enum(["integrations", "providers", "repository", "templates"]),
+            integrationId: zod_1.z
+                .string()
+                .optional()
+                .describe("Integration ID. When provided alongside scope=integrations, returns the detail object instead of the listing."),
+            query: zod_1.z
+                .record(zod_1.z.string(), zod_1.z.unknown())
+                .optional()
+                .describe("Optional query bag for repository / templates scopes."),
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            const orgId = binding.resolved.environment.organizationId;
+            switch (input.scope) {
+                case "integrations": {
+                    if (input.integrationId) {
+                        const integration = await (0, api_1.fetchSourceControlIntegration)(options, input.integrationId);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Resolved source-control integration '${input.integrationId}'.`,
+                                },
+                            ],
+                            structuredContent: { scope: "integrations", integration },
+                        };
+                    }
+                    const integrations = await (0, api_1.fetchSourceControlIntegrations)(options);
+                    return {
+                        content: [{ type: "text", text: "Listed source-control integrations." }],
+                        structuredContent: { scope: "integrations", integrations },
+                    };
+                }
+                case "providers": {
+                    const providers = await (0, api_1.fetchSourceControlProviders)(options, orgId);
+                    return {
+                        content: [{ type: "text", text: "Listed source-control providers." }],
+                        structuredContent: { scope: "providers", providers },
+                    };
+                }
+                case "repository": {
+                    const repository = await (0, api_1.fetchSourceControlRepository)(options, input.query, orgId);
+                    return {
+                        content: [{ type: "text", text: "Resolved source-control repository." }],
+                        structuredContent: { scope: "repository", repository },
+                    };
+                }
+                case "templates": {
+                    const templates = await (0, api_1.fetchSourceControlTemplates)(options, input.query, orgId);
+                    return {
+                        content: [{ type: "text", text: "Listed source-control templates." }],
+                        structuredContent: { scope: "templates", templates },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "deploy_source_control_manage",
+        description: descriptions_1.TOOL_DESCRIPTIONS.deploy_source_control_manage,
+        auth: "write",
+        annotations: {
+            title: "Source-control writes",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            action: zod_1.z.enum([
+                "create-repository",
+                "create-repository-github",
+                "delete-integration",
+                "validate-repository",
+            ]),
+            integrationId: zod_1.z
+                .string()
+                .optional()
+                .describe("Integration ID. Required for delete-integration."),
+            body: zod_1.z
+                .record(zod_1.z.string(), zod_1.z.unknown())
+                .optional()
+                .describe("Payload for create / validate actions."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            const options = apiOptionsFromContext(binding.deployToken);
+            const orgId = binding.resolved.environment.organizationId;
+            switch (input.action) {
+                case "create-repository": {
+                    if (!input.body) {
+                        throw (0, errors_1.createScaiError)("`body` is required for action=create-repository.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.createSourceControlRepository)(options, input.body, orgId);
+                    return {
+                        content: [{ type: "text", text: "Created source-control repository." }],
+                        structuredContent: { action: "create-repository", result },
+                    };
+                }
+                case "create-repository-github": {
+                    if (!input.body) {
+                        throw (0, errors_1.createScaiError)("`body` is required for action=create-repository-github.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.createSourceControlRepositoryGithub)(options, input.body, orgId);
+                    return {
+                        content: [{ type: "text", text: "Created GitHub-backed source-control repository." }],
+                        structuredContent: { action: "create-repository-github", result },
+                    };
+                }
+                case "delete-integration": {
+                    if (!input.integrationId) {
+                        throw (0, errors_1.createScaiError)("`integrationId` is required for action=delete-integration.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.deleteSourceControlIntegration)(options, input.integrationId);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Deleted source-control integration '${input.integrationId}' (irreversible).`,
+                            },
+                        ],
+                        structuredContent: {
+                            action: "delete-integration",
+                            integrationId: input.integrationId,
+                            result,
+                        },
+                    };
+                }
+                case "validate-repository": {
+                    if (!input.body) {
+                        throw (0, errors_1.createScaiError)("`body` is required for action=validate-repository.", "INPUT_INVALID");
+                    }
+                    const result = await (0, api_1.validateSourceControlRepository)(options, input.body, orgId);
+                    return {
+                        content: [{ type: "text", text: "Validated source-control repository." }],
+                        structuredContent: { action: "validate-repository", result },
+                    };
+                }
+            }
+        },
+    });
+};
+exports.registerDeployTools = registerDeployTools;