@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/webhooks/api/client.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookApiClient = exports.WEBHOOK_FIELD_SERIALIZATION_TYPE = exports.WEBHOOK_FIELD_AUTHORIZATION = exports.WEBHOOK_FIELD_ENABLED = exports.WEBHOOK_FIELD_EVENTS = exports.WEBHOOK_FIELD_URL = exports.WEBHOOK_FIELD_DESCRIPTION = exports.DEFAULT_WEBHOOK_HANDLERS_ROOT = void 0;
+const errors_1 = require("../../shared/errors");
+const graphql_1 = require("../../shared/graphql");
+const graphql_2 = require("./graphql");
+const templates_1 = require("./templates");
+/**
+ * Authoring GraphQL operations for the Sitecore webhook content tree.
+ *
+ * Webhooks in XM Cloud are content items, not a dedicated API surface.
+ * This client wraps `createItem` / `updateItem` / `deleteItem` against
+ * `/sitecore/system/Webhooks` (event handlers) and the workflow
+ * `Actions` subtree (submit/validation actions). See
+ * `templates.ts` for the runtime template ID + event-type catalog
+ * resolution.
+ */
+exports.DEFAULT_WEBHOOK_HANDLERS_ROOT = "/sitecore/system/Webhooks";
+exports.WEBHOOK_FIELD_DESCRIPTION = "Description";
+exports.WEBHOOK_FIELD_URL = "Url";
+exports.WEBHOOK_FIELD_EVENTS = "Events";
+exports.WEBHOOK_FIELD_ENABLED = "Enabled";
+exports.WEBHOOK_FIELD_AUTHORIZATION = "Authorization";
+exports.WEBHOOK_FIELD_SERIALIZATION_TYPE = "Serialization Type";
+const ITEM_FIELDS_FRAGMENT = `
+  itemId
+  name
+  path
+  template { templateId name }
+  fields(ownFields: false) {
+    nodes { name value }
+  }`;
+const GET_ITEM_BY_ID = `
+query($itemId: ID!) {
+  item(where: { itemId: $itemId }) {${ITEM_FIELDS_FRAGMENT}
+  }
+}`;
+const GET_ITEM_BY_PATH = `
+query($path: String!) {
+  item(where: { path: $path }) {${ITEM_FIELDS_FRAGMENT}
+  }
+}`;
+const GET_CHILDREN_BY_PATH = `
+query($path: String!) {
+  item(where: { path: $path }) {
+    children {
+      nodes {
+        itemId
+        name
+        path
+        template { templateId name }
+        fields(ownFields: false) { nodes { name value } }
+      }
+    }
+  }
+}`;
+const CREATE_ITEM_MUTATION = `
+mutation($input: CreateItemInput!) {
+  createItem(input: $input) {
+    item { itemId name path }
+  }
+}`;
+const DELETE_ITEM_MUTATION = `
+mutation($input: DeleteItemInput!) {
+  deleteItem(input: $input) { successful }
+}`;
+const WEBHOOK_EVENT_HANDLER_TEMPLATE_NAME = "Webhook Event Handler";
+const WEBHOOK_SUBMIT_ACTION_TEMPLATE_NAME = "Webhook Submit Action";
+const WEBHOOK_VALIDATION_ACTION_TEMPLATE_NAME = "Webhook Validation Action";
+const isWebhookFolder = (templateName) => templateName === "Folder" || templateName === "Webhook Folder";
+const isWebhookHandlerTemplate = (templateName) => templateName === WEBHOOK_EVENT_HANDLER_TEMPLATE_NAME ||
+    templateName === WEBHOOK_SUBMIT_ACTION_TEMPLATE_NAME ||
+    templateName === WEBHOOK_VALIDATION_ACTION_TEMPLATE_NAME;
+const fieldsToMap = (nodes) => {
+    const map = new Map();
+    for (const f of nodes)
+        map.set(f.name, f.value);
+    return map;
+};
+const parseEventsRaw = (raw) => {
+    if (!raw)
+        return [];
+    return raw
+        .split("|")
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0);
+};
+const flattenFields = (raw) => {
+    const map = fieldsToMap(raw.fields.nodes);
+    const eventsRaw = map.get(exports.WEBHOOK_FIELD_EVENTS) ?? null;
+    return {
+        description: map.get(exports.WEBHOOK_FIELD_DESCRIPTION) ?? null,
+        url: map.get(exports.WEBHOOK_FIELD_URL) ?? null,
+        eventsRaw,
+        // Resolving event GUIDs back to display names would require an
+        // extra batch query per inspect call. Surface the raw GUID list for
+        // now; callers that need display names can join with the event-type
+        // catalog separately.
+        events: parseEventsRaw(eventsRaw),
+        enabled: (map.get(exports.WEBHOOK_FIELD_ENABLED) ?? "").trim() === "1",
+        authorizationItemId: map.get(exports.WEBHOOK_FIELD_AUTHORIZATION) ?? null,
+        serializationType: map.get(exports.WEBHOOK_FIELD_SERIALIZATION_TYPE) ?? null,
+    };
+};
+const toSummary = (raw) => ({
+    itemId: raw.itemId,
+    name: raw.name,
+    path: raw.path,
+    templateName: raw.template?.name ?? null,
+});
+const toDetail = (raw) => ({
+    ...toSummary(raw),
+    fields: flattenFields(raw),
+});
+const createWebhookApiClient = (options) => {
+    const { environment, request } = options;
+    const readRequest = {
+        ...request,
+        retry: { ...request?.retry, retryableStatuses: graphql_1.READ_RETRYABLE_STATUSES },
+    };
+    // Writes are not retried — the Authoring API has no idempotency-key
+    // mechanism, and retrying createItem after a 503 risks producing
+    // duplicate items.
+    const writeRequest = {
+        ...(request ?? {}),
+        retry: { maxAttempts: 1 },
+    };
+    const templates = (0, templates_1.createWebhookTemplateResolver)(environment, readRequest);
+    const fetchByPath = async (path) => {
+        const data = await (0, graphql_2.runWebhookAuthoringGraphQL)(environment, GET_ITEM_BY_PATH, { path }, readRequest);
+        return data.item;
+    };
+    const fetchById = async (itemId) => {
+        const data = await (0, graphql_2.runWebhookAuthoringGraphQL)(environment, GET_ITEM_BY_ID, { itemId }, readRequest);
+        return data.item;
+    };
+    const listChildrenRaw = async (path) => {
+        const data = await (0, graphql_2.runWebhookAuthoringGraphQL)(environment, GET_CHILDREN_BY_PATH, { path }, readRequest);
+        return data.item?.children.nodes ?? [];
+    };
+    const listEventHandlers = async (opts) => {
+        const rootPath = opts?.rootPath ?? exports.DEFAULT_WEBHOOK_HANDLERS_ROOT;
+        const results = [];
+        const visit = async (path, depth) => {
+            const children = await listChildrenRaw(path);
+            for (const c of children) {
+                const tname = c.template?.name ?? null;
+                if (isWebhookHandlerTemplate(tname)) {
+                    if (opts?.enabledOnly) {
+                        const enabled = (fieldsToMap(c.fields.nodes).get(exports.WEBHOOK_FIELD_ENABLED) ?? "").trim() === "1";
+                        if (!enabled)
+                            continue;
+                    }
+                    results.push(toSummary(c));
+                }
+                else if (isWebhookFolder(tname) && depth < 1) {
+                    await visit(c.path, depth + 1);
+                }
+            }
+        };
+        await visit(rootPath, 0);
+        return results;
+    };
+    const listEventTypes = async (opts) => {
+        // Roots: Item/, Publish/. Walk one level — each child IS the
+        // catalog item (no nested folders in base content). If a tenant
+        // organizes the catalog into folders later, the surfaced names
+        // skip them — operators authoring webhooks reference catalog
+        // strings by their leaf name, not their tree path, so flattening
+        // is the right behavior here.
+        const roots = [];
+        if (opts?.category === undefined || opts.category === "item") {
+            roots.push(["item", templates_1.EVENT_TYPE_ITEM_ROOT]);
+        }
+        if (opts?.category === undefined || opts.category === "publish") {
+            roots.push(["publish", templates_1.EVENT_TYPE_PUBLISH_ROOT]);
+        }
+        const results = [];
+        for (const [category, root] of roots) {
+            const children = await listChildrenRaw(root);
+            for (const c of children) {
+                results.push({
+                    name: c.name,
+                    itemId: c.itemId,
+                    category,
+                    path: c.path,
+                });
+            }
+        }
+        return results;
+    };
+    const getEventHandler = async (input) => {
+        if (!input.itemId && !input.path) {
+            throw (0, errors_1.createScaiError)("getEventHandler requires either itemId or path.", "INPUT_INVALID");
+        }
+        const raw = input.itemId ? await fetchById(input.itemId) : await fetchByPath(input.path);
+        return raw ? toDetail(raw) : null;
+    };
+    /**
+     * Common create path — assembles `CreateItemInput`, dispatches the
+     * mutation, returns a summary. `templateId`, `parent`, `name`, and
+     * the field map are caller-prepared so flavor-specific helpers can
+     * vary their template + parent + field set without duplicating the
+     * dispatch.
+     */
+    const dispatchCreate = async (input) => {
+        const payload = {
+            input: {
+                templateId: input.templateId,
+                parent: input.parent,
+                name: input.name,
+                language: "en",
+                database: "master",
+                fields: input.fields,
+            },
+        };
+        const data = await (0, graphql_2.runWebhookAuthoringGraphQL)(environment, CREATE_ITEM_MUTATION, payload, writeRequest);
+        const created = data.createItem?.item;
+        if (!created) {
+            throw (0, errors_1.createScaiError)(`Webhook createItem returned no item for '${input.name}' under '${input.parent}'.`, "UNKNOWN");
+        }
+        return {
+            itemId: created.itemId,
+            name: created.name,
+            path: created.path,
+            templateName: null,
+        };
+    };
+    const resolveAuthorizationItemId = async (authorizationPath) => {
+        if (!authorizationPath)
+            return null;
+        const id = await templates.resolveItemIdByPath(authorizationPath);
+        if (!id) {
+            throw (0, errors_1.createScaiError)(`Webhook Authorization item not found at '${authorizationPath}'.`, "INPUT_INVALID", {
+                hint: "Authorization items live under '/sitecore/system/Settings/Webhooks/Authorizations'. Create one in Sitecore or omit --authorization to leave the handler unauthorized.",
+            });
+        }
+        return id;
+    };
+    const buildSharedFields = async (input) => {
+        const fields = [
+            { name: exports.WEBHOOK_FIELD_URL, value: input.url },
+            { name: exports.WEBHOOK_FIELD_ENABLED, value: input.enabled === false ? "" : "1" },
+            {
+                name: exports.WEBHOOK_FIELD_SERIALIZATION_TYPE,
+                value: input.serializationType ?? "JSON",
+            },
+        ];
+        if (input.description !== undefined) {
+            fields.push({ name: exports.WEBHOOK_FIELD_DESCRIPTION, value: input.description });
+        }
+        const authId = await resolveAuthorizationItemId(input.authorizationPath);
+        if (authId) {
+            fields.push({ name: exports.WEBHOOK_FIELD_AUTHORIZATION, value: authId });
+        }
+        return fields;
+    };
+    const createEventHandler = async (input) => {
+        if (input.events.length === 0) {
+            throw (0, errors_1.createScaiError)("createEventHandler requires at least one event type.", "INPUT_INVALID", { hint: "Pass --event <name> (e.g. 'item:saved', 'publish:end')." });
+        }
+        const [templateId, eventGuids] = await Promise.all([
+            templates.webhookEventHandlerTemplateId(),
+            templates.resolveEventTypeIds(input.events),
+        ]);
+        const fields = await buildSharedFields(input);
+        // Events is a multilist field: pipe-delimited list of catalog item IDs.
+        fields.push({ name: exports.WEBHOOK_FIELD_EVENTS, value: eventGuids.join("|") });
+        return dispatchCreate({
+            templateId,
+            parent: input.parentPath ?? exports.DEFAULT_WEBHOOK_HANDLERS_ROOT,
+            name: input.name,
+            fields,
+        });
+    };
+    const createWorkflowActionImpl = async (input, templateId) => {
+        const fields = await buildSharedFields(input);
+        // Actions are created under <state-or-command>/Actions. The Actions
+        // folder is auto-created by Sitecore with the state/command; if it
+        // is missing the create call fails with a clear "parent not found"
+        // upstream error, which is the right signal to surface.
+        const parent = `${input.stateOrCommandPath.replace(/\/$/, "")}/Actions`;
+        return dispatchCreate({
+            templateId,
+            parent,
+            name: input.name,
+            fields,
+        });
+    };
+    const createWorkflowSubmitAction = async (input) => {
+        const templateId = await templates.webhookSubmitActionTemplateId();
+        return createWorkflowActionImpl(input, templateId);
+    };
+    const createWorkflowValidationAction = async (input) => {
+        const templateId = await templates.webhookValidationActionTemplateId();
+        return createWorkflowActionImpl(input, templateId);
+    };
+    const deleteWebhookItem = async (input) => {
+        if (!input.itemId && !input.path) {
+            throw (0, errors_1.createScaiError)("deleteWebhookItem requires either itemId or path.", "INPUT_INVALID");
+        }
+        const payload = {
+            database: "master",
+            permanently: true,
+        };
+        if (input.itemId)
+            payload.itemId = input.itemId;
+        else if (input.path)
+            payload.path = input.path;
+        const data = await (0, graphql_2.runWebhookAuthoringGraphQL)(environment, DELETE_ITEM_MUTATION, { input: payload }, writeRequest);
+        if (!data.deleteItem?.successful) {
+            throw (0, errors_1.createScaiError)(`Webhook deleteItem returned successful=${data.deleteItem?.successful} for ${input.itemId ?? input.path}`, "UNKNOWN");
+        }
+    };
+    return {
+        listEventHandlers,
+        getEventHandler,
+        createEventHandler,
+        createWorkflowSubmitAction,
+        createWorkflowValidationAction,
+        deleteWebhookItem,
+        listEventTypes,
+        templates,
+    };
+};
+exports.createWebhookApiClient = createWebhookApiClient;

package/dist/webhooks/api/graphql.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentConfiguration } from "../../config/types";
+import { type GraphQLRequestOptions } from "../../shared/graphql";
+export type WebhookRequestOptions = GraphQLRequestOptions;
+export declare const runWebhookAuthoringGraphQL: <T>(environment: EnvironmentConfiguration, query: string, variables?: Record<string, unknown>, options?: WebhookRequestOptions) => Promise<T>;

package/dist/webhooks/api/graphql.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhookAuthoringGraphQL = void 0;
+const graphql_1 = require("../../shared/graphql");
+const auth_1 = require("../../serialization/api/auth");
+const DEFAULT_AUTHORING_PATH = "/sitecore/api/authoring/graphql/v1";
+const resolveAuthoringPath = () => process.env.SITECOREAI_AUTHORING_PATH ?? DEFAULT_AUTHORING_PATH;
+const DEFAULT_AUTHORING_RETRY = { maxAttempts: 5 };
+const runWebhookAuthoringGraphQL = (environment, query, variables, options) => (0, graphql_1.runSitecoreGraphQL)(environment, query, variables, {
+    servicePath: resolveAuthoringPath(),
+    label: "Webhook",
+    requireToken: true,
+    getAccessToken: auth_1.getAccessToken,
+}, {
+    ...options,
+    retry: { ...DEFAULT_AUTHORING_RETRY, ...(options?.retry ?? {}) },
+});
+exports.runWebhookAuthoringGraphQL = runWebhookAuthoringGraphQL;

package/dist/webhooks/api/templates.d.ts

@@ -0,0 +1,41 @@
+import type { EnvironmentConfiguration } from "../../config/types";
+import { type WebhookRequestOptions } from "./graphql";
+/**
+ * Runtime resolvers for Sitecore template IDs and event-type catalog
+ * item IDs needed by `scai content workflow webhook create`.
+ *
+ * **Why runtime, not hardcoded.** XM Cloud ships these templates and
+ * catalog items as part of base content, but Sitecore has never
+ * published their GUIDs as a public contract — they're treated as
+ * tenant-internal. They should be stable within a major version, but
+ * resolving by path keeps the CLI working if a tenant has been
+ * customized or if Sitecore ever renumbers them in a base-content
+ * update.
+ *
+ * Both resolvers cache per-instance — the resolver is constructed
+ * once per `WebhookApiClient` invocation, so subsequent `create` calls
+ * within the same task run share the cache and pay for resolution
+ * once.
+ */
+export declare const WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH = "/sitecore/templates/System/Webhooks/Webhook Event Handler";
+export declare const WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH = "/sitecore/templates/System/Workflow/Webhook Submit Action";
+export declare const WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH = "/sitecore/templates/System/Workflow/Webhook Validation Action";
+export declare const EVENT_TYPE_ITEM_ROOT = "/sitecore/system/Settings/Webhooks/Event Types/Item";
+export declare const EVENT_TYPE_PUBLISH_ROOT = "/sitecore/system/Settings/Webhooks/Event Types/Publish";
+export interface WebhookTemplateResolver {
+    /** Resolve the Webhook Event Handler template's item ID. */
+    webhookEventHandlerTemplateId(): Promise<string>;
+    /** Resolve the Webhook Submit Action (workflow) template's item ID. */
+    webhookSubmitActionTemplateId(): Promise<string>;
+    /** Resolve the Webhook Validation Action (workflow) template's item ID. */
+    webhookValidationActionTemplateId(): Promise<string>;
+    /**
+     * Resolve a set of event-type names (e.g. `item:saved`, `publish:end`)
+     * to their catalog item IDs. Missing events throw `INPUT_INVALID`
+     * with a hint pointing at the catalog tree.
+     */
+    resolveEventTypeIds(eventNames: readonly string[]): Promise<string[]>;
+    /** Generic path resolution. Returns null if the item doesn't exist. */
+    resolveItemIdByPath(path: string): Promise<string | null>;
+}
+export declare const createWebhookTemplateResolver: (environment: EnvironmentConfiguration, request?: WebhookRequestOptions) => WebhookTemplateResolver;

package/dist/webhooks/api/templates.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookTemplateResolver = exports.EVENT_TYPE_PUBLISH_ROOT = exports.EVENT_TYPE_ITEM_ROOT = exports.WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH = exports.WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH = exports.WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH = void 0;
+const errors_1 = require("../../shared/errors");
+const graphql_1 = require("./graphql");
+/**
+ * Runtime resolvers for Sitecore template IDs and event-type catalog
+ * item IDs needed by `scai content workflow webhook create`.
+ *
+ * **Why runtime, not hardcoded.** XM Cloud ships these templates and
+ * catalog items as part of base content, but Sitecore has never
+ * published their GUIDs as a public contract — they're treated as
+ * tenant-internal. They should be stable within a major version, but
+ * resolving by path keeps the CLI working if a tenant has been
+ * customized or if Sitecore ever renumbers them in a base-content
+ * update.
+ *
+ * Both resolvers cache per-instance — the resolver is constructed
+ * once per `WebhookApiClient` invocation, so subsequent `create` calls
+ * within the same task run share the cache and pay for resolution
+ * once.
+ */
+exports.WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH = "/sitecore/templates/System/Webhooks/Webhook Event Handler";
+exports.WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH = "/sitecore/templates/System/Workflow/Webhook Submit Action";
+exports.WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH = "/sitecore/templates/System/Workflow/Webhook Validation Action";
+exports.EVENT_TYPE_ITEM_ROOT = "/sitecore/system/Settings/Webhooks/Event Types/Item";
+exports.EVENT_TYPE_PUBLISH_ROOT = "/sitecore/system/Settings/Webhooks/Event Types/Publish";
+const LOOKUP_ITEM_BY_PATH = `
+query($path: String!) {
+  item(where: { path: $path }) {
+    itemId
+    name
+    path
+  }
+}`;
+const createWebhookTemplateResolver = (environment, request) => {
+    const cache = new Map();
+    const resolveItemIdByPath = async (path) => {
+        if (cache.has(path))
+            return cache.get(path) ?? null;
+        const data = await (0, graphql_1.runWebhookAuthoringGraphQL)(environment, LOOKUP_ITEM_BY_PATH, { path }, request);
+        const id = data.item?.itemId ?? null;
+        cache.set(path, id);
+        return id;
+    };
+    const resolveTemplate = async (path, label) => {
+        const id = await resolveItemIdByPath(path);
+        if (!id) {
+            throw (0, errors_1.createScaiError)(`Could not resolve the ${label} template at '${path}'.`, "ENV_NOT_FOUND", {
+                hint: "Verify the path exists on the target tenant. XM Cloud ships this template in base content; if it's missing, the tenant may be on an older version or the path was customized.",
+            });
+        }
+        return id;
+    };
+    return {
+        webhookEventHandlerTemplateId: () => resolveTemplate(exports.WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH, "Webhook Event Handler"),
+        webhookSubmitActionTemplateId: () => resolveTemplate(exports.WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH, "Webhook Submit Action"),
+        webhookValidationActionTemplateId: () => resolveTemplate(exports.WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH, "Webhook Validation Action"),
+        resolveEventTypeIds: async (eventNames) => {
+            const ids = [];
+            for (const name of eventNames) {
+                const isPublish = name.startsWith("publish:");
+                const root = isPublish ? exports.EVENT_TYPE_PUBLISH_ROOT : exports.EVENT_TYPE_ITEM_ROOT;
+                const path = `${root}/${name}`;
+                const id = await resolveItemIdByPath(path);
+                if (!id) {
+                    throw (0, errors_1.createScaiError)(`Unknown webhook event type '${name}'.`, "INPUT_INVALID", {
+                        hint: `Expected a catalog item at '${path}'. Check '/sitecore/system/Settings/Webhooks/Event Types' on the tenant for the correct event name.`,
+                    });
+                }
+                ids.push(id);
+            }
+            return ids;
+        },
+        resolveItemIdByPath,
+    };
+};
+exports.createWebhookTemplateResolver = createWebhookTemplateResolver;

package/dist/webhooks/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/webhooks`.
+ *
+ * Sitecore webhooks (event handlers + workflow submit/validation actions)
+ * authored against the Authoring GraphQL API. Surface mirrors the
+ * `scai content workflow webhook *` command tree.
+ */
+export { createWebhookApiClient, type WebhookApiClient, type WebhookClientOptions, type WebhookHandlerSummary, type WebhookHandlerDetail, type WebhookHandlerFieldsMap, type WebhookSerializationType, type CreateEventHandlerInput, type CreateWorkflowActionInput, type WebhookEventTypeCategory, type WebhookEventTypeSummary, DEFAULT_WEBHOOK_HANDLERS_ROOT, WEBHOOK_FIELD_DESCRIPTION, WEBHOOK_FIELD_URL, WEBHOOK_FIELD_EVENTS, WEBHOOK_FIELD_ENABLED, WEBHOOK_FIELD_AUTHORIZATION, WEBHOOK_FIELD_SERIALIZATION_TYPE, } from "./api/client";
+export { createWebhookTemplateResolver, type WebhookTemplateResolver, WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH, WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH, WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH, EVENT_TYPE_ITEM_ROOT, EVENT_TYPE_PUBLISH_ROOT, } from "./api/templates";
+export { runWebhookAuthoringGraphQL, type WebhookRequestOptions } from "./api/graphql";
+export { type WebhookTaskOptions, type ResolvedWebhookTenant, resolveWebhookTenant, toLogger, printWebhookResult, } from "./tasks/shared";
+export { runWebhookList, type WebhookListOptions, type WebhookListResult, type WebhookEventCategory, } from "./tasks/list";
+export { runWebhookInspect, parseWebhookRef, type WebhookInspectOptions } from "./tasks/inspect";
+export { runWebhookCreate, type WebhookCreateOptions, type WebhookCreateResult, } from "./tasks/create";
+export { runWebhookDelete, type WebhookDeleteOptions, type WebhookDeleteResult, } from "./tasks/delete";
+export { runWebhookEventTypes, type WebhookEventTypesOptions, type WebhookEventTypesResult, } from "./tasks/event-types";

package/dist/webhooks/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Public entry for `@sitecoreai-labs/sitecoreai-cli/webhooks`.
+ *
+ * Sitecore webhooks (event handlers + workflow submit/validation actions)
+ * authored against the Authoring GraphQL API. Surface mirrors the
+ * `scai content workflow webhook *` command tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWebhookEventTypes = exports.runWebhookDelete = exports.runWebhookCreate = exports.parseWebhookRef = exports.runWebhookInspect = exports.runWebhookList = exports.printWebhookResult = exports.toLogger = exports.resolveWebhookTenant = exports.runWebhookAuthoringGraphQL = exports.EVENT_TYPE_PUBLISH_ROOT = exports.EVENT_TYPE_ITEM_ROOT = exports.WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH = exports.WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH = exports.WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH = exports.createWebhookTemplateResolver = exports.WEBHOOK_FIELD_SERIALIZATION_TYPE = exports.WEBHOOK_FIELD_AUTHORIZATION = exports.WEBHOOK_FIELD_ENABLED = exports.WEBHOOK_FIELD_EVENTS = exports.WEBHOOK_FIELD_URL = exports.WEBHOOK_FIELD_DESCRIPTION = exports.DEFAULT_WEBHOOK_HANDLERS_ROOT = exports.createWebhookApiClient = void 0;
+var client_1 = require("./api/client");
+Object.defineProperty(exports, "createWebhookApiClient", { enumerable: true, get: function () { return client_1.createWebhookApiClient; } });
+Object.defineProperty(exports, "DEFAULT_WEBHOOK_HANDLERS_ROOT", { enumerable: true, get: function () { return client_1.DEFAULT_WEBHOOK_HANDLERS_ROOT; } });
+Object.defineProperty(exports, "WEBHOOK_FIELD_DESCRIPTION", { enumerable: true, get: function () { return client_1.WEBHOOK_FIELD_DESCRIPTION; } });
+Object.defineProperty(exports, "WEBHOOK_FIELD_URL", { enumerable: true, get: function () { return client_1.WEBHOOK_FIELD_URL; } });
+Object.defineProperty(exports, "WEBHOOK_FIELD_EVENTS", { enumerable: true, get: function () { return client_1.WEBHOOK_FIELD_EVENTS; } });
+Object.defineProperty(exports, "WEBHOOK_FIELD_ENABLED", { enumerable: true, get: function () { return client_1.WEBHOOK_FIELD_ENABLED; } });
+Object.defineProperty(exports, "WEBHOOK_FIELD_AUTHORIZATION", { enumerable: true, get: function () { return client_1.WEBHOOK_FIELD_AUTHORIZATION; } });
+Object.defineProperty(exports, "WEBHOOK_FIELD_SERIALIZATION_TYPE", { enumerable: true, get: function () { return client_1.WEBHOOK_FIELD_SERIALIZATION_TYPE; } });
+var templates_1 = require("./api/templates");
+Object.defineProperty(exports, "createWebhookTemplateResolver", { enumerable: true, get: function () { return templates_1.createWebhookTemplateResolver; } });
+Object.defineProperty(exports, "WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH", { enumerable: true, get: function () { return templates_1.WEBHOOK_EVENT_HANDLER_TEMPLATE_PATH; } });
+Object.defineProperty(exports, "WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH", { enumerable: true, get: function () { return templates_1.WEBHOOK_SUBMIT_ACTION_TEMPLATE_PATH; } });
+Object.defineProperty(exports, "WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH", { enumerable: true, get: function () { return templates_1.WEBHOOK_VALIDATION_ACTION_TEMPLATE_PATH; } });
+Object.defineProperty(exports, "EVENT_TYPE_ITEM_ROOT", { enumerable: true, get: function () { return templates_1.EVENT_TYPE_ITEM_ROOT; } });
+Object.defineProperty(exports, "EVENT_TYPE_PUBLISH_ROOT", { enumerable: true, get: function () { return templates_1.EVENT_TYPE_PUBLISH_ROOT; } });
+var graphql_1 = require("./api/graphql");
+Object.defineProperty(exports, "runWebhookAuthoringGraphQL", { enumerable: true, get: function () { return graphql_1.runWebhookAuthoringGraphQL; } });
+var shared_1 = require("./tasks/shared");
+Object.defineProperty(exports, "resolveWebhookTenant", { enumerable: true, get: function () { return shared_1.resolveWebhookTenant; } });
+Object.defineProperty(exports, "toLogger", { enumerable: true, get: function () { return shared_1.toLogger; } });
+Object.defineProperty(exports, "printWebhookResult", { enumerable: true, get: function () { return shared_1.printWebhookResult; } });
+var list_1 = require("./tasks/list");
+Object.defineProperty(exports, "runWebhookList", { enumerable: true, get: function () { return list_1.runWebhookList; } });
+var inspect_1 = require("./tasks/inspect");
+Object.defineProperty(exports, "runWebhookInspect", { enumerable: true, get: function () { return inspect_1.runWebhookInspect; } });
+Object.defineProperty(exports, "parseWebhookRef", { enumerable: true, get: function () { return inspect_1.parseWebhookRef; } });
+var create_1 = require("./tasks/create");
+Object.defineProperty(exports, "runWebhookCreate", { enumerable: true, get: function () { return create_1.runWebhookCreate; } });
+var delete_1 = require("./tasks/delete");
+Object.defineProperty(exports, "runWebhookDelete", { enumerable: true, get: function () { return delete_1.runWebhookDelete; } });
+var event_types_1 = require("./tasks/event-types");
+Object.defineProperty(exports, "runWebhookEventTypes", { enumerable: true, get: function () { return event_types_1.runWebhookEventTypes; } });

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

@@ -0,0 +1,58 @@
+import type { WebhookHandlerSummary, WebhookSerializationType } from "../api/client";
+import { type WebhookTaskOptions } from "./shared";
+/**
+ * Three flavors:
+ *
+ *   - `item` / `publish` — create a Webhook Event Handler under
+ *     `/sitecore/system/Webhooks` (or `--parent-path`). Use `--event`
+ *     one or more times to pick event-type catalog entries.
+ *   - `workflow` — create a Webhook Submit Action or Validation Action
+ *     under a workflow state's (or command's) `Actions` folder. Use
+ *     `--on-state` (or `--on-command`) to point at the parent; pick
+ *     `--action submit|validation`.
+ */
+export interface WebhookCreateOptions extends WebhookTaskOptions {
+    /** Item name for the new handler. */
+    name: string;
+    url: string;
+    /** Discriminator. */
+    event: "item" | "publish" | "workflow";
+    /**
+     * Event-type names (e.g. `item:saved`, `publish:end`). Required for
+     * the `item` and `publish` event flavors; ignored for `workflow`.
+     * Can be a comma-separated string or repeated occurrences.
+     */
+    events?: string[];
+    /**
+     * For workflow webhooks — absolute path to the workflow state or
+     * command under which the action item is created (i.e.
+     * `/sitecore/system/Workflows/My Workflow/Draft` or `.../Submit`).
+     */
+    onState?: string;
+    /** For workflow webhooks — `submit` (default) or `validation`. */
+    action?: "submit" | "validation";
+    description?: string;
+    /** Optional absolute path to an Authorization item. */
+    authorization?: string;
+    serializationType?: WebhookSerializationType;
+    /** Override parent path for item/publish handlers. */
+    parentPath?: string;
+    /** Per-invocation override of the env's `allowWrite` flag. */
+    allowWrite?: boolean;
+    /** Plan-only — no mutation. */
+    whatIf?: boolean;
+    enabled?: boolean;
+}
+export interface WebhookCreateResult {
+    status: "created" | "what-if";
+    handler: WebhookHandlerSummary | null;
+    plan: {
+        flavor: "item" | "publish" | "workflow";
+        name: string;
+        url: string;
+        events?: string[];
+        workflowAction?: "submit" | "validation";
+        parent: string;
+    };
+}
+export declare const runWebhookCreate: (options: WebhookCreateOptions) => Promise<WebhookCreateResult>;