@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/webhooks/tasks/create.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhookCreate = void 0;
+const allow_write_1 = require("../../policy/allow-write");
+const errors_1 = require("../../shared/errors");
+const shared_1 = require("./shared");
+const isItemOrPublishFlavor = (event) => event === "item" || event === "publish";
+const runWebhookCreate = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    if (!options.name) {
+        throw (0, errors_1.createScaiError)("--name is required.", "INPUT_INVALID");
+    }
+    if (!options.url) {
+        throw (0, errors_1.createScaiError)("--url is required.", "INPUT_INVALID");
+    }
+    const { envName, root, client } = (0, shared_1.resolveWebhookTenant)(options);
+    if (!options.whatIf) {
+        (0, allow_write_1.ensureAllowWrite)(root, envName, options.allowWrite);
+    }
+    else if (!logger.isJson()) {
+        logger.info("What-if mode — no webhook will be created.", "yellow");
+    }
+    if (isItemOrPublishFlavor(options.event)) {
+        if (!options.events || options.events.length === 0) {
+            throw (0, errors_1.createScaiError)("--event item|publish requires at least one --events <name>.", "INPUT_INVALID", { hint: "Pass --events item:saved (repeat or comma-separate for multiple)." });
+        }
+        const expectedPrefix = options.event === "item" ? "item:" : "publish:";
+        for (const e of options.events) {
+            if (!e.startsWith(expectedPrefix)) {
+                throw (0, errors_1.createScaiError)(`Event '${e}' is not a ${options.event}-event (must start with '${expectedPrefix}').`, "INPUT_INVALID");
+            }
+        }
+        const plan = {
+            flavor: options.event,
+            name: options.name,
+            url: options.url,
+            events: [...options.events],
+            parent: options.parentPath ?? "/sitecore/system/Webhooks",
+        };
+        if (options.whatIf) {
+            const result = { status: "what-if", handler: null, plan };
+            (0, shared_1.printWebhookResult)({
+                logger,
+                command: "webhook.create",
+                envName,
+                result,
+                humanLines: [
+                    `Would create '${options.name}' under ${plan.parent} for events [${plan.events.join(", ")}].`,
+                ],
+            });
+            return result;
+        }
+        const input = {
+            name: options.name,
+            url: options.url,
+            events: options.events,
+            ...(options.enabled !== undefined && { enabled: options.enabled }),
+            ...(options.description !== undefined && { description: options.description }),
+            ...(options.authorization !== undefined && { authorizationPath: options.authorization }),
+            ...(options.serializationType !== undefined && {
+                serializationType: options.serializationType,
+            }),
+            ...(options.parentPath !== undefined && { parentPath: options.parentPath }),
+        };
+        const handler = await client.createEventHandler(input);
+        const result = { status: "created", handler, plan };
+        (0, shared_1.printWebhookResult)({
+            logger,
+            command: "webhook.create",
+            envName,
+            result,
+            humanLines: [`Created webhook '${handler.name}' (${handler.itemId}) at ${handler.path}.`],
+        });
+        return result;
+    }
+    // workflow flavor
+    if (!options.onState) {
+        throw (0, errors_1.createScaiError)("--event workflow requires --on-state pointing at a workflow state or command path.", "INPUT_INVALID");
+    }
+    const actionKind = options.action ?? "submit";
+    const plan = {
+        flavor: "workflow",
+        name: options.name,
+        url: options.url,
+        workflowAction: actionKind,
+        parent: `${options.onState.replace(/\/$/, "")}/Actions`,
+    };
+    if (options.whatIf) {
+        const result = { status: "what-if", handler: null, plan };
+        (0, shared_1.printWebhookResult)({
+            logger,
+            command: "webhook.create",
+            envName,
+            result,
+            humanLines: [
+                `Would create workflow ${actionKind}-action '${options.name}' under ${plan.parent}.`,
+            ],
+        });
+        return result;
+    }
+    const input = {
+        name: options.name,
+        url: options.url,
+        stateOrCommandPath: options.onState,
+        ...(options.enabled !== undefined && { enabled: options.enabled }),
+        ...(options.description !== undefined && { description: options.description }),
+        ...(options.authorization !== undefined && { authorizationPath: options.authorization }),
+        ...(options.serializationType !== undefined && {
+            serializationType: options.serializationType,
+        }),
+    };
+    const handler = actionKind === "validation"
+        ? await client.createWorkflowValidationAction(input)
+        : await client.createWorkflowSubmitAction(input);
+    const result = { status: "created", handler, plan };
+    (0, shared_1.printWebhookResult)({
+        logger,
+        command: "webhook.create",
+        envName,
+        result,
+        humanLines: [
+            `Created workflow ${actionKind}-action '${handler.name}' (${handler.itemId}) at ${handler.path}.`,
+        ],
+    });
+    return result;
+};
+exports.runWebhookCreate = runWebhookCreate;

package/dist/webhooks/tasks/delete.d.ts

@@ -0,0 +1,14 @@
+import { type WebhookTaskOptions } from "./shared";
+export interface WebhookDeleteOptions extends WebhookTaskOptions {
+    /** Item GUID or content-tree path of the webhook handler. */
+    webhook: string;
+    /** Per-invocation override of the env's `allowWrite` flag. */
+    allowWrite?: boolean;
+    /** Plan-only — no mutation. */
+    whatIf?: boolean;
+}
+export interface WebhookDeleteResult {
+    status: "deleted" | "what-if" | "not-found";
+    webhook: string;
+}
+export declare const runWebhookDelete: (options: WebhookDeleteOptions) => Promise<WebhookDeleteResult>;

package/dist/webhooks/tasks/delete.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhookDelete = void 0;
+const allow_write_1 = require("../../policy/allow-write");
+const errors_1 = require("../../shared/errors");
+const inspect_1 = require("./inspect");
+const shared_1 = require("./shared");
+const runWebhookDelete = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    if (!options.webhook) {
+        throw (0, errors_1.createScaiError)("Webhook reference is required.", "INPUT_INVALID");
+    }
+    const selector = (0, inspect_1.parseWebhookRef)(options.webhook);
+    const { envName, root, client } = (0, shared_1.resolveWebhookTenant)(options);
+    if (!options.whatIf) {
+        (0, allow_write_1.ensureAllowWrite)(root, envName, options.allowWrite);
+    }
+    else if (!logger.isJson()) {
+        logger.info("What-if mode — no webhook will be deleted.", "yellow");
+    }
+    // Verify the handler exists first — issues a clean "not-found" error
+    // rather than a generic deleteItem failure.
+    const detail = await client.getEventHandler(selector);
+    if (!detail) {
+        const result = { status: "not-found", webhook: options.webhook };
+        (0, shared_1.printWebhookResult)({
+            logger,
+            command: "webhook.delete",
+            envName,
+            result,
+            humanLines: [`No webhook handler found at ${options.webhook}.`],
+        });
+        return result;
+    }
+    if (options.whatIf) {
+        const result = { status: "what-if", webhook: options.webhook };
+        (0, shared_1.printWebhookResult)({
+            logger,
+            command: "webhook.delete",
+            envName,
+            result,
+            humanLines: [`Would delete ${detail.name} (${detail.itemId}) at ${detail.path}.`],
+        });
+        return result;
+    }
+    await client.deleteWebhookItem({ itemId: detail.itemId });
+    const result = { status: "deleted", webhook: options.webhook };
+    (0, shared_1.printWebhookResult)({
+        logger,
+        command: "webhook.delete",
+        envName,
+        result,
+        humanLines: [`Deleted ${detail.name} (${detail.itemId}) from ${detail.path}.`],
+    });
+    return result;
+};
+exports.runWebhookDelete = runWebhookDelete;

package/dist/webhooks/tasks/event-types.d.ts

@@ -0,0 +1,21 @@
+import type { WebhookEventTypeCategory, WebhookEventTypeSummary } from "../api/client";
+import { type WebhookTaskOptions } from "./shared";
+export interface WebhookEventTypesOptions extends WebhookTaskOptions {
+    /** Limit results to a single catalog branch. */
+    category?: WebhookEventTypeCategory;
+}
+export interface WebhookEventTypesResult {
+    eventTypes: WebhookEventTypeSummary[];
+}
+/**
+ * Discover which event-type strings the target tenant accepts for
+ * `scai content workflow webhook create --events <name>`. The catalog lives in Sitecore
+ * content under `/sitecore/system/Settings/Webhooks/Event Types/` and
+ * is tenant-customizable, so we resolve it at runtime rather than
+ * baking a static list into the SDK.
+ *
+ * Output orders `item` events first, then `publish`. Within a category
+ * the order matches the Sitecore content tree's child order — operators
+ * see what the CMS shows them, not an alphabetized rewrite.
+ */
+export declare const runWebhookEventTypes: (options: WebhookEventTypesOptions) => Promise<WebhookEventTypesResult>;

package/dist/webhooks/tasks/event-types.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhookEventTypes = void 0;
+const shared_1 = require("./shared");
+/**
+ * Discover which event-type strings the target tenant accepts for
+ * `scai content workflow webhook create --events <name>`. The catalog lives in Sitecore
+ * content under `/sitecore/system/Settings/Webhooks/Event Types/` and
+ * is tenant-customizable, so we resolve it at runtime rather than
+ * baking a static list into the SDK.
+ *
+ * Output orders `item` events first, then `publish`. Within a category
+ * the order matches the Sitecore content tree's child order — operators
+ * see what the CMS shows them, not an alphabetized rewrite.
+ */
+const runWebhookEventTypes = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { envName, client } = (0, shared_1.resolveWebhookTenant)(options);
+    const eventTypes = await client.listEventTypes(options.category !== undefined ? { category: options.category } : undefined);
+    const lines = eventTypes.length > 0
+        ? eventTypes.map((e) => `  [${e.category}] ${e.name}  (${e.itemId})`)
+        : ["No webhook event types found in the tenant catalog."];
+    (0, shared_1.printWebhookResult)({
+        logger,
+        command: "webhook.event-types",
+        envName,
+        result: { eventTypes },
+        humanLines: [`Webhook event types in '${envName}':`, ...lines],
+    });
+    return { eventTypes };
+};
+exports.runWebhookEventTypes = runWebhookEventTypes;

package/dist/webhooks/tasks/inspect.d.ts

@@ -0,0 +1,12 @@
+import type { WebhookHandlerDetail } from "../api/client";
+import { type WebhookTaskOptions } from "./shared";
+export interface WebhookInspectOptions extends WebhookTaskOptions {
+    /** Item GUID or content-tree path of the webhook handler. */
+    webhook: string;
+}
+declare const parseWebhookRef: (value: string) => {
+    itemId?: string;
+    path?: string;
+};
+export declare const runWebhookInspect: (options: WebhookInspectOptions) => Promise<WebhookHandlerDetail | null>;
+export { parseWebhookRef };

package/dist/webhooks/tasks/inspect.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWebhookRef = exports.runWebhookInspect = void 0;
+const errors_1 = require("../../shared/errors");
+const shared_1 = require("./shared");
+const ITEM_ID_PATTERN = /^\{?[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\}?$/i;
+const parseWebhookRef = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw (0, errors_1.createScaiError)("Webhook reference is empty.", "INPUT_INVALID");
+    }
+    if (trimmed.startsWith("/sitecore/") || trimmed.startsWith("/Sitecore/")) {
+        return { path: trimmed };
+    }
+    if (ITEM_ID_PATTERN.test(trimmed)) {
+        return { itemId: trimmed };
+    }
+    throw (0, errors_1.createScaiError)(`'${value}' is not a valid webhook reference. Expected a Sitecore GUID or a content-tree path.`, "INPUT_INVALID");
+};
+exports.parseWebhookRef = parseWebhookRef;
+const runWebhookInspect = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const selector = parseWebhookRef(options.webhook);
+    const { envName, client } = (0, shared_1.resolveWebhookTenant)(options);
+    const detail = await client.getEventHandler(selector);
+    if (!detail) {
+        if (logger.isJson()) {
+            logger.json({
+                command: "webhook.inspect",
+                environment: envName,
+                result: null,
+                reason: "not-found",
+            });
+        }
+        else {
+            logger.info(`No webhook handler found at ${selector.path ?? selector.itemId}.`);
+        }
+        return null;
+    }
+    const f = detail.fields;
+    const humanLines = [
+        `Item:           ${detail.path}`,
+        `Template:       ${detail.templateName ?? "?"}`,
+        `URL:            ${f.url ?? "(unset)"}`,
+        `Enabled:        ${f.enabled ? "yes" : "no"}`,
+        `Serialization:  ${f.serializationType ?? "JSON"}`,
+        `Authorization:  ${f.authorizationItemId ? f.authorizationItemId : "(none)"}`,
+        `Description:    ${f.description ?? "(none)"}`,
+        `Event count:    ${f.events.length}`,
+    ];
+    if (f.events.length > 0) {
+        humanLines.push("Event-type GUIDs:");
+        for (const e of f.events)
+            humanLines.push(`  - ${e}`);
+    }
+    (0, shared_1.printWebhookResult)({
+        logger,
+        command: "webhook.inspect",
+        envName,
+        result: detail,
+        humanLines,
+    });
+    return detail;
+};
+exports.runWebhookInspect = runWebhookInspect;

package/dist/webhooks/tasks/list.d.ts

@@ -0,0 +1,29 @@
+import type { WebhookHandlerSummary } from "../api/client";
+import { type WebhookTaskOptions } from "./shared";
+export type WebhookEventCategory = "item" | "publish" | "workflow";
+export interface WebhookListOptions extends WebhookTaskOptions {
+    /**
+     * Override the content-tree root to scan. Defaults to
+     * `/sitecore/system/Webhooks` (where item + publish event handlers
+     * live). Workflow webhook actions live under workflow states and
+     * require a per-state root override.
+     */
+    root?: string;
+    /** Filter to handlers whose template name matches the category. */
+    eventType?: WebhookEventCategory;
+    /** Return only enabled handlers. */
+    enabledOnly?: boolean;
+}
+export interface WebhookListResult {
+    rootPath: string;
+    handlers: WebhookHandlerSummary[];
+}
+/**
+ * List webhook handler items under the configured tree. Categories
+ * `item` and `publish` filter the same template (the catalog
+ * distinguishes them by the `Events` field, not the handler template).
+ * Category `workflow` filters to Submit Actions; pair with a `--root`
+ * pointing at a workflow state to find workflow webhooks attached to
+ * a specific transition.
+ */
+export declare const runWebhookList: (options: WebhookListOptions) => Promise<WebhookListResult>;

package/dist/webhooks/tasks/list.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhookList = void 0;
+const shared_1 = require("./shared");
+const TEMPLATE_NAME_BY_CATEGORY = {
+    item: "Webhook Event Handler",
+    publish: "Webhook Event Handler",
+    workflow: "Webhook Submit Action",
+};
+/**
+ * List webhook handler items under the configured tree. Categories
+ * `item` and `publish` filter the same template (the catalog
+ * distinguishes them by the `Events` field, not the handler template).
+ * Category `workflow` filters to Submit Actions; pair with a `--root`
+ * pointing at a workflow state to find workflow webhooks attached to
+ * a specific transition.
+ */
+const runWebhookList = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const { envName, client } = (0, shared_1.resolveWebhookTenant)(options);
+    const rootPath = options.root ?? "/sitecore/system/Webhooks";
+    const all = await client.listEventHandlers({
+        rootPath,
+        ...(options.enabledOnly !== undefined && { enabledOnly: options.enabledOnly }),
+    });
+    const handlers = options.eventType
+        ? all.filter((h) => h.templateName === TEMPLATE_NAME_BY_CATEGORY[options.eventType])
+        : all;
+    const lines = handlers.length > 0
+        ? handlers.map((h) => `${h.name} (${h.itemId}) — ${h.path}${h.templateName ? ` [${h.templateName}]` : ""}`)
+        : [`No webhook handlers found under ${rootPath}.`];
+    (0, shared_1.printWebhookResult)({
+        logger,
+        command: "webhook.list",
+        envName,
+        result: { rootPath, handlers },
+        humanLines: lines,
+    });
+    return { rootPath, handlers };
+};
+exports.runWebhookList = runWebhookList;

package/dist/webhooks/tasks/shared.d.ts

@@ -0,0 +1,35 @@
+import { Logger } from "../../shared/logger";
+import type { EnvironmentConfiguration, RootConfiguration } from "../../config/types";
+import { type WebhookApiClient } from "../api/client";
+/** Shared option shape for `scai content workflow webhook *` tasks. */
+export interface WebhookTaskOptions {
+    config?: string;
+    environmentName?: string;
+    verbose?: boolean;
+    trace?: boolean;
+    quiet?: boolean;
+    json?: boolean;
+    logFile?: string;
+    nonInteractive?: boolean;
+}
+export declare const toLogger: (options: WebhookTaskOptions) => Logger;
+export interface ResolvedWebhookTenant {
+    envName: string;
+    environment: EnvironmentConfiguration;
+    root: RootConfiguration;
+    client: WebhookApiClient;
+}
+export declare const resolveWebhookTenant: (options: WebhookTaskOptions) => ResolvedWebhookTenant;
+/**
+ * Render a result as a `--json` envelope or as a small human-readable
+ * block. Mirrors `printWorkflowResult` — single-record commands don't
+ * need hygiene's broader `printReport` with baseline + output-file
+ * support.
+ */
+export declare const printWebhookResult: (params: {
+    logger: Logger;
+    command: string;
+    envName: string;
+    result: unknown;
+    humanLines?: string[];
+}) => void;

package/dist/webhooks/tasks/shared.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printWebhookResult = exports.resolveWebhookTenant = exports.toLogger = void 0;
+const logger_1 = require("../../shared/logger");
+const environment_1 = require("../../policy/environment");
+const client_1 = require("../api/client");
+const toLogger = (options) => new logger_1.Logger(Boolean(options.verbose), Boolean(options.trace), Boolean(options.json), Boolean(options.quiet), options.logFile ?? process.env.SITECOREAI_LOG_FILE);
+exports.toLogger = toLogger;
+const resolveWebhookTenant = (options) => {
+    const { envName, environment, root, timeoutMs } = (0, environment_1.resolveEnvironment)(options);
+    const client = (0, client_1.createWebhookApiClient)({
+        environment,
+        request: { timeoutMs },
+    });
+    return { envName, environment, root, client };
+};
+exports.resolveWebhookTenant = resolveWebhookTenant;
+/**
+ * Render a result as a `--json` envelope or as a small human-readable
+ * block. Mirrors `printWorkflowResult` — single-record commands don't
+ * need hygiene's broader `printReport` with baseline + output-file
+ * support.
+ */
+const printWebhookResult = (params) => {
+    const { logger, command, envName, result, humanLines } = params;
+    if (logger.isJson()) {
+        logger.json({ command, environment: envName, result });
+        return;
+    }
+    if (humanLines && humanLines.length > 0) {
+        for (const line of humanLines)
+            logger.info(line);
+    }
+    else {
+        logger.info(JSON.stringify(result, null, 2));
+    }
+};
+exports.printWebhookResult = printWebhookResult;