@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/commands/policy.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * `scai policy …` — inspect and manage the workspace environment-policy
+ * guardrails. See docs/policy-and-guardrails.md.
+ *
+ * The workspace policy is an operator-owned, deny-by-default allowlist of
+ * the Sitecore environments scai may operate against. It is normally
+ * auto-populated (`scai setup login`, `scai mcp serve`); these commands
+ * are for inspecting it and for the deliberate acts — enrolling a second
+ * environment, re-pinning after a legitimate tenant change, revoking one.
+ *
+ * These commands deliberately read the config directly rather than going
+ * through `resolveEnvironment`: they run before/around enrollment and
+ * must not trip the very gate they manage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolicyCommand = void 0;
+const commander_1 = require("commander");
+const shared_1 = require("./shared");
+const cli_tasks_1 = require("../shared/cli-tasks");
+const root_config_1 = require("../config/root-config");
+const errors_1 = require("../shared/errors");
+const policy_1 = require("../policy");
+const POLICY_WRITE_FAILED_HINT = "Check that ~/.sitecoreai is writable, or set SITECOREAI_POLICY_HOME.";
+/**
+ * Resolve an env profile's raw config without going through
+ * `resolveEnvironment` (which would enforce the policy).
+ */
+const resolveEnvProfile = (options, envNameArg) => {
+    const configPath = options.config ?? process.cwd();
+    const file = (0, root_config_1.readRootConfigurationFile)(configPath);
+    const envName = envNameArg ?? options.environmentName ?? file.config.defaultEnvProfile;
+    if (!envName) {
+        throw (0, errors_1.createScaiError)("An environment name is required.", "INPUT_INVALID", {
+            hint: "Pass the environment name, or set defaultEnvProfile in sitecoreai.cli.json.",
+        });
+    }
+    const environment = (0, root_config_1.readRootConfiguration)(configPath, envName).environments[envName];
+    if (!environment) {
+        throw (0, errors_1.createScaiError)(`Environment '${envName}' is not configured.`, "ENV_NOT_FOUND", {
+            hint: "Run 'scai setup init' to configure it before enrolling it in the policy.",
+        });
+    }
+    return { envName, environment };
+};
+const runPolicyShow = async (options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const policy = (0, policy_1.readWorkspacePolicy)();
+    const policyPath = (0, policy_1.resolveUserPolicyPath)();
+    let repoPolicy = null;
+    try {
+        const rootDir = (0, root_config_1.readRootConfigurationFile)(options.config ?? process.cwd()).rootDir;
+        repoPolicy = (0, policy_1.readRepoPolicy)(rootDir);
+    }
+    catch {
+        // No config file resolvable from here — the repo policy is simply absent.
+    }
+    if (logger.isJson()) {
+        logger.json({
+            managed: policy !== null,
+            policyPath,
+            environments: policy
+                ? Object.entries(policy.environments).map(([name, entry]) => ({ name, ...entry }))
+                : [],
+            repoPolicy,
+        });
+        return;
+    }
+    if (!policy) {
+        logger.info("Workspace policy: unmanaged — no policy file.", "yellow");
+        logger.info("Environment guardrails are off. Run 'scai policy init' (or 'scai setup login') to enable them.");
+        return;
+    }
+    logger.info(`Workspace policy: ${policyPath}`, "cyan");
+    const names = Object.keys(policy.environments).sort((a, b) => a.localeCompare(b));
+    if (names.length === 0) {
+        logger.warn("No environments are enrolled — every environment is currently denied.");
+    }
+    for (const name of names) {
+        const entry = policy.environments[name];
+        const id = entry.identity;
+        const idParts = [
+            id.organizationId && `org=${id.organizationId}`,
+            id.projectId && `project=${id.projectId}`,
+            id.environmentId && `environment=${id.environmentId}`,
+            id.host && `host=${id.host}`,
+        ].filter(Boolean);
+        logger.info(`\n  ${name}`, "green");
+        logger.info(`    ceiling:  ${entry.ceiling}`);
+        logger.info(`    mint:     ${entry.mintCredentials ? "allowed" : "denied"}`);
+        logger.info(`    ciWrites: ${entry.ciWrites ? "allowed" : "denied"}`);
+        logger.info(`    step-up:  ${entry.stepUpMinutes ? `${entry.stepUpMinutes} min` : "off"}`);
+        logger.info(`    enrolled: ${entry.enrolledAt} (via ${entry.enrolledVia})`);
+        logger.info(`    identity: ${idParts.length > 0 ? idParts.join(", ") : "(none pinned)"}`);
+    }
+    if (repoPolicy) {
+        logger.info("\n  repo policy (scai.policy.json) is narrowing this workspace:", "magenta");
+        if (repoPolicy.allowEnvironments) {
+            logger.info(`    allowEnvironments: ${repoPolicy.allowEnvironments.join(", ")}`);
+        }
+        for (const [name, entry] of Object.entries(repoPolicy.environments ?? {})) {
+            if (entry.ceiling) {
+                logger.info(`    ${name}: ceiling lowered to ${entry.ceiling}`);
+            }
+        }
+    }
+};
+const runPolicyInit = async (options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const wasManaged = (0, policy_1.readWorkspacePolicy)() !== null;
+    const { envName, environment } = resolveEnvProfile(options);
+    const result = (0, policy_1.enrollEnvironment)({ envName, environment, via: "policy-init" });
+    if (!result.written) {
+        throw (0, errors_1.createScaiError)("Could not write the workspace policy.", "CONFIG_INVALID", {
+            hint: POLICY_WRITE_FAILED_HINT,
+        });
+    }
+    if (logger.isJson()) {
+        logger.json({ envName, created: !wasManaged, policyPath: (0, policy_1.resolveUserPolicyPath)() });
+        return;
+    }
+    if (!wasManaged) {
+        logger.info(`Workspace policy created at ${(0, policy_1.resolveUserPolicyPath)()}.`, "cyan");
+    }
+    logger.info(`Environment '${envName}' enrolled — guardrails are active.`, "green");
+};
+const runPolicyAllow = async (envNameArg, options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const { envName, environment } = resolveEnvProfile(options, envNameArg);
+    const result = (0, policy_1.enrollEnvironment)({ envName, environment, via: "policy-allow" });
+    if (!result.written) {
+        throw (0, errors_1.createScaiError)("Could not write the workspace policy.", "CONFIG_INVALID", {
+            hint: POLICY_WRITE_FAILED_HINT,
+        });
+    }
+    const action = result.alreadyEnrolled ? "refreshed" : "enrolled";
+    if (logger.isJson()) {
+        logger.json({ envName, action });
+        return;
+    }
+    logger.info(`Environment '${envName}' ${action} in the workspace policy.`, "green");
+};
+const runPolicyRemove = async (envNameArg, options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const configPath = options.config ?? process.cwd();
+    const envName = envNameArg ??
+        options.environmentName ??
+        (0, root_config_1.readRootConfigurationFile)(configPath).config.defaultEnvProfile;
+    if (!envName) {
+        throw (0, errors_1.createScaiError)("An environment name is required.", "INPUT_INVALID", {
+            hint: "Pass the environment name to remove from the allowlist.",
+        });
+    }
+    const removed = (0, policy_1.unenrollEnvironment)(envName);
+    if (logger.isJson()) {
+        logger.json({ envName, action: removed ? "removed" : "not-enrolled" });
+        return;
+    }
+    if (removed) {
+        logger.info(`Environment '${envName}' removed from the workspace policy.`, "green");
+    }
+    else {
+        logger.warn(`Environment '${envName}' was not enrolled — nothing to remove.`);
+    }
+};
+const runPolicyTrust = async (envNameArg, options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const { envName, environment } = resolveEnvProfile(options, envNameArg);
+    const policy = (0, policy_1.readWorkspacePolicy)();
+    if (!policy || !policy.environments[envName]) {
+        throw (0, errors_1.createScaiError)(`Environment '${envName}' is not enrolled in the workspace policy.`, "POLICY_DENIED", { hint: `Run 'scai policy allow ${envName}' to enroll it first.` });
+    }
+    (0, policy_1.repinEnvironment)(envName, environment);
+    if (logger.isJson()) {
+        logger.json({ envName, action: "re-pinned" });
+        return;
+    }
+    logger.info(`Environment '${envName}' identity re-pinned to the current sitecoreai.cli.json.`, "green");
+};
+const runPolicySet = async (envNameArg, options) => {
+    const logger = (0, cli_tasks_1.toLogger)(options);
+    const configPath = options.config ?? process.cwd();
+    const envName = envNameArg ??
+        options.environmentName ??
+        (0, root_config_1.readRootConfigurationFile)(configPath).config.defaultEnvProfile;
+    if (!envName) {
+        throw (0, errors_1.createScaiError)("An environment name is required.", "INPUT_INVALID", {
+            hint: "Pass the environment name to tune.",
+        });
+    }
+    const flags = {};
+    if (options.ceiling) {
+        flags.ceiling = options.ceiling;
+    }
+    if (options.ciWrites) {
+        flags.ciWrites = options.ciWrites === "on";
+    }
+    if (options.mint) {
+        flags.mintCredentials = options.mint === "on";
+    }
+    if (options.stepUp) {
+        if (options.stepUp.toLowerCase() === "off") {
+            flags.stepUpMinutes = null;
+        }
+        else {
+            const minutes = Number(options.stepUp);
+            if (!Number.isInteger(minutes) || minutes <= 0) {
+                throw (0, errors_1.createScaiError)("--step-up must be a positive whole number of minutes, or 'off'.", "INPUT_INVALID", { hint: "Example: scai policy set prod --step-up 60" });
+            }
+            flags.stepUpMinutes = minutes;
+        }
+    }
+    if (Object.keys(flags).length === 0) {
+        throw (0, errors_1.createScaiError)("Nothing to change.", "INPUT_INVALID", {
+            hint: "Pass at least one of --ceiling, --ci-writes, or --mint.",
+        });
+    }
+    const updated = (0, policy_1.setEnvironmentFlags)(envName, flags);
+    if (!updated) {
+        throw (0, errors_1.createScaiError)(`Environment '${envName}' is not enrolled in the workspace policy.`, "POLICY_DENIED", { hint: `Run 'scai policy allow ${envName}' to enroll it first.` });
+    }
+    if (logger.isJson()) {
+        logger.json({ envName, ...flags });
+        return;
+    }
+    logger.info(`Updated the workspace policy for '${envName}'.`, "green");
+};
+const createPolicyCommand = () => {
+    const command = new commander_1.Command("policy").description("Inspect and manage the workspace environment-policy guardrails — the allowlist of Sitecore environments scai may operate against.");
+    const show = new commander_1.Command("show").description("Show the effective workspace policy and the enrolled environments.");
+    (0, shared_1.addConfigOption)(show);
+    (0, shared_1.addVerbosityOptions)(show);
+    show.action(async (options) => runPolicyShow(options));
+    const init = new commander_1.Command("init").description("Create the workspace policy, enrolling the default environment.");
+    (0, shared_1.addConfigOption)(init);
+    (0, shared_1.addEnvironmentOption)(init);
+    (0, shared_1.addVerbosityOptions)(init);
+    init.action(async (options) => runPolicyInit(options));
+    const allow = new commander_1.Command("allow")
+        .description("Enroll an environment into the workspace-policy allowlist.")
+        .argument("[env]", "Environment profile name (defaults to the configured default).");
+    (0, shared_1.addConfigOption)(allow);
+    (0, shared_1.addVerbosityOptions)(allow);
+    allow.action(async (env, options) => runPolicyAllow(env, options));
+    const remove = new commander_1.Command("remove")
+        .aliases(["rm"])
+        .description("Remove an environment from the workspace-policy allowlist.")
+        .argument("[env]", "Environment profile name (defaults to the configured default).");
+    (0, shared_1.addConfigOption)(remove);
+    (0, shared_1.addVerbosityOptions)(remove);
+    remove.action(async (env, options) => runPolicyRemove(env, options));
+    const trust = new commander_1.Command("trust")
+        .description("Re-pin an enrolled environment's tenant identity to the current config, after a legitimate change.")
+        .argument("[env]", "Environment profile name (defaults to the configured default).");
+    (0, shared_1.addConfigOption)(trust);
+    (0, shared_1.addVerbosityOptions)(trust);
+    trust.action(async (env, options) => runPolicyTrust(env, options));
+    const set = new commander_1.Command("set")
+        .description("Tune an enrolled environment — ceiling, CI-write permission, mint eligibility.")
+        .argument("[env]", "Environment profile name (defaults to the configured default).")
+        .addOption(new commander_1.Option("--ceiling <tier>", "Cap the environment at this risk tier.").choices([
+        "read",
+        "write",
+        "destructive",
+        "mint",
+    ]))
+        .addOption(new commander_1.Option("--ci-writes <state>", "Allow or deny write/destructive operations from a CI caller.").choices(["on", "off"]))
+        .addOption(new commander_1.Option("--mint <state>", "Allow or deny `scai setup client create` minting on this environment.").choices(["on", "off"]))
+        .addOption(new commander_1.Option("--step-up <minutes>", "Require a deploy token authenticated within N minutes for destructive/mint ops; 'off' to clear."));
+    (0, shared_1.addConfigOption)(set);
+    (0, shared_1.addVerbosityOptions)(set);
+    set.action(async (env, options) => runPolicySet(env, options));
+    command.addCommand(show);
+    command.addCommand(init);
+    command.addCommand(allow);
+    command.addCommand(set);
+    command.addCommand(remove);
+    command.addCommand(trust);
+    command.addHelpText("after", [
+        "",
+        "The workspace policy is a deny-by-default allowlist of the environments",
+        "scai may operate against, kept at ~/.sitecoreai/policy.json. It is",
+        "normally auto-populated by 'scai setup login' and 'scai mcp serve' — a",
+        "second environment is the one thing that needs a deliberate 'allow'.",
+        "",
+        "Examples:",
+        "  $ scai policy show                  # what is allowed right now",
+        "  $ scai policy allow staging         # enroll a second environment",
+        "  $ scai policy set staging --ci-writes on   # let a CI caller write here",
+        "  $ scai policy trust staging         # re-pin after a legitimate tenant change",
+        "  $ scai policy remove staging        # revoke an environment",
+        "",
+    ].join("\n"));
+    return command;
+};
+exports.createPolicyCommand = createPolicyCommand;

package/dist/commands/publish/all.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishAllCommand: () => Command;

package/dist/commands/publish/all.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishAllCommand = void 0;
+const commander_1 = require("commander");
+const all_1 = require("../../publishing/tasks/all");
+const shared_1 = require("../shared");
+const createPublishAllCommand = () => {
+    const command = new commander_1.Command("all")
+        .description("Whole-environment republish to Edge (Tier 2). Publishes every item across every site in the environment — empirically verified against the API (the `xmc.site.mode` field is named for legacy XM reasons; there is no API surface to scope to a single site). To publish just one site's subtree, use `scai content publish item --site <name> --include-subitems`. MAXIMUM gating: always requires --confirm-token AND a typed env-name confirmation, regardless of whether the env is flagged production. Use sparingly — needed after big serialization pushes, rollbacks, or migrations where Edge has drifted from CM.")
+        .option("-l, --languages <list>", "Literal language list. Mutually exclusive with --languages-from-site / --all-tenant-languages.", (value) => value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean), [])
+        .option("--languages-from-site <name>", "Resolve locales from the named site (Sites API). NOTE: the publish is still whole-environment — this flag scopes locales only, not items.")
+        .option("--all-tenant-languages", "Resolve locales to every language registered in the tenant.")
+        .addOption(new commander_1.Option("--mode <mode>", "Whole-environment publish mode")
+        .choices(["Republish", "Smart", "Incremental"])
+        .default("Republish"))
+        .option("--confirm-token <token>", "Scope token from a previous dry-run. Always required for the real call.")
+        .option("--yes", "Skip the typed env-name prompt (CI use). Still requires --confirm-token.")
+        .option("--no-wait", "In --non-interactive mode (default behavior is to watch), don't wait for the job to finish — submit and exit. The submitted jobId is logged so CI can poll later.")
+        .addOption(new commander_1.Option("--poll-interval-s <seconds>", "Polling interval when watching in non-interactive mode (default 5, clamped to [2, 60]).").argParser((v) => Number.parseInt(v, 10)))
+        .addOption(new commander_1.Option("--timeout-s <seconds>", "Watch timeout in seconds when waiting on the job in non-interactive mode (default 1800).").argParser((v) => Number.parseInt(v, 10)))
+        .addOption(new commander_1.Option("--name <name>", "Override the API job name."))
+        .addOption(new commander_1.Option("--source <source>", "Override the API source field. Default `scai`."));
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    (0, shared_1.addAllowWriteOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addHelpText("after", "\nFlow (always two steps, no shortcut even on sandbox):\n" +
+        "  1. Dry-run: scai content publish all -n <env>\n" +
+        "     → prints scope summary + a 5-minute scope token\n" +
+        "  2. Real call: scai content publish all -n <env> --allow-write --confirm-token <token>\n" +
+        "     → prompts to type the env name verbatim (skippable with --yes for CI)\n");
+    command.action(async (options) => {
+        await (0, all_1.runPublishAll)(options);
+    });
+    return command;
+};
+exports.createPublishAllCommand = createPublishAllCommand;

package/dist/commands/publish/cancel.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishCancelCommand: () => Command;

package/dist/commands/publish/cancel.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishCancelCommand = void 0;
+const commander_1 = require("commander");
+const cancel_1 = require("../../publishing/tasks/cancel");
+const shared_1 = require("../shared");
+const createPublishCancelCommand = () => {
+    const command = new commander_1.Command("cancel")
+        .description("Cancel a queued or running publish job. Pass <jobId> for one, or --all-queued to sweep every queued/running job in the env (gated behind a typed env-name confirmation). The API only honours cancellation for Queued / Running jobs; Completed / Failed / already-Cancelled jobs cannot be cancelled.")
+        .argument("[jobId]", "Publish job id returned by `scai content publish item` / `scai content publish all`. Omit when using --all-queued.")
+        .option("--all-queued", "Cancel every queued and running publish job in the env. Requires a typed env-name confirmation (or --yes in CI).")
+        .option("--yes", "Skip the typed env-name prompt when using --all-queued (CI use).");
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addHelpText("after", "\nExamples:\n" +
+        "  $ scai content publish cancel job_abc123 -n sandbox\n" +
+        "  $ scai content publish cancel --all-queued -n sandbox\n" +
+        "  $ scai content publish cancel --all-queued -n sandbox --yes  # CI / scripted use\n");
+    command.action(async (jobId, options) => {
+        await (0, cancel_1.runPublishCancel)({ ...options, jobId });
+    });
+    return command;
+};
+exports.createPublishCancelCommand = createPublishCancelCommand;

package/dist/commands/publish/history.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishHistoryCommand: () => Command;

package/dist/commands/publish/history.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishHistoryCommand = void 0;
+const commander_1 = require("commander");
+const history_1 = require("../../publishing/tasks/history");
+const shared_1 = require("../shared");
+const parseIntOpt = (value) => {
+    const n = Number.parseInt(value, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`Expected positive integer, got '${value}'.`);
+    }
+    return n;
+};
+const createPublishHistoryCommand = () => {
+    const command = new commander_1.Command("history")
+        .description("Read the local publishing audit log at ~/.sitecoreai/audit.log (overridable via SITECOREAI_AUDIT_LOG). Filter by env / time / command / outcome. Use --json for newline-delimited JSON suitable for piping into jq.")
+        .option("--env <name>", "Filter to entries from this env (matches scope.envName).")
+        .option("--since <spec>", "Filter to entries newer than this. ISO 8601 (e.g. 2026-05-01) or relative (24h, 7d, 30m).")
+        .option("--command <substr>", "Substring match against the `command` field (e.g. 'item', 'unpublish', 'content version').")
+        .addOption(new commander_1.Option("--outcome <value>", "Filter by outcome.").choices(["ok", "error", "cancelled"]))
+        .addOption(new commander_1.Option("--scan-limit <N>", "How many recent entries to scan before filtering (default 500). Increase for deep history searches.").argParser(parseIntOpt))
+        .addOption(new commander_1.Option("--limit <N>", "Max entries to print after filtering (default 50).").argParser(parseIntOpt));
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addHelpText("after", "\nExamples:\n" +
+        "  $ scai content publish history\n" +
+        "  $ scai content publish history --env sandbox --since 24h\n" +
+        "  $ scai content publish history --command 'publish all' --outcome ok\n" +
+        "  $ scai content publish history --outcome error --json | jq -r '.errorMessage'\n");
+    command.action(async (options) => {
+        await (0, history_1.runPublishHistory)(options);
+    });
+    return command;
+};
+exports.createPublishHistoryCommand = createPublishHistoryCommand;

package/dist/commands/publish/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishCommand: () => Command;

package/dist/commands/publish/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishCommand = void 0;
+const commander_1 = require("commander");
+const all_1 = require("./all");
+const cancel_1 = require("./cancel");
+const history_1 = require("./history");
+const item_1 = require("./item");
+const status_1 = require("./status");
+const unpublish_1 = require("./unpublish");
+const createPublishCommand = () => {
+    const command = new commander_1.Command("publish").description("Publish content to Experience Edge via the SAI Publishing API. Requires an environment-level automation client (Cloud Portal → Environments → [env] → Automation Clients).");
+    command.addCommand((0, item_1.createPublishItemCommand)());
+    command.addCommand((0, all_1.createPublishAllCommand)());
+    command.addCommand((0, status_1.createPublishStatusCommand)());
+    command.addCommand((0, cancel_1.createPublishCancelCommand)());
+    command.addCommand((0, unpublish_1.createPublishUnpublishCommand)());
+    command.addCommand((0, history_1.createPublishHistoryCommand)());
+    command.addHelpText("after", "\nExamples:\n" +
+        "  $ scai content publish item --item-id <guid> -n <env>                # dry-run, prints scope + token\n" +
+        "  $ scai content publish item --item-id <guid> -n <env> --allow-write  # actually publish (non-prod)\n" +
+        "  $ scai content publish status <jobId> -n <env>                       # inspect a publish job\n" +
+        "\nSetup:\n" +
+        "  1. Cloud Portal: Environments → [env] → Automation Clients → Create\n" +
+        "  2. Set SITECOREAI_ENV_<NAME>_CLIENT_ID / _CLIENT_SECRET in your shell,\n" +
+        "     or add clientId/clientSecret to the env profile in sitecoreai.cli.json\n" +
+        "  3. scai mints the publishing token transparently with xmcpub.jobs.t:r/w scopes\n");
+    return command;
+};
+exports.createPublishCommand = createPublishCommand;

package/dist/commands/publish/item.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishItemCommand: () => Command;

package/dist/commands/publish/item.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishItemCommand = void 0;
+const commander_1 = require("commander");
+const item_1 = require("../../publishing/tasks/item");
+const shared_1 = require("../shared");
+const createPublishItemCommand = () => {
+    const command = new commander_1.Command("item")
+        .description("Publish one or more items in a single job (Tier 1). Items can be addressed by GUID (--items) or by Sitecore content-tree path (--paths). At least one must be provided. Defaults to --what-if dry-run; pass --allow-write to actually publish. Production-tier envs additionally require --confirm-token from a prior dry-run.")
+        .option("--items <guid>", "Item ID (GUID) to publish. Repeatable, or pass a comma-separated list.", shared_1.collectList, [])
+        .option("--paths <path>", "Item path (e.g. /sitecore/content/Home). Repeatable, or pass a comma-separated list. Resolved to item IDs via Authoring GraphQL before submission.", shared_1.collectList, [])
+        .option("--site <name>", "Resolve the named site's content-tree root and add it to the publish target list. By default publishes ONLY the root item; combine with --include-subitems for the whole site.")
+        .option("--item-type <type>", "ItemModel.type for the request body. Defaults to `item`.")
+        .option("-l, --languages <list>", "Literal language list (e.g. en-US,fr-CA). Mutually exclusive with --languages-from-site / --all-tenant-languages.", shared_1.collectList, [])
+        .option("--languages-from-site <name>", "Resolve the language list from the named site's configured languages (via Sites API). Logs the resolved set before submitting.")
+        .option("--all-tenant-languages", "Resolve the language list to every language registered in the tenant (via Sites API listLanguages).")
+        .option("--include-subitems", "Publish descendants of the items (xmc.items.publishChildren).")
+        .option("--include-related", "Publish referenced items (xmc.items.publishRelatedItems).")
+        .addOption(new commander_1.Option("--mode <mode>", "Publish mode. `Smart` skips items unchanged since the last publish; `Republish` forces re-emit of every item in the batch. Incremental is whole-environment only and lives on `publish all`.")
+        .choices(["Smart", "Republish"])
+        .default("Smart"))
+        .option("--confirm-token <token>", "Scope token obtained from a previous dry-run. Required on production-tier envs.")
+        .option("--yes", "Skip the [y/N] prompt on non-production envs. Has no effect on production-tier — those always require --confirm-token.")
+        .addOption(new commander_1.Option("--name <name>", "Override the API job name (the publishing UI label)."))
+        .addOption(new commander_1.Option("--source <source>", "Override the API source field. Default `scai`."));
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    (0, shared_1.addAllowWriteOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addHelpText("after", "\nFlow:\n" +
+        "  1. Dry-run (default): scai content publish item --items <guid>[,<guid>...] -n <env>\n" +
+        "     → prints the resolved scope and a scope token (5-min TTL)\n" +
+        "  2. Real call: scai content publish item --items <guid>... -n <env> --allow-write\n" +
+        "     → on non-prod envs, prompts [y/N]\n" +
+        "     → on prod envs, ALSO requires --confirm-token <token>\n" +
+        "\nExamples:\n" +
+        "  $ scai content publish item --items abc123 -n sandbox\n" +
+        "  $ scai content publish item --items abc123,def456,ghi789 -n sandbox\n" +
+        "  $ scai content publish item --paths /sitecore/content/Home -n sandbox\n" +
+        "  $ scai content publish item --paths /sitecore/content/Home,/sitecore/content/About -n sandbox\n" +
+        "  $ scai content publish item --items abc123 --paths /sitecore/content/Home -n sandbox  # mix both\n" +
+        "  $ scai content publish item --items abc123 --include-subitems -n sandbox              # + descendants\n" +
+        "  $ scai content publish item --items abc1,def4 --mode Republish -n sandbox             # force re-emit\n" +
+        "  $ scai content publish item --paths /sitecore/content/Home --languages-from-site marketing -n sandbox\n" +
+        "  $ scai content publish item --items abc1 --all-tenant-languages -n sandbox            # every tenant lang\n" +
+        "  $ scai content publish item --site marketing -n sandbox                                # site root only\n" +
+        "  $ scai content publish item --site marketing --include-subitems -n sandbox             # whole site\n" +
+        "  $ scai content publish item --site marketing --include-subitems --languages-from-site marketing -n sandbox\n");
+    command.action(async (options) => {
+        await (0, item_1.runPublishItem)(options);
+    });
+    return command;
+};
+exports.createPublishItemCommand = createPublishItemCommand;

package/dist/commands/publish/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishStatusCommand: () => Command;

package/dist/commands/publish/status.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishStatusCommand = void 0;
+const commander_1 = require("commander");
+const status_1 = require("../../publishing/tasks/status");
+const shared_1 = require("../shared");
+const parseIntOpt = (value) => {
+    const n = Number.parseInt(value, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`Expected positive integer, got '${value}'.`);
+    }
+    return n;
+};
+const createPublishStatusCommand = () => {
+    const command = new commander_1.Command("status")
+        .description("Show the state of a publish job, or list queued/running jobs when no jobId is given. Pass --watch to poll until the job reaches a terminal state (completed/failed/cancelled).")
+        .argument("[jobId]", "Publish job id (e.g. job_4F2B1). When omitted, lists jobs currently queued or running.")
+        .option("--watch", "Poll until the job reaches a terminal state. Requires a jobId.")
+        .addOption(new commander_1.Option("--poll-interval-s <seconds>", "Polling interval in seconds (default 5, clamped to [2, 60]).").argParser(parseIntOpt))
+        .addOption(new commander_1.Option("--timeout-s <seconds>", "Hard timeout for --watch in seconds (default 1800). Throws NETWORK error if the job hasn't reached a terminal state by then.").argParser(parseIntOpt));
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addHelpText("after", "\nExamples:\n" +
+        "  $ scai content publish status -n sandbox                          # list queued/running\n" +
+        "  $ scai content publish status job_abc123 -n sandbox               # one-shot status\n" +
+        "  $ scai content publish status job_abc123 -n sandbox --watch       # follow until terminal\n" +
+        "  $ scai content publish status job_abc123 -n sandbox --watch --json  # CI-friendly stream\n");
+    command.action(async (jobId, options) => {
+        await (0, status_1.runPublishStatus)({ ...options, jobId });
+    });
+    return command;
+};
+exports.createPublishStatusCommand = createPublishStatusCommand;

package/dist/commands/publish/unpublish.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createPublishUnpublishCommand: () => Command;

package/dist/commands/publish/unpublish.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublishUnpublishCommand = void 0;
+const commander_1 = require("commander");
+const unpublish_1 = require("../../publishing/tasks/unpublish");
+const shared_1 = require("../shared");
+const createPublishUnpublishCommand = () => {
+    const command = new commander_1.Command("unpublish")
+        .description("Unpublish one or more items. Writes a publish-state field via the Authoring API (or calls deleteItem for --strategy delete), then submits a publish job so Edge picks up the removal. Defaults to the reversible `never-publish` strategy; pass --strategy expire-now to set `__Valid to: now`, or --strategy delete for permanent removal (typed-item-path confirmation required).")
+        .option("--items <guid>", "Item ID (GUID) to unpublish. Repeatable, or pass a comma-separated list.", shared_1.collectList, [])
+        .option("--paths <path>", "Item path (e.g. /sitecore/content/Home). Repeatable, or pass a comma-separated list. Resolved to item IDs via Authoring GraphQL before submission.", shared_1.collectList, [])
+        .option("--site <name>", "Resolve the named site's content-tree root and add it to the target list. By default targets ONLY the root item; combine with --include-subitems to unpublish the whole site.")
+        .option("-l, --languages <list>", "Literal language list. Mutually exclusive with --languages-from-site / --all-tenant-languages.", shared_1.collectList, [])
+        .option("--languages-from-site <name>", "Resolve the language list from the named site (Sites API).")
+        .option("--all-tenant-languages", "Resolve the language list to every language registered in the tenant.")
+        .option("--include-subitems", "Publish descendants in the follow-up publish job.")
+        .option("--include-related", "Publish referenced items in the follow-up publish job.")
+        .addOption(new commander_1.Option("--strategy <mode>", "Unpublish mechanism. `never-publish` (default, reversible) sets `__Never publish: true`. `expire-now` (reversible) sets `__Valid to: <now>`. `delete` (NOT reversible) calls deleteItem and requires typed-item-path confirmation per item.")
+        .choices(["never-publish", "expire-now", "delete"])
+        .default("never-publish"))
+        .option("--confirm-token <token>", "Scope token obtained from a previous dry-run. Required on production-tier envs.")
+        .option("--confirm-item-path <path>", "For --strategy delete with --yes: the exact resolved item path the operator is authorizing to delete. Must match scai's path resolution for each item. Without this (and --yes), scai prompts interactively per item.")
+        .option("--yes", "Skip the [y/N] prompt on non-production envs. Has no effect on production-tier — those always require --confirm-token. For --strategy delete: also requires --confirm-item-path.")
+        .addOption(new commander_1.Option("--name <name>", "Override the API job name for the follow-up publish job."))
+        .addOption(new commander_1.Option("--source <source>", "Override the API source field. Default `scai`."));
+    (0, shared_1.addEnvironmentOption)(command);
+    (0, shared_1.addConfigOption)(command);
+    (0, shared_1.addWhatIfOption)(command);
+    (0, shared_1.addAllowWriteOption)(command);
+    (0, shared_1.addVerbosityOptions)(command);
+    command.addHelpText("after", "\nFlow:\n" +
+        "  1. Dry-run (default): scai content publish unpublish --items <guid> -n <env>\n" +
+        "     → prints the resolved scope and a scope token (5-min TTL)\n" +
+        "  2. Real call: scai content publish unpublish --items <guid> -n <env> --allow-write\n" +
+        "     → writes `__Never publish: true` (or `__Valid to: <now>` for --strategy expire-now)\n" +
+        "     → then submits a Publishing API job so Edge picks up the removal\n" +
+        "  Reverse:\n" +
+        "     scai content version set-never-publish --item-id <guid> --value false -n <env> --allow-write\n" +
+        "     scai content publish item --items <guid> -n <env> --allow-write\n" +
+        "\nExamples:\n" +
+        "  $ scai content publish unpublish --items abc123 -n sandbox\n" +
+        "  $ scai content publish unpublish --paths /sitecore/content/Home -n sandbox\n" +
+        "  $ scai content publish unpublish --site marketing -n sandbox                           # site root only\n" +
+        "  $ scai content publish unpublish --site marketing --include-subitems -n sandbox        # whole site\n" +
+        "  $ scai content publish unpublish --items abc123 --strategy expire-now -n sandbox\n" +
+        "  $ scai content publish unpublish --items abc123 --strategy delete -n sandbox           # destructive\n");
+    command.action(async (options) => {
+        await (0, unpublish_1.runPublishUnpublish)(options);
+    });
+    return command;
+};
+exports.createPublishUnpublishCommand = createPublishUnpublishCommand;

package/dist/commands/recipe/index.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const createRecipeCommand: () => Command;
-//# sourceMappingURL=index.d.ts.map