@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/serialization/tasks/env/init/deploy-lookup.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDeployLookup = void 0;
+const api_1 = require("../../../../deploy/api");
+const cli_tasks_1 = require("../../../../shared/cli-tasks");
+const shared_1 = require("../../../../deploy/tasks/shared");
+const prompt_1 = require("../../../../shared/prompt");
+const errors_1 = require("../../../../shared/errors");
+const hasProjectRepository = (value) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    const candidates = [
+        record.repositoryId,
+        record.repositoryName,
+        record.repositoryRelativePath,
+        record.repositoryUrl,
+        record.sourceControlIntegrationId,
+        record.sourceControlIntegration,
+        record.repository,
+        record.repo,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim().length > 0) {
+            return true;
+        }
+        if (candidate && typeof candidate === "object") {
+            const nested = candidate;
+            const nestedCandidates = [
+                nested.id,
+                nested.name,
+                nested.repositoryId,
+                nested.repositoryName,
+                nested.url,
+            ];
+            if (nestedCandidates.some((entry) => typeof entry === "string" && entry.trim().length > 0)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const resolveDeployLookup = async (input) => {
+    const { options, runWizard, deployToken, updated, existing, baseEnv, host, projectSelection, environmentSelection, logger, } = input;
+    if (!deployToken) {
+        throw (0, errors_1.createCliError)("Deploy API access token is required. Provide --deploy-token or deploy credentials.", "AUTH_REQUIRED", {
+            hint: "Provide --deploy-token, or run 'scai login' to store credentials.",
+        });
+    }
+    const deployOptions = { accessToken: deployToken };
+    let resolvedEnvironment;
+    let nextHost = host;
+    try {
+        const organization = await (0, api_1.fetchOrganization)(deployOptions);
+        const orgId = organization.id ?? organization.organizationId ?? options.organizationId;
+        const projects = await (0, api_1.fetchProjects)(deployOptions);
+        let resolvedProject;
+        let environments = [];
+        let resolvedProjectId = "";
+        let resolvedProjectLabel = "selected project";
+        let projectDetails;
+        let selectedProjectValue = projectSelection;
+        while (true) {
+            if (!selectedProjectValue && runWizard && projects.length > 1) {
+                resolvedProject = await (0, cli_tasks_1.selectFromList)(logger, "Project", projects);
+            }
+            else {
+                resolvedProject = (0, cli_tasks_1.selectMatch)(projects, "Project", selectedProjectValue);
+            }
+            resolvedProjectId = resolvedProject.id ?? resolvedProject.projectId ?? "";
+            resolvedProjectLabel =
+                resolvedProject.name ??
+                    resolvedProject.id ??
+                    resolvedProject.projectId ??
+                    "selected project";
+            environments = await (0, api_1.fetchProjectEnvironments)(deployOptions, resolvedProjectId);
+            if (environments.length > 0) {
+                break;
+            }
+            if (!runWizard) {
+                throw (0, cli_tasks_1.inputError)(`No environments were returned for project '${resolvedProjectLabel}'.`);
+            }
+            if (!projectDetails) {
+                try {
+                    projectDetails = await (0, api_1.fetchProject)(deployOptions, resolvedProjectId);
+                }
+                catch (error) {
+                    const cliError = (0, errors_1.toCliError)(error);
+                    logger.warn(`Unable to verify repository linkage. ${cliError.message}`);
+                }
+            }
+            if (!hasProjectRepository(projectDetails ?? resolvedProject)) {
+                logger.warn(`Project '${resolvedProjectLabel}' is not linked to a repository. Environment creation requires a repository.`);
+                if (projects.length > 1) {
+                    const chooseAnother = await (0, prompt_1.promptConfirm)("Select a different project?", true);
+                    if (chooseAnother) {
+                        selectedProjectValue = undefined;
+                        projectDetails = undefined;
+                        continue;
+                    }
+                }
+                let environmentId = updated.environmentId ??
+                    existing.environmentId ??
+                    baseEnv.environmentId ??
+                    options.environment;
+                if (!environmentId) {
+                    environmentId = await (0, prompt_1.promptText)("Environment ID (Deploy)");
+                }
+                if (!environmentId) {
+                    throw (0, cli_tasks_1.inputError)("Environment ID is required. Use --environment <id>.");
+                }
+                resolvedEnvironment = await (0, api_1.fetchEnvironment)(deployOptions, environmentId);
+                const projectIdFromEnvironment = (0, shared_1.resolveProjectIdValue)(resolvedEnvironment.projectId);
+                if (projectIdFromEnvironment) {
+                    resolvedProject = {
+                        ...(resolvedProject ?? {}),
+                        id: projectIdFromEnvironment,
+                        projectId: projectIdFromEnvironment,
+                    };
+                }
+                break;
+            }
+            const shouldCreate = await (0, prompt_1.promptConfirm)(`No environments found for project '${resolvedProjectLabel}'. Create one now?`, false);
+            if (shouldCreate) {
+                const name = await (0, prompt_1.promptText)("Environment name");
+                if (!name) {
+                    throw (0, cli_tasks_1.inputError)("Environment name is required. Use --name.");
+                }
+                const cmOnly = await (0, prompt_1.promptConfirm)("Create a CM-only environment?", true);
+                let tenantType;
+                while (tenantType === undefined) {
+                    const tenantInput = await (0, prompt_1.promptText)("Tenant type (prod/nonprod)", "nonprod");
+                    const resolvedTenantType = (0, shared_1.resolveTenantTypeValue)(tenantInput);
+                    if (resolvedTenantType !== undefined) {
+                        tenantType = resolvedTenantType;
+                        break;
+                    }
+                    logger.warn("Invalid tenant type. Use 'prod' or 'nonprod'.");
+                }
+                const body = { name };
+                if (tenantType !== undefined) {
+                    body.tenantType = tenantType;
+                }
+                body.type = cmOnly ? "cm" : "combined";
+                try {
+                    const created = (await (0, api_1.createProjectEnvironment)(deployOptions, resolvedProjectId, body));
+                    resolvedEnvironment = created;
+                    environments = await (0, api_1.fetchProjectEnvironments)(deployOptions, resolvedProjectId);
+                    break;
+                }
+                catch (error) {
+                    const cliError = (0, errors_1.toCliError)(error);
+                    logger.warn(`Environment creation failed. ${cliError.message}`);
+                    if (projects.length > 1) {
+                        const chooseAnother = await (0, prompt_1.promptConfirm)("Select a different project?", true);
+                        if (chooseAnother) {
+                            selectedProjectValue = undefined;
+                            projectDetails = undefined;
+                            continue;
+                        }
+                    }
+                    throw error;
+                }
+            }
+            if (projects.length <= 1) {
+                throw (0, cli_tasks_1.inputError)(`No environments were returned for project '${resolvedProjectLabel}'.`);
+            }
+            selectedProjectValue = undefined;
+        }
+        const cmEnvironments = environments.filter((environment) => {
+            const type = (0, shared_1.getEnvironmentType)(environment);
+            return type ? type.toLowerCase().includes("cm") : false;
+        });
+        const selectionPool = !environmentSelection && cmEnvironments.length > 0 ? cmEnvironments : environments;
+        const environmentLabel = !environmentSelection && cmEnvironments.length > 0 ? "Environment (CM)" : "Environment";
+        if (!resolvedEnvironment) {
+            if (!environmentSelection && runWizard && selectionPool.length > 1) {
+                resolvedEnvironment = await (0, cli_tasks_1.selectFromList)(logger, environmentLabel, selectionPool);
+            }
+            else {
+                resolvedEnvironment = (0, cli_tasks_1.selectMatch)(selectionPool, "Environment", environmentSelection);
+            }
+        }
+        const editingHostEnvironmentIds = environments
+            .filter((environment) => {
+            const type = (0, shared_1.getEnvironmentType)(environment);
+            return type ? type.toLowerCase().includes("eh") : false;
+        })
+            .map((environment) => environment.id ?? environment.environmentId)
+            .filter((value) => Boolean(value));
+        updated.organizationId = orgId ?? updated.organizationId;
+        updated.projectId = resolvedProject.id ?? resolvedProject.projectId ?? updated.projectId;
+        updated.environmentId =
+            resolvedEnvironment.id ?? resolvedEnvironment.environmentId ?? updated.environmentId;
+        updated.tenantId = resolvedEnvironment.tenantId ?? updated.tenantId ?? organization.tenantId;
+        const resolvedType = (0, shared_1.getEnvironmentType)(resolvedEnvironment);
+        if (resolvedType === "cm" || resolvedType === "eh") {
+            updated.environmentType = resolvedType;
+        }
+        if (editingHostEnvironmentIds.length > 0) {
+            updated.editingHostEnvironmentIds = editingHostEnvironmentIds;
+        }
+        if (!nextHost) {
+            nextHost = (0, api_1.resolveHostFromEnvironment)(resolvedEnvironment);
+        }
+    }
+    catch (error) {
+        if (!runWizard) {
+            throw error;
+        }
+        const cliError = (0, errors_1.toCliError)(error);
+        const isEnvScoped = /environment[- ]scoped/i.test(cliError.message);
+        const warning = isEnvScoped
+            ? "Deploy lookup failed. Environment-scoped credentials require an environment ID."
+            : `Deploy lookup failed. ${cliError.message}`;
+        logger.warn(warning);
+        let environmentId = updated.environmentId ??
+            existing.environmentId ??
+            baseEnv.environmentId ??
+            options.environment;
+        if (!environmentId) {
+            environmentId = await (0, prompt_1.promptText)("Environment ID (Deploy)");
+        }
+        if (!environmentId) {
+            throw (0, cli_tasks_1.inputError)("Environment ID is required for environment-scoped credentials. Use --environment <id>.");
+        }
+        resolvedEnvironment = await (0, api_1.fetchEnvironment)(deployOptions, environmentId);
+        logger.warn("Environment-scoped credentials can limit some CLI operations (org/project lookups).");
+        updated.environmentId =
+            resolvedEnvironment.id ?? resolvedEnvironment.environmentId ?? updated.environmentId;
+        updated.projectId = (0, shared_1.resolveProjectIdValue)(resolvedEnvironment.projectId) ?? updated.projectId;
+        updated.tenantId = resolvedEnvironment.tenantId ?? updated.tenantId;
+        const resolvedType = (0, shared_1.getEnvironmentType)(resolvedEnvironment);
+        if (resolvedType === "cm" || resolvedType === "eh") {
+            updated.environmentType = resolvedType;
+        }
+        if (!nextHost) {
+            nextHost = (0, api_1.resolveHostFromEnvironment)(resolvedEnvironment);
+        }
+    }
+    return { host: nextHost, updated };
+};
+exports.resolveDeployLookup = resolveDeployLookup;

package/dist/serialization/tasks/env/init.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectOptions } from "../types";
+export declare const runInit: (options: ConnectOptions) => Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/serialization/tasks/env/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/serialization/tasks/env/init.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI/C,eAAO,MAAM,OAAO,GAAU,SAAS,cAAc,KAAG,OAAO,CAAC,IAAI,CA8QnE,CAAC"}

package/dist/serialization/tasks/env/init.js

@@ -0,0 +1,253 @@
+"use strict";
+// TODO(recipe-init): when the wizard runs in a non-default project layout,
+// auto-detect `*.recipe.ts` files and offer to set the `recipes` glob in
+// sitecoreai.cli.json accordingly. Today the default config template ships
+// `recipes: ["recipes/**/*.recipe.ts"]`; users with recipes elsewhere edit
+// the file by hand. Worth adding once orchestrator-mediated installs land
+// (Phase 3) — until then, agent-mediated installs control the layout.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("../../../config");
+const validate_1 = require("../../../shared/validate");
+const config_template_1 = require("../../../shared/config-template");
+const keychain_1 = require("../../../shared/keychain");
+const prompt_1 = require("../../../shared/prompt");
+const errors_1 = require("../../../shared/errors");
+const shared_1 = require("../shared");
+const auth_1 = require("./init/auth");
+const deploy_lookup_1 = require("./init/deploy-lookup");
+const runInit = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY && process.env.SITECOREAI_NON_INTERACTIVE !== "1";
+    const hasExplicitInput = Boolean(options.environmentName ||
+        options.cm ||
+        options.host ||
+        options.ref ||
+        options.allowWrite !== undefined ||
+        options.organizationId ||
+        options.tenantId ||
+        options.organization ||
+        options.project ||
+        options.environment ||
+        options.deployToken ||
+        options.clientId ||
+        options.clientSecret ||
+        options.useClientCredentials !== undefined ||
+        options.setDefault);
+    const runWizard = Boolean(options.wizard || !hasExplicitInput);
+    if (runWizard && !isInteractive) {
+        (0, prompt_1.assertInteractive)("Wizard mode requires a TTY. Provide flags instead.", "Provide flags instead.");
+    }
+    let envName = options.environmentName;
+    const reservedName = "default";
+    if (!envName) {
+        if (!runWizard) {
+            throw (0, shared_1.inputError)("Environment name is required. Use --environment-name.");
+        }
+        envName = await (0, prompt_1.promptText)("Environment name (local label; does not need to match SitecoreAI)");
+        if (!envName) {
+            throw (0, shared_1.inputError)("Environment name is required.");
+        }
+    }
+    if (runWizard && envName.toLowerCase() === reservedName) {
+        envName = "";
+    }
+    const configPath = options.config ?? process.cwd();
+    const targetPath = (0, config_template_1.resolveTargetPath)(configPath);
+    if (!node_fs_1.default.existsSync(targetPath)) {
+        (0, config_template_1.writeConfigTemplate)(targetPath);
+        logger.info(`Created ${targetPath}`, "green");
+    }
+    let rootConfigFile;
+    try {
+        rootConfigFile = (0, config_1.readRootConfigurationFile)(configPath);
+    }
+    catch (error) {
+        const cliError = (0, errors_1.toCliError)(error);
+        if (cliError.code === "CONFIG_INVALID" && runWizard && isInteractive) {
+            const recreate = await (0, prompt_1.promptConfirm)(`Configuration file at ${targetPath} is invalid. Recreate it?`, false);
+            if (!recreate) {
+                logger.info("Init cancelled. No changes were made.");
+                return;
+            }
+            if (node_fs_1.default.existsSync(targetPath)) {
+                const timestamp = new Date().toISOString().replace(/[-:.TZ]/g, "");
+                const backupPath = `${targetPath}.invalid-${timestamp}`;
+                node_fs_1.default.renameSync(targetPath, backupPath);
+                logger.warn(`Backed up invalid config to ${backupPath}`);
+            }
+            (0, config_template_1.writeConfigTemplate)(targetPath);
+            logger.info(`Recreated ${targetPath}`, "green");
+            rootConfigFile = (0, config_1.readRootConfigurationFile)(configPath);
+        }
+        else {
+            throw error;
+        }
+    }
+    const envProfiles = rootConfigFile.config.envProfiles ?? {};
+    let root = (0, config_1.readRootConfiguration)(configPath, envName);
+    let existing = envProfiles[envName] ?? {};
+    let envExists = Boolean(envProfiles[envName]);
+    let baseEnv = root.environments[envName] ?? {};
+    const hasOtherChanges = Boolean(options.cm || options.host || options.organization || options.project || options.environment) ||
+        Boolean(options.deployToken || options.clientId || options.clientSecret) ||
+        Boolean(options.useClientCredentials || options.ref || options.allowWrite) ||
+        Boolean(options.organizationId || options.tenantId);
+    if (envExists && runWizard) {
+        while (envExists || envName.toLowerCase() === reservedName) {
+            if (envName.toLowerCase() === reservedName) {
+                const newName = await (0, prompt_1.promptText)("Environment name cannot be 'default'. Choose another name");
+                if (!newName) {
+                    logger.info("Init cancelled. No changes were made.");
+                    return;
+                }
+                envName = newName;
+                root = (0, config_1.readRootConfiguration)(configPath, envName);
+                existing = envProfiles[envName] ?? {};
+                envExists = Boolean(envProfiles[envName]);
+                baseEnv = root.environments[envName] ?? {};
+                continue;
+            }
+            const overwrite = await (0, prompt_1.promptConfirm)(`Environment '${envName}' already exists. Overwrite?`, false);
+            if (overwrite) {
+                break;
+            }
+            const newName = await (0, prompt_1.promptText)("Choose a different environment name (local label; does not need to match SitecoreAI)");
+            if (!newName) {
+                logger.info("Init cancelled. No changes were made.");
+                return;
+            }
+            envName = newName;
+            root = (0, config_1.readRootConfiguration)(configPath, envName);
+            existing = envProfiles[envName] ?? {};
+            envExists = Boolean(envProfiles[envName]);
+            baseEnv = root.environments[envName] ?? {};
+        }
+    }
+    else if (envExists && !runWizard && hasOtherChanges) {
+        logger.warn(`Environment '${envName}' already exists and will be updated.`);
+    }
+    if (options.setDefault && !hasOtherChanges) {
+        if (!envProfiles[envName]) {
+            throw (0, errors_1.createCliError)(`Environment '${envName}' does not exist. Configure it before setting default.`, "ENV_NOT_FOUND");
+        }
+        rootConfigFile.config.defaultEnvProfile = envName;
+        (0, config_1.writeRootConfigurationFile)(configPath, rootConfigFile.config);
+        logger.info(`Default environment set to '${envName}'.`, "green");
+        return;
+    }
+    if (options.ref) {
+        const refEnv = envProfiles[options.ref];
+        if (!refEnv) {
+            throw (0, errors_1.createCliError)(`Referenced environment '${options.ref}' was not found.`, "ENV_NOT_FOUND");
+        }
+        if (refEnv.ref) {
+            throw (0, shared_1.inputError)(`Referenced environment '${options.ref}' cannot itself reference another environment.`);
+        }
+    }
+    const updated = { ...existing };
+    let host = options.cm ?? options.host ?? existing.host;
+    let projectSelection = options.project;
+    let environmentSelection = options.environment;
+    const skipDeployLookup = Boolean(options.skipDeployLookup) || process.env.SITECOREAI_SKIP_DEPLOY_LOOKUP === "1";
+    let needsDeployLookup = Boolean(options.organization || projectSelection || environmentSelection);
+    if (skipDeployLookup) {
+        needsDeployLookup = false;
+    }
+    if (runWizard && !needsDeployLookup && !skipDeployLookup) {
+        needsDeployLookup = true;
+    }
+    let needsDeployToken = needsDeployLookup || Boolean(options.deployToken || options.clientId || options.clientSecret);
+    if (runWizard) {
+        needsDeployToken = true;
+    }
+    const auth = await (0, auth_1.resolveDeployAuth)({
+        options,
+        envName,
+        existing,
+        baseEnv,
+        runWizard,
+        isInteractive,
+        needsDeployToken,
+        updated,
+        logger,
+    });
+    let deployToken = auth.deployToken;
+    const loginAuthority = auth.loginAuthority;
+    const loginClientId = auth.loginClientId;
+    const wantsClientCredentials = auth.wantsClientCredentials;
+    const shouldPersistClientId = auth.shouldPersistClientId;
+    if (needsDeployLookup) {
+        const lookup = await (0, deploy_lookup_1.resolveDeployLookup)({
+            options,
+            runWizard,
+            deployToken,
+            updated,
+            existing,
+            baseEnv,
+            host,
+            projectSelection,
+            environmentSelection,
+            logger,
+        });
+        host = lookup.host;
+    }
+    if (needsDeployToken && deployToken) {
+        const stored = await (0, keychain_1.setDeployToken)(envName, deployToken);
+        if (!stored) {
+            logger.warn("Unable to store the Deploy token in the OS keychain. Use SITECOREAI_DEPLOY_TOKEN if needed.");
+        }
+    }
+    if (!host && runWizard) {
+        host = await (0, prompt_1.promptText)("CM host (base URL)", host);
+    }
+    if (!host) {
+        throw (0, shared_1.inputError)("Environment host is required. Use --cm/--host or select it via Deploy.");
+    }
+    (0, validate_1.assertValidHost)(host, "CM host");
+    updated.host = host;
+    if (!updated.authority) {
+        updated.authority = loginAuthority;
+    }
+    if (loginClientId) {
+        if (wantsClientCredentials) {
+            updated.clientId = loginClientId;
+        }
+        else if (!updated.clientId && shouldPersistClientId) {
+            updated.clientId = loginClientId;
+        }
+    }
+    (0, shared_1.applyIfDefined)(updated, "ref", options.ref);
+    if (options.allowWrite !== undefined) {
+        updated.allowWrite = options.allowWrite;
+    }
+    else if (runWizard) {
+        updated.allowWrite = await (0, prompt_1.promptConfirm)("Allow write operations?", false);
+    }
+    (0, shared_1.applyIfDefined)(updated, "organizationId", options.organizationId);
+    (0, shared_1.applyIfDefined)(updated, "tenantId", options.tenantId);
+    (0, shared_1.applyIfDefined)(updated, "clientId", options.clientId);
+    if (wantsClientCredentials) {
+        updated.useClientCredentials = true;
+    }
+    rootConfigFile.config.envProfiles = {
+        ...envProfiles,
+        [envName]: updated,
+    };
+    if (options.setDefault || (!rootConfigFile.config.defaultEnvProfile && !runWizard)) {
+        rootConfigFile.config.defaultEnvProfile = envName;
+    }
+    else if (runWizard) {
+        const shouldSetDefault = await (0, prompt_1.promptConfirm)("Set as default environment?", !rootConfigFile.config.defaultEnvProfile);
+        if (shouldSetDefault) {
+            rootConfigFile.config.defaultEnvProfile = envName;
+        }
+    }
+    (0, config_1.writeRootConfigurationFile)(configPath, rootConfigFile.config);
+    logger.info(`Initialized environment '${envName}' in sitecoreai.cli.json`, "green");
+};
+exports.runInit = runInit;

package/dist/serialization/tasks/env/logout.d.ts

@@ -0,0 +1,3 @@
+import type { LogoutOptions } from "../types";
+export declare const runLogout: (options: LogoutOptions) => Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/serialization/tasks/env/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../../../src/serialization/tasks/env/logout.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,eAAO,MAAM,SAAS,GAAU,SAAS,aAAa,KAAG,OAAO,CAAC,IAAI,CAyDpE,CAAC"}

package/dist/serialization/tasks/env/logout.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLogout = void 0;
+const config_1 = require("../../../config");
+const keychain_1 = require("../../../shared/keychain");
+const errors_1 = require("../../../shared/errors");
+const shared_1 = require("../shared");
+const runLogout = async (options) => {
+    const logger = (0, shared_1.toLogger)(options);
+    const configPath = options.config ?? process.cwd();
+    const rootConfigFile = (0, config_1.readRootConfigurationFile)(configPath);
+    const envProfiles = rootConfigFile.config.envProfiles ?? {};
+    const names = Object.keys(envProfiles);
+    if (options.all) {
+        for (const name of names) {
+            const env = envProfiles[name];
+            envProfiles[name] = {
+                ...env,
+                accessToken: undefined,
+                refreshToken: undefined,
+                refreshTokenParameters: undefined,
+                expiresIn: undefined,
+                lastUpdated: undefined,
+                deployToken: undefined,
+                deployTokenExpiresIn: undefined,
+                deployTokenLastUpdated: undefined,
+            };
+            await (0, keychain_1.clearCmTokens)(name);
+            await (0, keychain_1.clearDeployToken)(name);
+        }
+        rootConfigFile.config.envProfiles = envProfiles;
+        (0, config_1.writeRootConfigurationFile)(configPath, rootConfigFile.config);
+        logger.info("Cleared stored tokens for all environments.", "green");
+        return;
+    }
+    const envName = options.environmentName;
+    if (!envName) {
+        throw (0, errors_1.createCliError)("Environment name is required. Use --environment-name or --all.", "INPUT_INVALID");
+    }
+    const env = envProfiles[envName];
+    if (!env) {
+        throw (0, errors_1.createCliError)(`Environment '${envName}' does not exist.`, "ENV_NOT_FOUND");
+    }
+    envProfiles[envName] = {
+        ...env,
+        accessToken: undefined,
+        refreshToken: undefined,
+        refreshTokenParameters: undefined,
+        expiresIn: undefined,
+        lastUpdated: undefined,
+        deployToken: undefined,
+        deployTokenExpiresIn: undefined,
+        deployTokenLastUpdated: undefined,
+    };
+    await (0, keychain_1.clearCmTokens)(envName);
+    await (0, keychain_1.clearDeployToken)(envName);
+    rootConfigFile.config.envProfiles = envProfiles;
+    (0, config_1.writeRootConfigurationFile)(configPath, rootConfigFile.config);
+    logger.info(`Cleared stored tokens for environment '${envName}'.`, "green");
+};
+exports.runLogout = runLogout;

package/dist/serialization/tasks/env/status.d.ts

@@ -0,0 +1,3 @@
+import type { CommonOptions } from "../types";
+export declare const runStatus: (options: CommonOptions) => Promise<void>;
+//# sourceMappingURL=status.d.ts.map

package/dist/serialization/tasks/env/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../src/serialization/tasks/env/status.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,eAAO,MAAM,SAAS,GAAU,SAAS,aAAa,KAAG,OAAO,CAAC,IAAI,CAwJpE,CAAC"}