@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/publishing/tasks/item.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPublishItem = void 0;
+const logger_1 = require("../../shared/logger");
+const errors_1 = require("../../shared/errors");
+const environment_1 = require("../../policy/environment");
+const prompt_1 = require("../../shared/prompt");
+const auth_1 = require("../api/auth");
+const client_1 = require("../api/client");
+const path_resolver_1 = require("../api/path-resolver");
+const languages_1 = require("../api/languages");
+const sites_1 = require("../api/sites");
+const env_tier_1 = require("../../shared/env-tier");
+const publish_consent_1 = require("../../shared/publish-consent");
+const publish_audit_1 = require("../../shared/publish-audit");
+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);
+const printScope = (logger, scope) => {
+    logger.info(`Environment:   ${scope.envName}`, "cyan");
+    if (scope.resolvedTenantId) {
+        logger.info(`Tenant:        ${scope.resolvedTenantId}`, "gray");
+    }
+    logger.info(`Target:        ${scope.target}`, "gray");
+    logger.info(`Kind:          ${scope.kind}`, "gray");
+    if (scope.itemIds && scope.itemIds.length > 0) {
+        logger.info(`Item IDs:      ${scope.itemIds.join(", ")}`, "gray");
+    }
+    if (scope.path) {
+        logger.info(`Path:          ${scope.path}`, "gray");
+    }
+    logger.info(`Languages:     ${scope.languages?.join(", ") ?? "(default)"}`, "gray");
+    logger.info(`Include subs:  ${Boolean(scope.includeSubitems)}`, "gray");
+    logger.info(`Include rel.:  ${Boolean(scope.includeRelated)}`, "gray");
+};
+const runPublishItem = async (options) => {
+    const logger = toLogger(options);
+    const directItemIds = options.itemIds ?? [];
+    const paths = options.paths ?? [];
+    if (directItemIds.length === 0 && paths.length === 0 && !options.site) {
+        throw (0, errors_1.createScaiError)("Publish requires at least one --items <guid>, --paths <path>, or --site <name>.", "INPUT_INVALID", {
+            hint: "Pass --items <guid> (repeatable), --paths <path> (repeatable), and/or --site <name>. --site resolves the site's content-tree root via Sites API; add --include-subitems for the whole site.",
+        });
+    }
+    const { envName, environment, timeoutMs } = (0, environment_1.resolveEnvironment)(options);
+    const itemType = options.itemType ?? "item";
+    const target = "Edge";
+    const mode = options.mode ?? "Smart";
+    const languages = await (0, languages_1.resolvePublishingLocales)(logger, environment, options);
+    // Resolve paths → IDs up front so the dry-run scope (and the scope
+    // hash) reflects the actual items the API will see. Resolution
+    // errors fail the whole call before any publish-API write.
+    let resolvedFromPaths = [];
+    if (paths.length > 0) {
+        logger.info(`Resolving ${paths.length} path(s) via Authoring GraphQL...`, "gray");
+        const result = await (0, path_resolver_1.resolveItemPathsToIds)(environment, paths);
+        resolvedFromPaths = result.resolved;
+        for (const r of resolvedFromPaths) {
+            logger.info(`  ${r.path} → ${r.itemId}`, "gray");
+        }
+    }
+    // Site root resolution. Two round trips per call (discoverSites +
+    // resolveItemPathsToIds). Added to the target list; --include-subitems
+    // controls whether descendants come along.
+    let resolvedSite;
+    if (options.site) {
+        logger.info(`Resolving site '${options.site}' root via Sites + Authoring GraphQL...`, "gray");
+        resolvedSite = await (0, sites_1.resolveSiteRoot)(environment, options.site);
+        logger.info(`  → ${resolvedSite.path} (${resolvedSite.itemId})`, "gray");
+        if (!options.includeSubitems) {
+            logger.info(`Publishing only the site root item. Pass --include-subitems for the whole site.`, "gray");
+        }
+    }
+    const itemIds = [
+        ...directItemIds,
+        ...resolvedFromPaths.map((r) => r.itemId),
+        ...(resolvedSite ? [resolvedSite.itemId] : []),
+    ];
+    const scope = {
+        envName,
+        resolvedTenantId: environment.tenantId,
+        target,
+        kind: "item",
+        itemIds,
+        languages,
+        includeSubitems: options.includeSubitems,
+        includeRelated: options.includeRelated,
+    };
+    const scopeHash = (0, publish_consent_1.computeScopeHash)(scope);
+    // Default whatIf=true. Operator must pass --allow-write to actually
+    // call the API. Same pattern as scai hygiene cleanup versions prune.
+    const whatIf = options.allowWrite ? Boolean(options.whatIf) : true;
+    const productionTier = (0, env_tier_1.isProductionTier)(environment);
+    if (whatIf) {
+        // Dry-run path — print the scope, mint a scope token, exit.
+        logger.info(`What-if: would publish ${itemIds.length} item(s) to ${target}.`, "yellow");
+        printScope(logger, scope);
+        const token = (0, publish_consent_1.mintScopeToken)(scope);
+        logger.info("", "gray");
+        if (productionTier) {
+            logger.info(`Production-tier env. Real call requires --allow-write AND --confirm-token.`, "yellow");
+        }
+        logger.info(`Scope token (TTL ${publish_consent_1.SCOPE_TOKEN_TTL_MS / 1000}s):`, "gray");
+        process.stdout.write(`${token}\n`);
+        logger.info("", "gray");
+        logger.info(`To execute: rerun with --allow-write${productionTier ? ` --confirm-token ${token}` : ""}`, "gray");
+        return;
+    }
+    // Real call from here on. Layer the safety checks.
+    if (productionTier) {
+        if (!options.confirmToken) {
+            throw (0, errors_1.createScaiError)(`Production-tier env '${envName}' requires --confirm-token.`, "INPUT_INVALID", {
+                hint: "Run the same command without --allow-write to get a scope token, then pass it back as --confirm-token <token>.",
+            });
+        }
+        const verification = (0, publish_consent_1.verifyScopeToken)(options.confirmToken, scope);
+        if (!verification.ok) {
+            throw (0, errors_1.createScaiError)(`Scope token rejected (${verification.reason}).`, "INPUT_INVALID", {
+                hint: `Re-run the dry-run to mint a fresh token; the scope or env may have changed since the token was issued.`,
+            });
+        }
+    }
+    else if (!options.yes) {
+        if (options.nonInteractive) {
+            throw (0, errors_1.createScaiError)("Non-interactive mode requires --yes (or --confirm-token on prod envs).", "INPUT_INVALID");
+        }
+        logger.info(`About to publish ${itemIds.length} item(s) to ${target} in env '${envName}'.`, "yellow");
+        printScope(logger, scope);
+        const ok = await (0, prompt_1.promptConfirm)("Proceed with publish?", false);
+        if (!ok) {
+            logger.info("Aborted.", "yellow");
+            return;
+        }
+    }
+    const accessToken = await (0, auth_1.acquirePublishingToken)({ envName, environment });
+    const client = { accessToken, timeoutMs };
+    const caller = { type: "human", via: "cli" };
+    const defaultName = itemIds.length === 1
+        ? `scai content publish item ${itemIds[0]} (${envName})`
+        : `scai content publish ${itemIds.length} items (${envName})`;
+    const request = {
+        name: options.name ?? defaultName,
+        source: options.source ?? "scai",
+        options: {
+            // One ItemModel per requested id. `locale` left undefined so the
+            // top-level `xmc.locales` controls the language set for the whole
+            // batch; callers needing per-item locale targeting can use the
+            // lower-level `submitPublishJob` API directly.
+            items: itemIds.map((id) => ({ id, type: itemType })),
+            xmc: {
+                locales: languages.length > 0 ? languages : undefined,
+                items: {
+                    mode,
+                    publishChildren: options.includeSubitems,
+                    publishRelatedItems: options.includeRelated,
+                },
+            },
+        },
+    };
+    try {
+        const job = await (0, client_1.submitPublishJob)(client, request);
+        (0, publish_audit_1.recordPublishAudit)({
+            ts: new Date().toISOString(),
+            command: "publish item",
+            caller,
+            scope,
+            risk: "normal",
+            scopeHash,
+            scopeToken: options.confirmToken,
+            jobId: job.id,
+            outcome: "ok",
+        });
+        if (logger.isJson()) {
+            process.stdout.write(`${JSON.stringify(job, null, 2)}\n`);
+            return;
+        }
+        logger.info(`Submitted publish job ${job.id} (${job.state}).`, "green");
+        logger.info(`Track with: scai content publish status ${job.id} -n ${envName}`, "gray");
+    }
+    catch (err) {
+        (0, publish_audit_1.recordPublishAudit)({
+            ts: new Date().toISOString(),
+            command: "publish item",
+            caller,
+            scope,
+            risk: "normal",
+            scopeHash,
+            scopeToken: options.confirmToken,
+            outcome: "error",
+            errorCode: err instanceof Error && "code" in err ? String(err.code) : "UNKNOWN",
+            errorMessage: err instanceof Error ? err.message : String(err),
+        });
+        throw err;
+    }
+};
+exports.runPublishItem = runPublishItem;

package/dist/publishing/tasks/status.d.ts

@@ -0,0 +1,17 @@
+export interface RunPublishStatusOptions {
+    config?: string;
+    environmentName?: string;
+    jobId?: string;
+    /** Poll until the job reaches a terminal state. Requires a jobId. */
+    watch?: boolean;
+    /** Poll interval in seconds. Clamped to [2, 60]. Default 5. */
+    pollIntervalS?: number;
+    /** Hard timeout for --watch in seconds. Default 1800 (30 min). */
+    timeoutS?: number;
+    verbose?: boolean;
+    trace?: boolean;
+    quiet?: boolean;
+    json?: boolean;
+    logFile?: string;
+}
+export declare const runPublishStatus: (options: RunPublishStatusOptions) => Promise<void>;

package/dist/publishing/tasks/status.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPublishStatus = void 0;
+const logger_1 = require("../../shared/logger");
+const environment_1 = require("../../policy/environment");
+const errors_1 = require("../../shared/errors");
+const auth_1 = require("../api/auth");
+const client_1 = require("../api/client");
+const job_watcher_1 = require("../job-watcher");
+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);
+const formatJobLine = (job) => {
+    const parts = [job.id, job.state];
+    if (job.processedCount !== undefined) {
+        parts.push(`${job.processedCount} processed`);
+    }
+    if (job.startedAt) {
+        parts.push(`started ${job.startedAt}`);
+    }
+    return parts.join("  ");
+};
+const runPublishStatus = async (options) => {
+    const logger = toLogger(options);
+    if (options.watch && !options.jobId) {
+        throw (0, errors_1.createScaiError)("--watch requires a <jobId> argument.", "INPUT_INVALID", {
+            hint: "Run `scai content publish status <jobId> --watch` against a specific job.",
+        });
+    }
+    const { envName, environment, timeoutMs } = (0, environment_1.resolveEnvironment)(options);
+    const accessToken = await (0, auth_1.acquirePublishingToken)({ envName, environment });
+    const client = {
+        accessToken,
+        timeoutMs,
+    };
+    if (options.jobId) {
+        if (options.watch) {
+            const pollIntervalS = (0, job_watcher_1.clampPollInterval)(options.pollIntervalS);
+            const timeoutS = options.timeoutS ?? job_watcher_1.DEFAULT_WATCH_TIMEOUT_S;
+            const job = await (0, job_watcher_1.watchPublishJob)(logger, client, options.jobId, pollIntervalS, timeoutS);
+            if (logger.isJson()) {
+                process.stdout.write(`${JSON.stringify({ terminal: true, ...job }, null, 2)}\n`);
+            }
+            else {
+                (0, job_watcher_1.printJobSummary)(logger, job);
+            }
+            (0, job_watcher_1.throwOnTerminalFailure)(job);
+            return;
+        }
+        const job = await (0, client_1.getPublishJob)(client, options.jobId);
+        if (logger.isJson()) {
+            // stdout is reserved for the JSON payload when --json is set;
+            // logger.info() suppresses output in json mode.
+            process.stdout.write(`${JSON.stringify(job, null, 2)}\n`);
+            return;
+        }
+        (0, job_watcher_1.printJobSummary)(logger, job);
+        return;
+    }
+    const running = await (0, client_1.listPublishJobs)(client, {
+        statuses: ["Queued", "Running"],
+    });
+    if (logger.isJson()) {
+        process.stdout.write(`${JSON.stringify(running, null, 2)}\n`);
+        return;
+    }
+    if (running.length === 0) {
+        logger.info(`No publish jobs queued or running in environment '${envName}'.`, "yellow");
+        return;
+    }
+    logger.info(`Running publish jobs in '${envName}':`, "cyan");
+    for (const job of running) {
+        logger.info(`  ${formatJobLine(job)}`);
+    }
+};
+exports.runPublishStatus = runPublishStatus;

package/dist/publishing/tasks/unpublish.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `scai content publish unpublish` — composite verb.
+ *
+ * The SAI Publishing API has no per-version unpublish operation. The
+ * Sitecore-canonical mechanism is to change the item's publish-state
+ * fields via the Authoring API (so the next publish doesn't pick them
+ * up — or, for already-published items, the next publish removes them
+ * from Edge) and then submit a regular publish job.
+ *
+ * Three strategies:
+ *
+ *   - `never-publish` (default, reversible) — sets `__Never publish: true`
+ *     on the latest version per requested language. Reverse by writing
+ *     `__Never publish: false` (e.g. `scai content version
+ *     set-never-publish --value false`) and republishing.
+ *   - `expire-now` (reversible)             — sets `__Valid to: <now>`
+ *     on each targeted version. Reverse by writing `__Valid to` to a
+ *     future date.
+ *   - `delete` (destructive, NOT reversible from scai's side) — not yet
+ *     implemented; surfaces a clear error message.
+ *
+ * Safety model reuses the four PR 2b primitives: dry-run default,
+ * scope-token verification on production-tier envs, `--allow-write`
+ * to graduate from dry-run, audit log every mutation with before/after
+ * captures so an operator can reverse a mistaken toggle by reading the
+ * log.
+ */
+import { type UnpublishStrategy } from "../../shared/publish-audit";
+export interface RunPublishUnpublishOptions {
+    config?: string;
+    environmentName?: string;
+    itemIds?: string[];
+    paths?: string[];
+    /** Site name. Resolves to the site's content-tree root via Sites
+     *  API + Authoring GraphQL. Combine with `--include-subitems` to
+     *  unpublish the whole site. */
+    site?: string;
+    /** Literal language list. See `PublishLocaleOptions`. */
+    languages?: string[];
+    /** Resolve languages from the named site via Sites API. */
+    languagesFromSite?: string;
+    /** Resolve languages from the tenant-wide registered set. */
+    allTenantLanguages?: boolean;
+    includeSubitems?: boolean;
+    includeRelated?: boolean;
+    /** Defaults to `"never-publish"`. */
+    strategy?: UnpublishStrategy;
+    /**
+     * For `--strategy delete` on production-tier envs: the operator
+     *  must echo the item path back literally before scai will call
+     *  `deleteItem`. The CLI prompts interactively when unset; CI must
+     *  supply this matching the resolved item path. (Mirrors `publish
+     *  all`'s typed env-name gate, scaled per-item.)
+     */
+    confirmItemPath?: string;
+    whatIf?: boolean;
+    allowWrite?: boolean;
+    confirmToken?: string;
+    yes?: boolean;
+    name?: string;
+    source?: string;
+    verbose?: boolean;
+    trace?: boolean;
+    quiet?: boolean;
+    json?: boolean;
+    logFile?: string;
+    nonInteractive?: boolean;
+}
+export declare const runPublishUnpublish: (options: RunPublishUnpublishOptions) => Promise<void>;