@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/content/tasks/version-never-publish.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * `scai content version set-never-publish` — set or clear the
+ * `__Never publish` flag on a specific item version.
+ *
+ * Pure CM mutation — DOES NOT auto-publish. After flipping the flag,
+ * operators run `scai content publish item` (or `scai content publish unpublish`)
+ * separately. Letting these two steps stay independent means an
+ * operator can batch several `set-*` changes before paying for the
+ * publish round trip.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContentVersionSetNeverPublish = void 0;
+const errors_1 = require("../../shared/errors");
+const environment_1 = require("../../policy/environment");
+const publish_audit_1 = require("../../shared/publish-audit");
+const version_fields_1 = require("../../content/api/version-fields");
+const shared_1 = require("./shared");
+const runContentVersionSetNeverPublish = async (options) => {
+    const logger = (0, shared_1.buildLogger)(options);
+    if (typeof options.value !== "boolean") {
+        throw (0, errors_1.createScaiError)("set-never-publish requires --value true|false.", "INPUT_INVALID");
+    }
+    if (!options.language) {
+        throw (0, errors_1.createScaiError)("set-never-publish requires --language.", "INPUT_INVALID");
+    }
+    const { envName, environment } = (0, environment_1.resolveEnvironment)(options);
+    const itemId = await (0, shared_1.resolveTargetItemId)(environment, options);
+    const snapshot = await (0, shared_1.loadVersionSnapshot)(environment, itemId, options.language, options.version);
+    const before = (0, version_fields_1.findField)(snapshot, version_fields_1.FIELD_NEVER_PUBLISH);
+    const after = (0, version_fields_1.formatBoolean)(options.value);
+    const scope = {
+        envName,
+        resolvedTenantId: environment.tenantId,
+        target: "AuthoringCM",
+        kind: "never-publish",
+        itemIds: [snapshot.itemId],
+        path: snapshot.path,
+        languages: [snapshot.language],
+        version: snapshot.version,
+    };
+    const scopeHash = (0, shared_1.computeScopeHash)(scope);
+    const change = {
+        name: version_fields_1.FIELD_NEVER_PUBLISH,
+        before,
+        after,
+    };
+    const gate = await (0, shared_1.runSafetyGate)({
+        envName,
+        environment,
+        scope,
+        operationLabel: `set-never-publish (${options.value})`,
+        options,
+        logger,
+        describeChange: () => {
+            logger.info(`Field:         ${version_fields_1.FIELD_NEVER_PUBLISH}`, "gray");
+            logger.info(`Before:        ${before ?? "(absent)"}`, "gray");
+            logger.info(`After:         ${after === "" ? '"" (false)' : after}`, "gray");
+        },
+    });
+    if (!gate.proceed) {
+        return;
+    }
+    const caller = { type: "human", via: "cli" };
+    try {
+        await (0, version_fields_1.writeVersionFields)(environment, {
+            itemId: snapshot.itemId,
+            language: snapshot.language,
+            version: snapshot.version,
+            fields: [{ name: version_fields_1.FIELD_NEVER_PUBLISH, value: after }],
+        });
+        (0, publish_audit_1.recordPublishAudit)({
+            ts: new Date().toISOString(),
+            command: "content version set-never-publish",
+            caller,
+            scope,
+            risk: "normal",
+            scopeHash,
+            scopeToken: options.confirmToken,
+            outcome: "ok",
+            fieldChanges: [change],
+        });
+        if (logger.isJson()) {
+            process.stdout.write(`${JSON.stringify({
+                itemId: snapshot.itemId,
+                path: snapshot.path,
+                language: snapshot.language,
+                version: snapshot.version,
+                field: version_fields_1.FIELD_NEVER_PUBLISH,
+                before,
+                after,
+            }, null, 2)}\n`);
+            return;
+        }
+        logger.info(`Set ${version_fields_1.FIELD_NEVER_PUBLISH} on ${snapshot.path} [${snapshot.language} v${snapshot.version}] → ${after === "" ? "false" : "true"}.`, "green");
+        logger.info(`Publish the change with: scai content publish item --items ${snapshot.itemId} -n ${envName}`, "gray");
+    }
+    catch (err) {
+        (0, publish_audit_1.recordPublishAudit)({
+            ts: new Date().toISOString(),
+            command: "content version set-never-publish",
+            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),
+            fieldChanges: [change],
+        });
+        throw err;
+    }
+};
+exports.runContentVersionSetNeverPublish = runContentVersionSetNeverPublish;

package/dist/content/tasks/version-validity.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `scai content version set-validity` — set or clear `__Valid from` /
+ * `__Valid to` on a specific item version.
+ *
+ * Either or both fields may be set per call; passing `--clear-*` writes
+ * an empty string to the field (Sitecore's convention for "no date").
+ * The four flag pairs (`--valid-from / --clear-valid-from` and
+ * `--valid-to / --clear-valid-to`) are mutually exclusive within each
+ * pair; the CLI layer enforces that and this task assumes it.
+ *
+ * Like `set-never-publish`, this does NOT auto-publish.
+ */
+import { type CommonContentVersionOptions } from "./shared";
+export interface RunContentVersionSetValidityOptions extends CommonContentVersionOptions {
+    /** New `__Valid from` value (ISO 8601). Mutually exclusive with
+     *  `clearValidFrom`. */
+    validFrom?: string;
+    clearValidFrom?: boolean;
+    /** New `__Valid to` value (ISO 8601). Mutually exclusive with
+     *  `clearValidTo`. */
+    validTo?: string;
+    clearValidTo?: boolean;
+}
+export declare const runContentVersionSetValidity: (options: RunContentVersionSetValidityOptions) => Promise<void>;

package/dist/content/tasks/version-validity.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * `scai content version set-validity` — set or clear `__Valid from` /
+ * `__Valid to` on a specific item version.
+ *
+ * Either or both fields may be set per call; passing `--clear-*` writes
+ * an empty string to the field (Sitecore's convention for "no date").
+ * The four flag pairs (`--valid-from / --clear-valid-from` and
+ * `--valid-to / --clear-valid-to`) are mutually exclusive within each
+ * pair; the CLI layer enforces that and this task assumes it.
+ *
+ * Like `set-never-publish`, this does NOT auto-publish.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContentVersionSetValidity = void 0;
+const errors_1 = require("../../shared/errors");
+const environment_1 = require("../../policy/environment");
+const publish_audit_1 = require("../../shared/publish-audit");
+const version_fields_1 = require("../../content/api/version-fields");
+const shared_1 = require("./shared");
+/**
+ * Basic ISO 8601 validation — Sitecore stores the wire form as a
+ * string and accepts what the Authoring UI emits. Rather than depend
+ * on a date-parsing lib, we do a permissive check that catches the
+ * obvious fat-finger ("2026-01-01") cases without false-rejecting
+ * tenant-specific formats.
+ */
+const ISO_8601_PATTERN = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+const assertIso = (label, raw) => {
+    if (!raw)
+        return;
+    if (!ISO_8601_PATTERN.test(raw)) {
+        throw (0, errors_1.createScaiError)(`${label} '${raw}' is not a valid ISO 8601 date.`, "INPUT_INVALID", {
+            hint: "Use ISO 8601 e.g. 2026-12-31 or 2026-12-31T23:59:59Z.",
+        });
+    }
+};
+const runContentVersionSetValidity = async (options) => {
+    const logger = (0, shared_1.buildLogger)(options);
+    if (!options.language) {
+        throw (0, errors_1.createScaiError)("set-validity requires --language.", "INPUT_INVALID");
+    }
+    if (options.validFrom && options.clearValidFrom) {
+        throw (0, errors_1.createScaiError)("Pass either --valid-from or --clear-valid-from, not both.", "INPUT_INVALID");
+    }
+    if (options.validTo && options.clearValidTo) {
+        throw (0, errors_1.createScaiError)("Pass either --valid-to or --clear-valid-to, not both.", "INPUT_INVALID");
+    }
+    if (!options.validFrom && !options.clearValidFrom && !options.validTo && !options.clearValidTo) {
+        throw (0, errors_1.createScaiError)("set-validity requires at least one of --valid-from / --clear-valid-from / --valid-to / --clear-valid-to.", "INPUT_INVALID");
+    }
+    assertIso("--valid-from", options.validFrom);
+    assertIso("--valid-to", options.validTo);
+    const { envName, environment } = (0, environment_1.resolveEnvironment)(options);
+    const itemId = await (0, shared_1.resolveTargetItemId)(environment, options);
+    const snapshot = await (0, shared_1.loadVersionSnapshot)(environment, itemId, options.language, options.version);
+    const fieldsToWrite = [];
+    const changes = [];
+    if (options.validFrom !== undefined || options.clearValidFrom) {
+        const before = (0, version_fields_1.findField)(snapshot, version_fields_1.FIELD_VALID_FROM);
+        const after = options.clearValidFrom ? "" : options.validFrom;
+        fieldsToWrite.push({ name: version_fields_1.FIELD_VALID_FROM, value: after });
+        changes.push({
+            name: version_fields_1.FIELD_VALID_FROM,
+            before,
+            after: options.clearValidFrom ? null : after,
+        });
+    }
+    if (options.validTo !== undefined || options.clearValidTo) {
+        const before = (0, version_fields_1.findField)(snapshot, version_fields_1.FIELD_VALID_TO);
+        const after = options.clearValidTo ? "" : options.validTo;
+        fieldsToWrite.push({ name: version_fields_1.FIELD_VALID_TO, value: after });
+        changes.push({
+            name: version_fields_1.FIELD_VALID_TO,
+            before,
+            after: options.clearValidTo ? null : after,
+        });
+    }
+    const scope = {
+        envName,
+        resolvedTenantId: environment.tenantId,
+        target: "AuthoringCM",
+        kind: "validity",
+        itemIds: [snapshot.itemId],
+        path: snapshot.path,
+        languages: [snapshot.language],
+        version: snapshot.version,
+    };
+    const scopeHash = (0, shared_1.computeScopeHash)(scope);
+    const gate = await (0, shared_1.runSafetyGate)({
+        envName,
+        environment,
+        scope,
+        operationLabel: "set-validity",
+        options,
+        logger,
+        describeChange: () => {
+            for (const c of changes) {
+                const beforeStr = c.before == null || c.before === "" ? "(empty)" : c.before;
+                const afterStr = c.after == null || c.after === "" ? "(cleared)" : c.after;
+                logger.info(`Field: ${c.name}`, "gray");
+                logger.info(`  Before:  ${beforeStr}`, "gray");
+                logger.info(`  After:   ${afterStr}`, "gray");
+            }
+        },
+    });
+    if (!gate.proceed) {
+        return;
+    }
+    const caller = { type: "human", via: "cli" };
+    try {
+        await (0, version_fields_1.writeVersionFields)(environment, {
+            itemId: snapshot.itemId,
+            language: snapshot.language,
+            version: snapshot.version,
+            fields: fieldsToWrite,
+        });
+        (0, publish_audit_1.recordPublishAudit)({
+            ts: new Date().toISOString(),
+            command: "content version set-validity",
+            caller,
+            scope,
+            risk: "normal",
+            scopeHash,
+            scopeToken: options.confirmToken,
+            outcome: "ok",
+            fieldChanges: changes,
+        });
+        if (logger.isJson()) {
+            process.stdout.write(`${JSON.stringify({
+                itemId: snapshot.itemId,
+                path: snapshot.path,
+                language: snapshot.language,
+                version: snapshot.version,
+                changes,
+            }, null, 2)}\n`);
+            return;
+        }
+        logger.info(`Updated validity on ${snapshot.path} [${snapshot.language} v${snapshot.version}].`, "green");
+        logger.info(`Publish the change with: scai content publish item --items ${snapshot.itemId} -n ${envName}`, "gray");
+    }
+    catch (err) {
+        (0, publish_audit_1.recordPublishAudit)({
+            ts: new Date().toISOString(),
+            command: "content version set-validity",
+            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),
+            fieldChanges: changes,
+        });
+        throw err;
+    }
+};
+exports.runContentVersionSetValidity = runContentVersionSetValidity;

package/dist/deploy/api/client-naming.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Naming convention for OAuth clients that scai mints via the Deploy
+ * clients API (`./clients.ts`).
+ *
+ * Every scai-minted client is identifiable in the Cloud Portal clients
+ * list by a `scai-` name prefix, and its provenance is recorded in the
+ * description. This module is the single source of truth for that
+ * convention — every mint call and every "is this ours?" check goes
+ * through these helpers rather than hand-building strings.
+ *
+ * Name shape (stable + deterministic, so a list-then-match yields
+ * idempotent reuse — no timestamps):
+ *
+ *   - environment-scoped: `scai-<type>-<env>`  e.g. `scai-cm-production`
+ *   - organization-scoped: `scai-<type>`       e.g. `scai-deploy`
+ *
+ * The `<env>` segment is the slugified scai environment-profile name.
+ */
+/** The `name`-field prefix that marks a client as scai-managed. */
+export declare const SCAI_CLIENT_PREFIX = "scai-";
+/** Client kinds scai can mint. `deploy` is org-scoped; the rest are env-scoped. */
+export type ScaiClientType = "cm" | "deploy" | "edge" | "ehbuild";
+/** scai surface that triggered the mint — recorded in the description. */
+export type ScaiClientSurface = "CLI" | "MCP" | "SDK";
+/**
+ * Slugify a scai environment-profile name for use in a client name:
+ * lowercase, every run of non-alphanumerics collapsed to a single
+ * hyphen, leading/trailing hyphens trimmed.
+ */
+export declare const slugifyEnvName: (envName: string) => string;
+/**
+ * Build the canonical client name for a scai-minted client.
+ *
+ *   - env-scoped (`cm` | `edge` | `ehbuild`) → `scai-<type>-<env>`;
+ *     `envName` is required.
+ *   - org-scoped (`deploy`) → `scai-deploy`; `envName` is ignored.
+ *
+ * Throws `INPUT_INVALID` if an env-scoped type is given without a
+ * usable `envName`.
+ */
+export declare const buildScaiClientName: (type: ScaiClientType, envName?: string) => string;
+export interface BuildScaiClientDescriptionOptions {
+    /** Which scai surface minted the client. */
+    surface: ScaiClientSurface;
+    /** scai package version, e.g. "0.0.4". */
+    version: string;
+    /** Environment-profile name — for env-scoped clients. */
+    envName?: string;
+}
+/**
+ * The Deploy clients API caps the `description` field at 140 characters
+ * — `POST /api/clients/v1/*` rejects anything longer as a validation
+ * error. `buildScaiClientDescription` keeps its output within this.
+ */
+export declare const CLIENT_DESCRIPTION_MAX_LENGTH = 140;
+/**
+ * Build the human-readable provenance string for a scai-minted client's
+ * `description` field — records the surface, version, scope, and that
+ * the credential is safe to delete.
+ *
+ * Stays within `CLIENT_DESCRIPTION_MAX_LENGTH`, truncating as a
+ * defensive backstop for pathologically long env-profile names. The
+ * project id and creation date are deliberately omitted: the clients
+ * API records `createdAt` itself, and the project is already encoded in
+ * the client name (`scai-cm-<env>`).
+ */
+export declare const buildScaiClientDescription: (type: ScaiClientType, options: BuildScaiClientDescriptionOptions) => string;
+/** True if `name` carries the scai-managed prefix. */
+export declare const isScaiManagedClient: (name: string | null | undefined) => boolean;
+/**
+ * Parse a client name back into its `{ type, envName? }` parts, or
+ * `null` if it is not a canonically-formed scai-managed name.
+ *
+ * Round-trips with `buildScaiClientName` — note `envName` comes back
+ * slugified (the name only ever stored the slug).
+ */
+export declare const parseScaiClientName: (name: string | null | undefined) => {
+    type: ScaiClientType;
+    envName?: string;
+} | null;

package/dist/deploy/api/client-naming.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Naming convention for OAuth clients that scai mints via the Deploy
+ * clients API (`./clients.ts`).
+ *
+ * Every scai-minted client is identifiable in the Cloud Portal clients
+ * list by a `scai-` name prefix, and its provenance is recorded in the
+ * description. This module is the single source of truth for that
+ * convention — every mint call and every "is this ours?" check goes
+ * through these helpers rather than hand-building strings.
+ *
+ * Name shape (stable + deterministic, so a list-then-match yields
+ * idempotent reuse — no timestamps):
+ *
+ *   - environment-scoped: `scai-<type>-<env>`  e.g. `scai-cm-production`
+ *   - organization-scoped: `scai-<type>`       e.g. `scai-deploy`
+ *
+ * The `<env>` segment is the slugified scai environment-profile name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScaiClientName = exports.isScaiManagedClient = exports.buildScaiClientDescription = exports.CLIENT_DESCRIPTION_MAX_LENGTH = exports.buildScaiClientName = exports.slugifyEnvName = exports.SCAI_CLIENT_PREFIX = void 0;
+const errors_1 = require("../../shared/errors");
+/** The `name`-field prefix that marks a client as scai-managed. */
+exports.SCAI_CLIENT_PREFIX = "scai-";
+const ENV_SCOPED = new Set(["cm", "edge", "ehbuild"]);
+const ALL_TYPES = new Set(["cm", "deploy", "edge", "ehbuild"]);
+const TYPE_LABELS = {
+    cm: "CM",
+    deploy: "Deploy",
+    edge: "Edge",
+    ehbuild: "Editing-host build",
+};
+/**
+ * Slugify a scai environment-profile name for use in a client name:
+ * lowercase, every run of non-alphanumerics collapsed to a single
+ * hyphen, leading/trailing hyphens trimmed.
+ */
+const slugifyEnvName = (envName) => envName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+exports.slugifyEnvName = slugifyEnvName;
+/**
+ * Build the canonical client name for a scai-minted client.
+ *
+ *   - env-scoped (`cm` | `edge` | `ehbuild`) → `scai-<type>-<env>`;
+ *     `envName` is required.
+ *   - org-scoped (`deploy`) → `scai-deploy`; `envName` is ignored.
+ *
+ * Throws `INPUT_INVALID` if an env-scoped type is given without a
+ * usable `envName`.
+ */
+const buildScaiClientName = (type, envName) => {
+    if (!ENV_SCOPED.has(type)) {
+        return `${exports.SCAI_CLIENT_PREFIX}${type}`;
+    }
+    const slug = envName ? (0, exports.slugifyEnvName)(envName) : "";
+    if (!slug) {
+        throw (0, errors_1.createScaiError)(`Cannot build a client name: '${type}' is environment-scoped and needs an environment name.`, "INPUT_INVALID", { hint: "Pass the scai environment-profile name as the second argument." });
+    }
+    return `${exports.SCAI_CLIENT_PREFIX}${type}-${slug}`;
+};
+exports.buildScaiClientName = buildScaiClientName;
+/**
+ * The Deploy clients API caps the `description` field at 140 characters
+ * — `POST /api/clients/v1/*` rejects anything longer as a validation
+ * error. `buildScaiClientDescription` keeps its output within this.
+ */
+exports.CLIENT_DESCRIPTION_MAX_LENGTH = 140;
+/**
+ * Build the human-readable provenance string for a scai-minted client's
+ * `description` field — records the surface, version, scope, and that
+ * the credential is safe to delete.
+ *
+ * Stays within `CLIENT_DESCRIPTION_MAX_LENGTH`, truncating as a
+ * defensive backstop for pathologically long env-profile names. The
+ * project id and creation date are deliberately omitted: the clients
+ * API records `createdAt` itself, and the project is already encoded in
+ * the client name (`scai-cm-<env>`).
+ */
+const buildScaiClientDescription = (type, options) => {
+    const lead = `Managed by scai ${options.surface} v${options.version}.`;
+    const scope = ENV_SCOPED.has(type)
+        ? `${TYPE_LABELS[type]} client for ${options.envName ? `environment '${options.envName}'` : "an environment"}.`
+        : `${TYPE_LABELS[type]} client for the organization.`;
+    const tail = "Safe to delete if scai is unused.";
+    const full = `${lead} ${scope} ${tail}`;
+    if (full.length <= exports.CLIENT_DESCRIPTION_MAX_LENGTH) {
+        return full;
+    }
+    // Defensive: a very long env-profile name can still blow the cap.
+    return `${full.slice(0, exports.CLIENT_DESCRIPTION_MAX_LENGTH - 1).trimEnd()}…`;
+};
+exports.buildScaiClientDescription = buildScaiClientDescription;
+/** True if `name` carries the scai-managed prefix. */
+const isScaiManagedClient = (name) => typeof name === "string" && name.startsWith(exports.SCAI_CLIENT_PREFIX);
+exports.isScaiManagedClient = isScaiManagedClient;
+/**
+ * Parse a client name back into its `{ type, envName? }` parts, or
+ * `null` if it is not a canonically-formed scai-managed name.
+ *
+ * Round-trips with `buildScaiClientName` — note `envName` comes back
+ * slugified (the name only ever stored the slug).
+ */
+const parseScaiClientName = (name) => {
+    if (!(0, exports.isScaiManagedClient)(name)) {
+        return null;
+    }
+    const rest = name.slice(exports.SCAI_CLIENT_PREFIX.length);
+    const dash = rest.indexOf("-");
+    const typeToken = dash === -1 ? rest : rest.slice(0, dash);
+    const envToken = dash === -1 ? "" : rest.slice(dash + 1);
+    if (!ALL_TYPES.has(typeToken)) {
+        return null;
+    }
+    const type = typeToken;
+    if (ENV_SCOPED.has(type)) {
+        // Env-scoped names must carry a non-empty env segment.
+        return envToken ? { type, envName: envToken } : null;
+    }
+    // Org-scoped names must NOT carry a trailing segment.
+    return envToken ? null : { type };
+};
+exports.parseScaiClientName = parseScaiClientName;

package/dist/deploy/api/client.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Production `DeployApiClient` factory for the Sitecore Cloud Deploy API.
+ *
+ * Like `createSitesApiClient` in `recipe/`, this is an options-bound
+ * adapter over the function-style Deploy API surface. It exposes a
+ * curated 80%-use-case subset of the operations exported from
+ * `@sitecoreai-labs/sitecoreai-cli/deploy`:
+ *
+ *   - `fetchOrganization*` for org metadata + license
+ *   - `fetchProject*` + `createProject` for project navigation
+ *   - `fetchEnvironment*` + `createEnvironmentDeployment` for the
+ *     environment lifecycle
+ *   - `fetchDeployment*` + `deployDeployment` + `uploadDeploymentSource`
+ *     for the deploy flow
+ *   - `fetchLogList` for environment log access
+ *   - `fetchSourceControlIntegrations` + `fetchSourceControlRepository`
+ *     for source-control discovery
+ *
+ * The full operation set (60+ functions) remains exported from
+ * `@sitecoreai-labs/sitecoreai-cli/deploy` for callers that need the
+ * long-tail surface (env vars, regenerate context, source-control
+ * provider management, etc.) — bind them yourself by passing
+ * `options` as the first argument.
+ *
+ * This factory exists primarily for shape uniformity with the recipe
+ * surface; it does not add retry, caching, or path-resolution behavior
+ * beyond what the underlying functions already do.
+ *
+ * Note: a few deploy operations are intentionally NOT on this interface
+ * because their signatures don't take a `DeployApiClientOptions`:
+ *   - `probeEnvironmentHealth(host, timeoutMs)` — direct HTTP probe by URL
+ *   - `resolveHostFromEnvironment(env)` — pure object accessor
+ *   - `fetchDeploymentLogs(deploymentId, accessToken)` — takes the access
+ *     token directly rather than the full options object
+ * Import these directly from `@sitecoreai-labs/sitecoreai-cli/deploy`.
+ */
+import { cancelDeployment, deployDeployment, fetchDeployment, fetchDeploymentStatus, fetchDeployments, uploadDeploymentSource } from "./deployments";
+import { createEnvironmentDeployment, fetchAllEnvironments, fetchEnvironment, fetchEnvironmentDeployments, fetchEnvironments } from "./environments";
+import { fetchLogList } from "./logs";
+import { createOrganizationDemoSolution, fetchOrganization, fetchOrganizationHealth, fetchOrganizationLicense } from "./organizations";
+import { createProject, fetchAllProjects, fetchProject, fetchProjectEnvironments, fetchProjects } from "./projects";
+import { fetchSourceControlIntegrations, fetchSourceControlRepository } from "./source-control";
+import type { DeployApiClientOptions } from "./common/types";
+type Tail<F> = F extends (head: DeployApiClientOptions, ...rest: infer R) => infer X ? (...args: R) => X : never;
+export interface DeployApiClient {
+    readonly options: DeployApiClientOptions;
+    fetchOrganization: Tail<typeof fetchOrganization>;
+    fetchOrganizationHealth: Tail<typeof fetchOrganizationHealth>;
+    fetchOrganizationLicense: Tail<typeof fetchOrganizationLicense>;
+    createOrganizationDemoSolution: Tail<typeof createOrganizationDemoSolution>;
+    fetchProjects: Tail<typeof fetchProjects>;
+    fetchAllProjects: Tail<typeof fetchAllProjects>;
+    fetchProject: Tail<typeof fetchProject>;
+    createProject: Tail<typeof createProject>;
+    fetchProjectEnvironments: Tail<typeof fetchProjectEnvironments>;
+    fetchEnvironments: Tail<typeof fetchEnvironments>;
+    fetchAllEnvironments: Tail<typeof fetchAllEnvironments>;
+    fetchEnvironment: Tail<typeof fetchEnvironment>;
+    fetchEnvironmentDeployments: Tail<typeof fetchEnvironmentDeployments>;
+    createEnvironmentDeployment: Tail<typeof createEnvironmentDeployment>;
+    fetchDeployments: Tail<typeof fetchDeployments>;
+    fetchDeployment: Tail<typeof fetchDeployment>;
+    fetchDeploymentStatus: Tail<typeof fetchDeploymentStatus>;
+    deployDeployment: Tail<typeof deployDeployment>;
+    cancelDeployment: Tail<typeof cancelDeployment>;
+    uploadDeploymentSource: Tail<typeof uploadDeploymentSource>;
+    fetchLogList: Tail<typeof fetchLogList>;
+    fetchSourceControlIntegrations: () => ReturnType<typeof fetchSourceControlIntegrations>;
+    fetchSourceControlRepository: Tail<typeof fetchSourceControlRepository>;
+}
+export declare const createDeployApiClient: (options: DeployApiClientOptions) => DeployApiClient;
+export {};

package/dist/deploy/api/client.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeployApiClient = void 0;
+/**
+ * Production `DeployApiClient` factory for the Sitecore Cloud Deploy API.
+ *
+ * Like `createSitesApiClient` in `recipe/`, this is an options-bound
+ * adapter over the function-style Deploy API surface. It exposes a
+ * curated 80%-use-case subset of the operations exported from
+ * `@sitecoreai-labs/sitecoreai-cli/deploy`:
+ *
+ *   - `fetchOrganization*` for org metadata + license
+ *   - `fetchProject*` + `createProject` for project navigation
+ *   - `fetchEnvironment*` + `createEnvironmentDeployment` for the
+ *     environment lifecycle
+ *   - `fetchDeployment*` + `deployDeployment` + `uploadDeploymentSource`
+ *     for the deploy flow
+ *   - `fetchLogList` for environment log access
+ *   - `fetchSourceControlIntegrations` + `fetchSourceControlRepository`
+ *     for source-control discovery
+ *
+ * The full operation set (60+ functions) remains exported from
+ * `@sitecoreai-labs/sitecoreai-cli/deploy` for callers that need the
+ * long-tail surface (env vars, regenerate context, source-control
+ * provider management, etc.) — bind them yourself by passing
+ * `options` as the first argument.
+ *
+ * This factory exists primarily for shape uniformity with the recipe
+ * surface; it does not add retry, caching, or path-resolution behavior
+ * beyond what the underlying functions already do.
+ *
+ * Note: a few deploy operations are intentionally NOT on this interface
+ * because their signatures don't take a `DeployApiClientOptions`:
+ *   - `probeEnvironmentHealth(host, timeoutMs)` — direct HTTP probe by URL
+ *   - `resolveHostFromEnvironment(env)` — pure object accessor
+ *   - `fetchDeploymentLogs(deploymentId, accessToken)` — takes the access
+ *     token directly rather than the full options object
+ * Import these directly from `@sitecoreai-labs/sitecoreai-cli/deploy`.
+ */
+const deployments_1 = require("./deployments");
+const environments_1 = require("./environments");
+const logs_1 = require("./logs");
+const organizations_1 = require("./organizations");
+const projects_1 = require("./projects");
+const source_control_1 = require("./source-control");
+const createDeployApiClient = (options) => ({
+    options,
+    fetchOrganization: () => (0, organizations_1.fetchOrganization)(options),
+    fetchOrganizationHealth: (orgId) => (0, organizations_1.fetchOrganizationHealth)(options, orgId),
+    fetchOrganizationLicense: (orgId) => (0, organizations_1.fetchOrganizationLicense)(options, orgId),
+    createOrganizationDemoSolution: () => (0, organizations_1.createOrganizationDemoSolution)(options),
+    fetchProjects: (query) => (0, projects_1.fetchProjects)(options, query),
+    fetchAllProjects: (pageSize) => (0, projects_1.fetchAllProjects)(options, pageSize),
+    fetchProject: (projectId) => (0, projects_1.fetchProject)(options, projectId),
+    createProject: (body) => (0, projects_1.createProject)(options, body),
+    fetchProjectEnvironments: (projectId, query) => (0, projects_1.fetchProjectEnvironments)(options, projectId, query),
+    fetchEnvironments: (query) => (0, environments_1.fetchEnvironments)(options, query),
+    fetchAllEnvironments: (pageSize) => (0, environments_1.fetchAllEnvironments)(options, pageSize),
+    fetchEnvironment: (environmentId) => (0, environments_1.fetchEnvironment)(options, environmentId),
+    fetchEnvironmentDeployments: (environmentId) => (0, environments_1.fetchEnvironmentDeployments)(options, environmentId),
+    createEnvironmentDeployment: (environmentId, redeploy) => (0, environments_1.createEnvironmentDeployment)(options, environmentId, redeploy),
+    fetchDeployments: (query) => (0, deployments_1.fetchDeployments)(options, query),
+    fetchDeployment: (deploymentId) => (0, deployments_1.fetchDeployment)(options, deploymentId),
+    fetchDeploymentStatus: (organizationId) => (0, deployments_1.fetchDeploymentStatus)(options, organizationId),
+    deployDeployment: (deploymentId, organizationId) => (0, deployments_1.deployDeployment)(options, deploymentId, organizationId),
+    cancelDeployment: (deploymentId, organizationId) => (0, deployments_1.cancelDeployment)(options, deploymentId, organizationId),
+    uploadDeploymentSource: (deploymentId, content) => (0, deployments_1.uploadDeploymentSource)(options, deploymentId, content),
+    fetchLogList: (environmentId, latest) => (0, logs_1.fetchLogList)(options, environmentId, latest),
+    fetchSourceControlIntegrations: () => (0, source_control_1.fetchSourceControlIntegrations)(options),
+    fetchSourceControlRepository: (query, organizationId) => (0, source_control_1.fetchSourceControlRepository)(options, query, organizationId),
+});
+exports.createDeployApiClient = createDeployApiClient;