@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/serialization/wildcard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildcard.d.ts","sourceRoot":"","sources":["../../src/serialization/wildcard.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,GAAI,WAAW,MAAM,KAAG,OAM9C,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,OAAO,MAAM,EACb,WAAW,MAAM,EACjB,uBAAqB,KACpB,OAaF,CAAC"}

package/dist/serialization/wildcard.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWildcardMatch = exports.isWildcard = void 0;
+const errors_1 = require("../shared/errors");
+const isWildcard = (candidate) => {
+    if (candidate == null) {
+        throw (0, errors_1.createCliError)("Wildcard candidate is null or undefined.", "INPUT_INVALID");
+    }
+    return candidate.includes("*") || candidate.includes("?");
+};
+exports.isWildcard = isWildcard;
+const isWildcardMatch = (input, wildcards, caseSensitive = false) => {
+    if (input == null) {
+        throw (0, errors_1.createCliError)("Input is null or undefined.", "INPUT_INVALID");
+    }
+    if ((0, exports.isWildcard)(wildcards)) {
+        const escaped = wildcards.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = "^" + escaped.replace(/\\\*/g, ".*").replace(/\\\?/g, ".") + "$";
+        const flags = caseSensitive ? "" : "i";
+        return new RegExp(regex, flags).test(input);
+    }
+    return caseSensitive ? input === wildcards : input.toLowerCase() === wildcards.toLowerCase();
+};
+exports.isWildcardMatch = isWildcardMatch;

package/dist/serialization/yaml.d.ts

@@ -0,0 +1,9 @@
+import { ItemData, RoleData, UserData } from "./types";
+export declare const readItemYamlFromString: (content: string) => ItemData;
+export declare const readItemYaml: (filePath: string) => Promise<ItemData>;
+export declare const writeItemYaml: (item: ItemData) => string;
+export declare const writeRoleYaml: (role: RoleData) => string;
+export declare const readRoleYamlFromString: (content: string, serializedItemId?: string) => RoleData;
+export declare const readUserYamlFromString: (content: string, serializedItemId?: string) => UserData;
+export declare const writeUserYaml: (user: UserData) => string;
+//# sourceMappingURL=yaml.d.ts.map

package/dist/serialization/yaml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../../src/serialization/yaml.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAIR,QAAQ,EACR,QAAQ,EAET,MAAM,SAAS,CAAC;AAkHjB,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,KAAG,QA8BxD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,QAAQ,CAGrE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,MAAM,QAAQ,KAAG,MA4F9C,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,MAAM,QAAQ,KAAG,MAe9C,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,EAAE,mBAAmB,MAAM,KAAG,QAUnF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,EAAE,mBAAmB,MAAM,KAAG,QA+BnF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,MAAM,QAAQ,KAAG,MAmC9C,CAAC"}

package/dist/serialization/yaml.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeUserYaml = exports.readUserYamlFromString = exports.readRoleYamlFromString = exports.writeRoleYaml = exports.writeItemYaml = exports.readItemYaml = exports.readItemYamlFromString = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const yaml_1 = __importDefault(require("yaml"));
+const errors_1 = require("../shared/errors");
+const item_path_1 = require("./item-path");
+const signature_1 = require("./signature");
+class YamlWriter {
+    constructor() {
+        this.indent = 0;
+        this.chunks = [];
+    }
+    writeBeginNewDocument() {
+        this.chunks.push("---\n");
+    }
+    increaseIndent() {
+        this.indent += YamlWriter.indentSpaces;
+    }
+    decreaseIndent() {
+        this.indent = Math.max(0, this.indent - YamlWriter.indentSpaces);
+    }
+    writeMap(key, value) {
+        const prefix = " ".repeat(this.indent);
+        if (value === undefined) {
+            this.chunks.push(`${prefix}${key}:\n`);
+            return;
+        }
+        if (value.includes("\n") ||
+            value.includes("\r") ||
+            value.includes('"') ||
+            value.includes("\\")) {
+            this.chunks.push(`${prefix}${key}: |\n`);
+            const indented = value
+                .split(/\r\n|\r|\n/)
+                .map((line) => " ".repeat(this.indent + YamlWriter.indentSpaces) + line)
+                .join("\n");
+            this.chunks.push(indented + "\n");
+            return;
+        }
+        const specialChars = ['"', ":", "[", "]", "{", "}", "!", "?", "-", "\\"];
+        const encoded = specialChars.some((char) => value.includes(char))
+            ? `"${value.replace(/"/g, '\\"')}"`
+            : value;
+        this.chunks.push(`${prefix}${key}: ${encoded}\n`);
+    }
+    writeBeginListItem(key, value) {
+        if (this.indent < YamlWriter.indentSpaces) {
+            throw (0, errors_1.createCliError)("Indent is at minimum. You must indent to support a list.", "UNKNOWN");
+        }
+        const prefix = " ".repeat(this.indent - YamlWriter.indentSpaces);
+        this.chunks.push(`${prefix}- ${key}: ${value}\n`);
+    }
+    toString() {
+        return this.chunks.join("");
+    }
+}
+YamlWriter.indentSpaces = 2;
+const normalizeField = (field) => ({
+    fieldId: field.fieldId ?? "",
+    nameHint: field.nameHint,
+    value: field.value ?? "",
+    blobId: field.blobId ?? null,
+});
+const parseItemFields = (fields) => {
+    if (!Array.isArray(fields)) {
+        return [];
+    }
+    return fields.map((entry) => normalizeField({
+        fieldId: String(entry["ID"] ?? ""),
+        nameHint: entry["Hint"],
+        value: String(entry["Value"] ?? ""),
+        blobId: entry["BlobID"],
+    }));
+};
+const parseLanguages = (languages) => {
+    if (!Array.isArray(languages)) {
+        return { unversioned: [], versions: [] };
+    }
+    const unversioned = [];
+    const versions = [];
+    for (const entry of languages) {
+        const language = String(entry["Language"] ?? "");
+        const fields = parseItemFields(entry["Fields"]);
+        if (fields.length > 0) {
+            unversioned.push({ language, fields });
+        }
+        const versionEntries = entry["Versions"];
+        if (Array.isArray(versionEntries)) {
+            for (const versionEntry of versionEntries) {
+                const versionNumber = Number(versionEntry["Version"] ?? 0);
+                const versionFields = parseItemFields(versionEntry["Fields"]);
+                versions.push({ language, version: versionNumber, fields: versionFields });
+            }
+        }
+    }
+    return { unversioned, versions };
+};
+const readItemYamlFromString = (content) => {
+    const doc = yaml_1.default.parse(content);
+    const id = String(doc["ID"] ?? "");
+    const parentId = String(doc["Parent"] ?? "");
+    const templateId = String(doc["Template"] ?? "");
+    const pathValue = String(doc["Path"] ?? "");
+    const branchId = doc["BranchID"] ? String(doc["BranchID"]) : null;
+    const sharedFields = parseItemFields(doc["SharedFields"]);
+    const { unversioned, versions } = parseLanguages(doc["Languages"]);
+    const database = doc["DB"] ? String(doc["DB"]) : undefined;
+    const itemPath = item_path_1.ItemPath.fromPathString(pathValue);
+    const item = {
+        id,
+        parentId,
+        templateId,
+        path: itemPath,
+        dataSignature: "",
+        name: itemPath.itemName ?? "",
+        database,
+        branchId,
+        sharedFields,
+        unversionedFields: unversioned,
+        versions,
+    };
+    const signatureBase = (0, signature_1.createDataSignatureBase)(item);
+    item.dataSignature = (0, signature_1.createSignature)(signatureBase) ?? "";
+    return item;
+};
+exports.readItemYamlFromString = readItemYamlFromString;
+const readItemYaml = async (filePath) => {
+    const content = await promises_1.default.readFile(filePath, "utf8");
+    return (0, exports.readItemYamlFromString)(content);
+};
+exports.readItemYaml = readItemYaml;
+const writeItemYaml = (item) => {
+    const writer = new YamlWriter();
+    writer.writeBeginNewDocument();
+    writer.writeMap("ID", item.id);
+    writer.writeMap("Parent", item.parentId);
+    writer.writeMap("Template", item.templateId);
+    writer.writeMap("Path", item.path.toPathString());
+    if (item.branchId) {
+        writer.writeMap("BranchID", item.branchId);
+    }
+    if (item.sharedFields.length > 0) {
+        writer.writeMap("SharedFields");
+        writer.increaseIndent();
+        const fields = [...item.sharedFields].sort((a, b) => a.fieldId.localeCompare(b.fieldId));
+        for (const field of fields) {
+            writer.writeBeginListItem("ID", field.fieldId);
+            writer.writeMap("Hint", field.nameHint ?? undefined);
+            if (field.blobId) {
+                writer.writeMap("BlobID", field.blobId);
+            }
+            writer.writeMap("Value", field.value ?? "");
+        }
+        writer.decreaseIndent();
+    }
+    if (item.unversionedFields.length > 0 || item.versions.length > 0) {
+        writer.writeMap("Languages");
+        writer.increaseIndent();
+        const languages = [...item.unversionedFields].map((language) => language.language);
+        for (const version of item.versions) {
+            if (!languages.includes(version.language)) {
+                languages.push(version.language);
+            }
+        }
+        languages.sort((a, b) => a.localeCompare(b));
+        for (const language of languages) {
+            const unversioned = item.unversionedFields.find((entry) => entry.language === language);
+            const languageVersions = item.versions
+                .filter((entry) => entry.language === language)
+                .sort((a, b) => a.version - b.version);
+            writer.writeBeginListItem("Language", language);
+            if (unversioned && unversioned.fields.length > 0) {
+                writer.writeMap("Fields");
+                writer.increaseIndent();
+                for (const field of unversioned.fields.sort((a, b) => a.fieldId.localeCompare(b.fieldId))) {
+                    writer.writeBeginListItem("ID", field.fieldId);
+                    if (field.nameHint) {
+                        writer.writeMap("Hint", field.nameHint);
+                    }
+                    if (field.blobId) {
+                        writer.writeMap("BlobID", field.blobId);
+                    }
+                    writer.writeMap("Value", field.value ?? "");
+                }
+                writer.decreaseIndent();
+            }
+            writer.writeMap("Versions");
+            writer.increaseIndent();
+            for (const version of languageVersions) {
+                writer.writeBeginListItem("Version", version.version.toString());
+                if (version.fields.length > 0) {
+                    writer.writeMap("Fields");
+                    writer.increaseIndent();
+                    for (const field of version.fields.sort((a, b) => a.fieldId.localeCompare(b.fieldId))) {
+                        writer.writeBeginListItem("ID", field.fieldId);
+                        if (field.nameHint) {
+                            writer.writeMap("Hint", field.nameHint);
+                        }
+                        if (field.blobId) {
+                            writer.writeMap("BlobID", field.blobId);
+                        }
+                        writer.writeMap("Value", field.value ?? "");
+                    }
+                    writer.decreaseIndent();
+                }
+            }
+            writer.decreaseIndent();
+        }
+        writer.decreaseIndent();
+    }
+    if (item.database) {
+        writer.writeMap("DB", item.database);
+    }
+    return writer.toString();
+};
+exports.writeItemYaml = writeItemYaml;
+const writeRoleYaml = (role) => {
+    const writer = new YamlWriter();
+    writer.writeBeginNewDocument();
+    writer.writeMap("Role", role.roleName);
+    if (role.memberOfRoles.length > 0) {
+        writer.writeMap("MemberOf");
+        writer.increaseIndent();
+        for (const member of role.memberOfRoles) {
+            writer.writeBeginListItem("Role", member);
+        }
+        writer.decreaseIndent();
+    }
+    return writer.toString();
+};
+exports.writeRoleYaml = writeRoleYaml;
+const readRoleYamlFromString = (content, serializedItemId) => {
+    const doc = yaml_1.default.parse(content);
+    const roleName = String(doc["Role"] ?? "");
+    const memberOf = Array.isArray(doc["MemberOf"])
+        ? doc["MemberOf"].map((entry) => String(entry["Role"] ?? entry ?? ""))
+        : [];
+    return { roleName, memberOfRoles: memberOf, serializedItemId };
+};
+exports.readRoleYamlFromString = readRoleYamlFromString;
+const readUserYamlFromString = (content, serializedItemId) => {
+    const doc = yaml_1.default.parse(content);
+    const roles = Array.isArray(doc["Roles"])
+        ? doc["Roles"].map((entry) => String(entry["MemberOf"] ?? entry ?? ""))
+        : [];
+    const properties = [];
+    if (Array.isArray(doc["Properties"])) {
+        for (const entry of doc["Properties"]) {
+            const record = entry;
+            properties.push({
+                name: String(record["Key"] ?? ""),
+                content: String(record["Value"] ?? ""),
+                contentType: String(record["ValueType"] ?? ""),
+                isCustomProperty: Boolean(record["IsCustomProperty"]),
+            });
+        }
+    }
+    return {
+        userName: String(doc["UserName"] ?? ""),
+        email: doc["Email"] ? String(doc["Email"]) : undefined,
+        comment: doc["Comment"] ? String(doc["Comment"]) : undefined,
+        creationDate: String(doc["Created"] ?? ""),
+        isApproved: String(doc["IsApproved"] ?? "false").toLowerCase() === "true",
+        roles,
+        profileProperties: properties,
+        serializedItemId,
+    };
+};
+exports.readUserYamlFromString = readUserYamlFromString;
+const writeUserYaml = (user) => {
+    const writer = new YamlWriter();
+    writer.writeBeginNewDocument();
+    writer.writeMap("UserName", user.userName);
+    if (user.email) {
+        writer.writeMap("Email", user.email);
+    }
+    if (user.comment) {
+        writer.writeMap("Comment", user.comment);
+    }
+    writer.writeMap("Created", user.creationDate);
+    writer.writeMap("IsApproved", user.isApproved ? "true" : "false");
+    if (user.profileProperties.length > 0) {
+        writer.writeMap("Properties");
+        writer.increaseIndent();
+        for (const property of user.profileProperties) {
+            writer.writeBeginListItem("Key", property.name);
+            writer.writeMap("Value", property.content);
+            writer.writeMap("ValueType", property.contentType);
+            writer.writeMap("IsCustomProperty", property.isCustomProperty ? "true" : "false");
+        }
+        writer.decreaseIndent();
+    }
+    if (user.roles.length > 0) {
+        writer.writeMap("Roles");
+        writer.increaseIndent();
+        for (const role of user.roles) {
+            writer.writeBeginListItem("MemberOf", role);
+        }
+        writer.decreaseIndent();
+    }
+    return writer.toString();
+};
+exports.writeUserYaml = writeUserYaml;

package/dist/shared/browser.d.ts

@@ -0,0 +1,2 @@
+export declare const openBrowser: (url: string) => boolean;
+//# sourceMappingURL=browser.d.ts.map

package/dist/shared/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/shared/browser.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,OA2BzC,CAAC"}

package/dist/shared/browser.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = void 0;
+const node_child_process_1 = require("node:child_process");
+const openBrowser = (url) => {
+    try {
+        let command = "";
+        let args = [];
+        let shell = false;
+        if (process.platform === "darwin") {
+            command = "open";
+            args = [url];
+        }
+        else if (process.platform === "win32") {
+            command = "cmd";
+            args = ["/c", "start", "", url];
+            shell = true;
+        }
+        else {
+            command = "xdg-open";
+            args = [url];
+        }
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            stdio: "ignore",
+            detached: true,
+            shell,
+            windowsHide: true,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.openBrowser = openBrowser;

package/dist/shared/cli-options.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Neutral CLI option types shared across every command family
+ * (serialization, deploy, recipe, env). Family-specific option
+ * shapes live next to their tasks (`src/deploy/tasks/types.ts`,
+ * `src/serialization/tasks/types.ts`, etc.) and extend `CommonOptions`.
+ */
+export type CommonOptions = {
+    config?: string;
+    include?: string[];
+    exclude?: string[];
+    verbose?: boolean;
+    trace?: boolean;
+    json?: boolean;
+    quiet?: boolean;
+    logFile?: string;
+};
+//# sourceMappingURL=cli-options.d.ts.map

package/dist/shared/cli-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-options.d.ts","sourceRoot":"","sources":["../../src/shared/cli-options.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/shared/cli-options.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Neutral CLI option types shared across every command family
+ * (serialization, deploy, recipe, env). Family-specific option
+ * shapes live next to their tasks (`src/deploy/tasks/types.ts`,
+ * `src/serialization/tasks/types.ts`, etc.) and extend `CommonOptions`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/cli-tasks.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Neutral helpers shared across every CLI task family. Anything
+ * deploy-specific belongs in `src/deploy/tasks/shared.ts`; anything
+ * serialization-specific belongs in `src/serialization/tasks/shared.ts`.
+ */
+import type { RootConfiguration } from "../config";
+import { Logger } from "../shared/logger";
+import type { CommonOptions } from "./cli-options";
+export declare const toLogger: (options: CommonOptions) => Logger;
+export declare const applyIfDefined: <T>(target: T, key: keyof T, value: T[keyof T] | undefined) => void;
+export declare const inputError: (message: string, hint?: string) => Error;
+export declare const confirmDestructive: (message: string, force?: boolean) => Promise<boolean>;
+export declare const selectMatch: <T extends {
+    id?: string;
+    name?: string;
+    projectId?: string;
+    environmentId?: string;
+}>(list: T[], label: string, selection?: string) => T;
+export declare const selectFromList: <T extends {
+    id?: string;
+    name?: string;
+    projectId?: string;
+    environmentId?: string;
+}>(logger: Logger, label: string, list: T[]) => Promise<T>;
+export declare const resolveApiTimeoutMs: (root: RootConfiguration) => number | undefined;
+/**
+ * `Promise.all`-style fan-out, but with a concurrency cap. Use this when
+ * mapping over an unbounded list (recipe files, environment fetches,
+ * etc.) where `Promise.all(items.map(fn))` would race N parallel
+ * I/O calls — fine for small N, a footgun for workspaces with hundreds
+ * of items. Order of the returned array matches the input order.
+ *
+ * Defaults to 8: enough to saturate the file-system on a normal laptop,
+ * conservative enough not to thrash a slow disk or thunder-herd a remote
+ * API. Pass a lower limit when each task hits the same upstream.
+ */
+export declare const mapWithConcurrency: <T, R>(items: readonly T[], fn: (item: T, index: number) => Promise<R>, concurrency?: number) => Promise<R[]>;
+//# sourceMappingURL=cli-tasks.d.ts.map

package/dist/shared/cli-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-tasks.d.ts","sourceRoot":"","sources":["../../src/shared/cli-tasks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,eAAO,MAAM,QAAQ,GAAI,SAAS,aAAa,KAAG,MASjD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,KAAG,IAI1F,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,EAAE,OAAO,MAAM,KAAG,KACI,CAAC;AAEjE,eAAO,MAAM,kBAAkB,GAAU,SAAS,MAAM,EAAE,QAAQ,OAAO,KAAG,OAAO,CAAC,OAAO,CAU1F,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,CAAC,SAAS;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAEpF,MAAM,CAAC,EAAE,EACT,OAAO,MAAM,EACb,YAAY,MAAM,KACjB,CAsBF,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EAEpF,QAAQ,MAAM,EACd,OAAO,MAAM,EACb,MAAM,CAAC,EAAE,KACR,OAAO,CAAC,CAAC,CAgBX,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,MAAM,iBAAiB,KAAG,MAAM,GAAG,SAMtE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAU,CAAC,EAAE,CAAC,EAC3C,OAAO,SAAS,CAAC,EAAE,EACnB,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,oBAAe,KACd,OAAO,CAAC,CAAC,EAAE,CAcb,CAAC"}

package/dist/shared/cli-tasks.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Neutral helpers shared across every CLI task family. Anything
+ * deploy-specific belongs in `src/deploy/tasks/shared.ts`; anything
+ * serialization-specific belongs in `src/serialization/tasks/shared.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapWithConcurrency = exports.resolveApiTimeoutMs = exports.selectFromList = exports.selectMatch = exports.confirmDestructive = exports.inputError = exports.applyIfDefined = exports.toLogger = void 0;
+const logger_1 = require("../shared/logger");
+const prompt_1 = require("../shared/prompt");
+const errors_1 = require("../shared/errors");
+const toLogger = (options) => {
+    const logFile = options.logFile ?? process.env.SITECOREAI_LOG_FILE;
+    return new logger_1.Logger(Boolean(options.verbose), Boolean(options.trace), Boolean(options.json), Boolean(options.quiet), logFile);
+};
+exports.toLogger = toLogger;
+const applyIfDefined = (target, key, value) => {
+    if (value !== undefined) {
+        target[key] = value;
+    }
+};
+exports.applyIfDefined = applyIfDefined;
+const inputError = (message, hint) => (0, errors_1.createCliError)(message, "INPUT_INVALID", hint ? { hint } : {});
+exports.inputError = inputError;
+const confirmDestructive = async (message, force) => {
+    if (force) {
+        return true;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw (0, errors_1.createCliError)("Confirmation required for destructive action.", "INPUT_INVALID", {
+            hint: "Re-run with --force to skip the confirmation prompt.",
+        });
+    }
+    return (0, prompt_1.promptConfirm)(message, false);
+};
+exports.confirmDestructive = confirmDestructive;
+const selectMatch = (list, label, selection) => {
+    if (!selection) {
+        if (list.length === 1) {
+            return list[0];
+        }
+        throw (0, exports.inputError)(`${label} must be specified when multiple results are available: ${list
+            .map((item) => item.name ?? item.id ?? item.projectId ?? item.environmentId ?? "(unknown)")
+            .join(", ")}`);
+    }
+    const match = list.find((item) => item.id === selection ||
+        item.projectId === selection ||
+        item.environmentId === selection ||
+        (item.name && item.name.toLowerCase() === selection.toLowerCase()));
+    if (!match) {
+        throw (0, exports.inputError)(`${label} '${selection}' was not found.`);
+    }
+    return match;
+};
+exports.selectMatch = selectMatch;
+const selectFromList = async (logger, label, list) => {
+    if (list.length === 1) {
+        return list[0];
+    }
+    logger.info(`${label} choices:`, "cyan");
+    list.forEach((item, index) => {
+        const id = item.id ?? item.projectId ?? item.environmentId ?? "-";
+        const name = item.name ?? id;
+        logger.info(`  ${index + 1}) ${name} (${id})`);
+    });
+    const selection = await (0, prompt_1.promptText)(`${label} (number or id/name)`);
+    const index = Number(selection);
+    if (!Number.isNaN(index) && index >= 1 && index <= list.length) {
+        return list[index - 1];
+    }
+    return (0, exports.selectMatch)(list, label, selection);
+};
+exports.selectFromList = selectFromList;
+const resolveApiTimeoutMs = (root) => {
+    const minutes = root.settings.apiClientTimeoutInMinutes;
+    if (!Number.isFinite(minutes) || minutes <= 0) {
+        return undefined;
+    }
+    return minutes * 60 * 1000;
+};
+exports.resolveApiTimeoutMs = resolveApiTimeoutMs;
+/**
+ * `Promise.all`-style fan-out, but with a concurrency cap. Use this when
+ * mapping over an unbounded list (recipe files, environment fetches,
+ * etc.) where `Promise.all(items.map(fn))` would race N parallel
+ * I/O calls — fine for small N, a footgun for workspaces with hundreds
+ * of items. Order of the returned array matches the input order.
+ *
+ * Defaults to 8: enough to saturate the file-system on a normal laptop,
+ * conservative enough not to thrash a slow disk or thunder-herd a remote
+ * API. Pass a lower limit when each task hits the same upstream.
+ */
+const mapWithConcurrency = async (items, fn, concurrency = 8) => {
+    const results = new Array(items.length);
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+        while (true) {
+            const index = cursor++;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await fn(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+};
+exports.mapWithConcurrency = mapWithConcurrency;

package/dist/shared/config-template.d.ts

@@ -0,0 +1,23 @@
+export declare const SCHEMA_BASE_URL = "https://schemas.sitecoreai.dev/v1";
+export declare const DEFAULT_CONFIG: {
+    $schema: string;
+    modules: string[];
+    recipes: string[];
+    serialization: {
+        defaultMaxRelativeItemPathLength: number;
+        defaultModuleRelativeSerializationPath: string;
+        removeOrphansForRoles: boolean;
+        removeOrphansForUsers: boolean;
+        continueOnItemFailure: boolean;
+        excludedFields: never[];
+    };
+    settings: {
+        cacheAuthenticationToken: boolean;
+        versionComparisonEnabled: boolean;
+        apiClientTimeoutInMinutes: number;
+    };
+    envProfiles: {};
+};
+export declare const resolveTargetPath: (value?: string) => string;
+export declare const writeConfigTemplate: (targetPath: string) => void;
+//# sourceMappingURL=config-template.d.ts.map

package/dist/shared/config-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-template.d.ts","sourceRoot":"","sources":["../../src/shared/config-template.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,sCAAsC,CAAC;AAEnE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;CAkB1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,KAAG,MAGlD,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,IAGxD,CAAC"}

package/dist/shared/config-template.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeConfigTemplate = exports.resolveTargetPath = exports.DEFAULT_CONFIG = exports.SCHEMA_BASE_URL = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.SCHEMA_BASE_URL = "https://schemas.sitecoreai.dev/v1";
+exports.DEFAULT_CONFIG = {
+    $schema: `${exports.SCHEMA_BASE_URL}/sitecoreai.cli.json`,
+    modules: ["./**/*.module.json"],
+    recipes: ["recipes/**/*.recipe.ts"],
+    serialization: {
+        defaultMaxRelativeItemPathLength: 120,
+        defaultModuleRelativeSerializationPath: "serialization",
+        removeOrphansForRoles: true,
+        removeOrphansForUsers: true,
+        continueOnItemFailure: false,
+        excludedFields: [],
+    },
+    settings: {
+        cacheAuthenticationToken: true,
+        versionComparisonEnabled: true,
+        apiClientTimeoutInMinutes: 5,
+    },
+    envProfiles: {},
+};
+const resolveTargetPath = (value) => {
+    const target = value ? node_path_1.default.resolve(value) : process.cwd();
+    return node_path_1.default.extname(target) === ".json" ? target : node_path_1.default.join(target, "sitecoreai.cli.json");
+};
+exports.resolveTargetPath = resolveTargetPath;
+const writeConfigTemplate = (targetPath) => {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+    node_fs_1.default.writeFileSync(targetPath, JSON.stringify(exports.DEFAULT_CONFIG, null, 2), "utf8");
+};
+exports.writeConfigTemplate = writeConfigTemplate;