@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/mcp/tools/webhook.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Webhook domain — inspect + manage.
+ *
+ *   - `webhook_inspect` (read) lists handlers or fetches one by id/path.
+ *   - `webhook_manage` (write) creates an item/publish event handler or
+ *     a workflow submit/validation action, and deletes any of the above.
+ *
+ * Mirrors the workflow tools' discriminated-verb pattern. Each handler
+ * delegates to the `runWebhook*` task functions shared with the CLI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWebhookTools = void 0;
+const zod_1 = require("zod");
+const create_1 = require("../../webhooks/tasks/create");
+const delete_1 = require("../../webhooks/tasks/delete");
+const event_types_1 = require("../../webhooks/tasks/event-types");
+const inspect_1 = require("../../webhooks/tasks/inspect");
+const list_1 = require("../../webhooks/tasks/list");
+const allow_write_1 = require("../../policy/allow-write");
+const errors_1 = require("../../shared/errors");
+const auth_1 = require("../auth");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const baseTaskOptions = (config, envName, overrides = {}) => ({
+    config,
+    environmentName: envName,
+    quiet: true,
+    json: false,
+    ...overrides,
+});
+const registerWebhookTools = (registry) => {
+    registry.registerTool({
+        name: "webhook_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.webhook_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect Sitecore webhook handlers",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            verb: zod_1.z.enum(["list", "get", "event-types"]).describe("Which read operation to run."),
+            root: zod_1.z
+                .string()
+                .optional()
+                .describe("Content-tree root for verb='list' (default: /sitecore/system/Webhooks). Pass a workflow state path to list workflow-attached webhooks."),
+            eventType: zod_1.z
+                .enum(["item", "publish", "workflow"])
+                .optional()
+                .describe("Filter handlers by category (verb='list')."),
+            enabledOnly: zod_1.z.boolean().optional().describe("Return only enabled handlers (verb='list')."),
+            webhook: zod_1.z
+                .string()
+                .optional()
+                .describe("Item GUID or content-tree path of the webhook handler. Required for verb='get'."),
+            category: zod_1.z
+                .enum(["item", "publish"])
+                .optional()
+                .describe("Catalog branch for verb='event-types'. Omit to list both branches."),
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const taskOpts = baseTaskOptions(context.configPath, input.environmentName ?? context.envName);
+            switch (input.verb) {
+                case "list": {
+                    const result = await (0, list_1.runWebhookList)({
+                        ...taskOpts,
+                        ...(input.root !== undefined && { root: input.root }),
+                        ...(input.eventType !== undefined && { eventType: input.eventType }),
+                        ...(input.enabledOnly !== undefined && { enabledOnly: input.enabledOnly }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${result.handlers.length} webhook handler(s) under ${result.rootPath}.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "get": {
+                    if (!input.webhook) {
+                        throw (0, errors_1.createScaiError)("verb='get' requires `webhook`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, inspect_1.runWebhookInspect)({
+                        ...taskOpts,
+                        webhook: input.webhook,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result
+                                    ? `Webhook '${result.name}' at ${result.path} (enabled=${result.fields.enabled}).`
+                                    : `No webhook handler found at ${input.webhook}.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "event-types": {
+                    const result = await (0, event_types_1.runWebhookEventTypes)({
+                        ...taskOpts,
+                        ...(input.category !== undefined && { category: input.category }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${result.eventTypes.length} event type(s) in tenant catalog.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "webhook_manage",
+        description: descriptions_1.TOOL_DESCRIPTIONS.webhook_manage,
+        auth: "write",
+        annotations: {
+            title: "Create or delete a webhook handler",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            verb: zod_1.z.enum(["create", "delete"]).describe("Which mutation to run."),
+            // create — required for verb='create'
+            name: zod_1.z
+                .string()
+                .optional()
+                .describe("Sitecore item name for the new handler (verb='create')."),
+            url: zod_1.z.string().optional().describe("Webhook target URL (verb='create')."),
+            event: zod_1.z
+                .enum(["item", "publish", "workflow"])
+                .optional()
+                .describe("Event category (verb='create')."),
+            events: zod_1.z
+                .array(zod_1.z.string())
+                .optional()
+                .describe("Event-type names for item/publish flavors (e.g. ['item:saved','publish:end'])."),
+            onState: zod_1.z
+                .string()
+                .optional()
+                .describe("Workflow state or command path (verb='create', event='workflow'). The action item is created at <onState>/Actions/<name>."),
+            action: zod_1.z
+                .enum(["submit", "validation"])
+                .optional()
+                .describe("Workflow action kind (verb='create', event='workflow')."),
+            description: zod_1.z.string().optional().describe("Optional description on the handler."),
+            authorization: zod_1.z
+                .string()
+                .optional()
+                .describe("Absolute path to an Authorization item under /sitecore/system/Settings/Webhooks/Authorizations."),
+            serializationType: zod_1.z
+                .enum(["JSON", "XML"])
+                .optional()
+                .describe("Payload serialization (default JSON)."),
+            parentPath: zod_1.z.string().optional().describe("Override parent path for item/publish handlers."),
+            enabled: zod_1.z.boolean().optional().describe("Enable on creation. Default true."),
+            // delete — required for verb='delete'
+            webhook: zod_1.z
+                .string()
+                .optional()
+                .describe("Item GUID or content-tree path of the handler to delete (verb='delete')."),
+            ...common_1.whatIfShape,
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context) => {
+            // Resolve the target environment (bound default unless retargeted
+            // via `environmentName`). `denyMcpElevation` is checked against
+            // the TARGET env.
+            const binding = await (0, auth_1.resolveToolBinding)(context, input.environmentName);
+            (0, allow_write_1.ensureMcpElevationAllowed)(binding.resolved.root, binding.envName);
+            const taskOpts = baseTaskOptions(context.configPath, binding.envName);
+            switch (input.verb) {
+                case "create": {
+                    if (!input.name || !input.url || !input.event) {
+                        throw (0, errors_1.createScaiError)("verb='create' requires `name`, `url`, and `event`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, create_1.runWebhookCreate)({
+                        ...taskOpts,
+                        name: input.name,
+                        url: input.url,
+                        event: input.event,
+                        ...(input.events !== undefined && { events: input.events }),
+                        ...(input.onState !== undefined && { onState: input.onState }),
+                        ...(input.action !== undefined && { action: input.action }),
+                        ...(input.description !== undefined && { description: input.description }),
+                        ...(input.authorization !== undefined && { authorization: input.authorization }),
+                        ...(input.serializationType !== undefined && {
+                            serializationType: input.serializationType,
+                        }),
+                        ...(input.parentPath !== undefined && { parentPath: input.parentPath }),
+                        ...(input.enabled !== undefined && { enabled: input.enabled }),
+                        ...(input.whatIf !== undefined && { whatIf: input.whatIf }),
+                        ...(input.allowWrite !== undefined && { allowWrite: input.allowWrite }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result.status === "created"
+                                    ? `Created webhook '${result.handler.name}' at ${result.handler.path}.`
+                                    : `Would create '${result.plan.name}' under ${result.plan.parent}.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "delete": {
+                    if (!input.webhook) {
+                        throw (0, errors_1.createScaiError)("verb='delete' requires `webhook`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, delete_1.runWebhookDelete)({
+                        ...taskOpts,
+                        webhook: input.webhook,
+                        ...(input.whatIf !== undefined && { whatIf: input.whatIf }),
+                        ...(input.allowWrite !== undefined && { allowWrite: input.allowWrite }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result.status === "deleted"
+                                    ? `Deleted ${input.webhook}.`
+                                    : result.status === "not-found"
+                                        ? `No webhook handler found at ${input.webhook}.`
+                                        : `Would delete ${input.webhook}.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+            }
+        },
+    });
+};
+exports.registerWebhookTools = registerWebhookTools;

package/dist/mcp/tools/workflow.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Workflow domain — inspect + lifecycle.
+ *
+ * Two tools, workflow-shaped:
+ *
+ *   - `workflow_inspect` (read) discriminates on `verb` so a single
+ *     entry point covers state inspection, available-command lookup,
+ *     workflow-definition enumeration, per-site rollup (XM Apps REST),
+ *     and workflow-state search ("assigned to me" queries).
+ *
+ *   - `workflow_lifecycle` (write) currently exposes a single `verb`
+ *     (`advance`) but is shaped as a discriminated input so future
+ *     mutations (reset to initial, bulk-advance) slot in without
+ *     forcing a tool-name change.
+ *
+ * Each handler delegates to the `runWorkflow*` task function shared
+ * with the CLI; the MCP layer adds only the discriminator routing
+ * and the structured-content envelope.
+ */
+import type { McpRegistry } from "../registry";
+export declare const registerWorkflowTools: (registry: McpRegistry) => void;