@nocobase/cli 2.1.0-beta.44.test.3 → 2.1.0-beta.44.test.4

package/dist/lib/app-runtime.js

@@ -1,189 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-import path from 'node:path';
-import { resolveEnvKind } from './auth-store.js';
-import { getEnv, loadAuthConfig } from './auth-store.js';
-import { DEFAULT_DOCKER_CONTAINER_PREFIX, DEFAULT_DOCKER_NETWORK, getEffectiveCliConfigValue, } from './cli-config.js';
-import { resolveManagedLocalEnvFilePath } from './managed-env-file.js';
-import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
-import { buildRuntimeEnvVars } from './runtime-env-vars.js';
-const DOCKER_APP_WORKDIR = '/app/nocobase';
-function sanitizeDockerResourceName(value) {
-    const normalized = value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_.-]+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return normalized || 'nocobase';
-}
-export function defaultWorkspaceName(cwd = process.cwd()) {
-    return sanitizeDockerResourceName(`nb-${path.basename(cwd)}`);
-}
-export function defaultDockerContainerPrefix(cwd = process.cwd()) {
-    const configured = String(DEFAULT_DOCKER_CONTAINER_PREFIX ?? '').trim();
-    if (configured) {
-        return sanitizeDockerResourceName(configured);
-    }
-    return defaultWorkspaceName(cwd);
-}
-export function defaultDockerNetworkName() {
-    return sanitizeDockerResourceName(DEFAULT_DOCKER_NETWORK);
-}
-export function buildDockerAppContainerName(envName, containerPrefix) {
-    const prefix = containerPrefix?.trim() || defaultDockerContainerPrefix();
-    return sanitizeDockerResourceName(`${prefix}-${envName}-app`);
-}
-export function buildDockerDbContainerName(envName, dbDialect, containerPrefix) {
-    const prefix = containerPrefix?.trim() || defaultDockerContainerPrefix();
-    const dialect = dbDialect.trim() || 'postgres';
-    return sanitizeDockerResourceName(`${prefix}-${envName}-${dialect}`);
-}
-function normalizeEnvSource(env) {
-    const source = String(env.config.source ?? '').trim();
-    if (source === 'docker' || source === 'npm' || source === 'git') {
-        return source;
-    }
-    const kind = resolveEnvKind(env.config);
-    if (kind === 'local') {
-        return 'local';
-    }
-    return undefined;
-}
-export async function resolveManagedAppRuntime(envName) {
-    const config = await loadAuthConfig();
-    const env = await getEnv(envName, { config });
-    if (!env) {
-        return undefined;
-    }
-    const resolvedName = env.name || envName?.trim() || config.lastEnv || 'default';
-    const source = normalizeEnvSource(env);
-    const dockerNetworkName = sanitizeDockerResourceName(getEffectiveCliConfigValue(config, 'docker.network') || defaultDockerNetworkName());
-    const dockerContainerPrefix = sanitizeDockerResourceName(getEffectiveCliConfigValue(config, 'docker.container-prefix') || defaultDockerContainerPrefix());
-    const kind = env.kind ?? resolveEnvKind(env.config);
-    if (kind === 'docker') {
-        return {
-            kind: 'docker',
-            env,
-            envName: resolvedName,
-            source: 'docker',
-            dockerNetworkName,
-            dockerContainerPrefix,
-            workspaceName: dockerNetworkName,
-            containerName: buildDockerAppContainerName(resolvedName, dockerContainerPrefix),
-        };
-    }
-    if (kind === 'local') {
-        return {
-            kind: 'local',
-            env,
-            envName: resolvedName,
-            source: source === 'git' ? 'git' : source === 'npm' ? 'npm' : 'local',
-            projectRoot: env.sourcePath,
-            dockerNetworkName,
-            dockerContainerPrefix,
-            workspaceName: dockerNetworkName,
-        };
-    }
-    if (kind === 'ssh') {
-        return {
-            kind: 'ssh',
-            env,
-            envName: resolvedName,
-            source,
-        };
-    }
-    return {
-        kind: 'http',
-        env,
-        envName: resolvedName,
-        source,
-    };
-}
-export function formatMissingManagedAppEnvMessage(envName) {
-    const requested = String(envName ?? '').trim();
-    if (requested) {
-        return [
-            `Env "${requested}" is not configured in this workspace.`,
-            `If you want to create a new NocoBase AI environment, run \`nb init --ui --env ${requested}\` first.`,
-        ].join('\n');
-    }
-    return 'No NocoBase env is configured yet. Run `nb init --ui` to create one first.';
-}
-export function managedAppLifecycleEnvVars() {
-    return {
-        APP_ENV: 'production',
-        NODE_ENV: 'production',
-    };
-}
-export async function runLocalNocoBaseCommand(runtime, args, options) {
-    const envVars = await buildRuntimeEnvVars(runtime);
-    const appEnvPath = resolveManagedLocalEnvFilePath(runtime);
-    await runNocoBaseCommand(args, {
-        cwd: runtime.projectRoot,
-        env: {
-            ...envVars,
-            APP_ENV_PATH: appEnvPath,
-            ...options?.env,
-        },
-        stdio: options?.stdio,
-        onStdout: options?.onStdout,
-        onStderr: options?.onStderr,
-    });
-}
-export async function dockerContainerExists(containerName) {
-    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
-}
-export async function dockerContainerIsRunning(containerName) {
-    try {
-        const output = await commandOutput('docker', ['inspect', '--format', '{{.State.Running}}', containerName], { errorName: 'docker inspect' });
-        return output.trim() === 'true';
-    }
-    catch (_error) {
-        return false;
-    }
-}
-export async function startDockerContainer(containerName, options) {
-    const exists = await dockerContainerExists(containerName);
-    if (!exists) {
-        throw new Error(`Docker app container "${containerName}" does not exist.`);
-    }
-    if (await dockerContainerIsRunning(containerName)) {
-        return 'already-running';
-    }
-    await run('docker', ['start', containerName], {
-        errorName: 'docker start',
-        stdio: options?.stdio,
-    });
-    return 'started';
-}
-export async function stopDockerContainer(containerName, options) {
-    const exists = await dockerContainerExists(containerName);
-    if (!exists) {
-        throw new Error(`Docker app container "${containerName}" does not exist.`);
-    }
-    if (!(await dockerContainerIsRunning(containerName))) {
-        return 'already-stopped';
-    }
-    await run('docker', ['stop', containerName], {
-        errorName: 'docker stop',
-        stdio: options?.stdio,
-    });
-    return 'stopped';
-}
-export async function runDockerNocoBaseCommand(containerName, args, options) {
-    await startDockerContainer(containerName, { stdio: options?.stdio });
-    const dockerEnvArgs = Object.entries(options?.env ?? {}).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
-    await run('docker', ['exec', ...dockerEnvArgs, '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
-        errorName: 'docker exec',
-        stdio: options?.stdio,
-        onStdout: options?.onStdout,
-        onStderr: options?.onStderr,
-    });
-}

package/dist/lib/auth-store.js

@@ -1,498 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { resolveAppPublicPath } from './app-public-path.js';
-import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
-import { normalizeCliLocale } from './cli-locale.js';
-import { inferConfiguredAppPathFromLegacyConfig, resolveConfiguredAppPath, resolveConfiguredSourcePath, resolveConfiguredStoragePath, } from './env-paths.js';
-import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
-function normalizeStoredEnvKind(value) {
-    const kind = String(value ?? '').trim();
-    if (kind === 'remote') {
-        return 'http';
-    }
-    if (kind === 'local' || kind === 'http' || kind === 'docker' || kind === 'ssh') {
-        return kind;
-    }
-    return undefined;
-}
-function normalizeOptionalString(value) {
-    const normalized = String(value ?? '').trim();
-    return normalized || undefined;
-}
-function normalizeOptionalCliLocale(value) {
-    const normalized = normalizeOptionalString(value);
-    if (!normalized) {
-        return undefined;
-    }
-    return normalizeCliLocale(normalized);
-}
-function normalizeOptionalCliUpdatePolicy(value) {
-    const normalized = normalizeOptionalString(value);
-    if (normalized === 'prompt' || normalized === 'auto' || normalized === 'off') {
-        return normalized;
-    }
-    return undefined;
-}
-export function readEnvApiBaseUrl(config) {
-    if (!config) {
-        return undefined;
-    }
-    return (normalizeOptionalString(config.apiBaseUrl) ??
-        normalizeOptionalString(config.baseUrl) ??
-        normalizeOptionalString(config.apibaseUrl));
-}
-export function resolveEnvKind(config) {
-    if (!config) {
-        return undefined;
-    }
-    const explicitKind = normalizeStoredEnvKind(config.kind);
-    if (explicitKind) {
-        return explicitKind;
-    }
-    const source = String(config.source ?? '').trim();
-    if (source === 'docker') {
-        return 'docker';
-    }
-    if (source === 'npm' || source === 'git' || source === 'local') {
-        return 'local';
-    }
-    if (String(config.appPath ?? '').trim() || String(config.appRootPath ?? '').trim()) {
-        return 'local';
-    }
-    if (readEnvApiBaseUrl(config) || config.auth) {
-        return 'http';
-    }
-    return undefined;
-}
-function normalizeEnvConfigEntry(entry) {
-    if (!entry) {
-        return entry;
-    }
-    const { kind: _kind, apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, ...rest } = entry;
-    const normalizedKind = resolveEnvKind(entry);
-    const apiBaseUrl = readEnvApiBaseUrl(entry);
-    return {
-        ...rest,
-        ...(normalizedKind ? { kind: normalizedKind } : {}),
-        ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
-        ...(normalizeOptionalString(entry.appPublicPath) ? { appPublicPath: resolveAppPublicPath(entry.appPublicPath) } : {}),
-    };
-}
-function normalizeAuthConfig(config) {
-    const settings = config.settings ?? {};
-    const locale = normalizeOptionalCliLocale(settings.locale);
-    const updatePolicy = normalizeOptionalCliUpdatePolicy(settings.update?.policy);
-    return {
-        name: config.name || config.dockerResourcePrefix,
-        settings: {
-            ...(locale ? { locale } : {}),
-            ...(updatePolicy ? { update: { policy: updatePolicy } } : {}),
-            ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
-            ...(settings.docker?.network || settings.docker?.containerPrefix
-                ? {
-                    docker: {
-                        ...(settings.docker?.network ? { network: normalizeOptionalString(settings.docker.network) } : {}),
-                        ...(settings.docker?.containerPrefix
-                            ? { containerPrefix: normalizeOptionalString(settings.docker.containerPrefix) }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...(settings.bin?.docker || settings.bin?.caddy || settings.bin?.git || settings.bin?.nginx || settings.bin?.yarn
-                ? {
-                    bin: {
-                        ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
-                        ...(settings.bin?.caddy ? { caddy: normalizeOptionalString(settings.bin.caddy) } : {}),
-                        ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
-                        ...(settings.bin?.nginx ? { nginx: normalizeOptionalString(settings.bin.nginx) } : {}),
-                        ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
-                    },
-                }
-                : {}),
-            ...(settings.proxy?.nbCliRoot ||
-                settings.proxy?.upstreamHost ||
-                settings.proxy?.host
-                ? {
-                    proxy: {
-                        ...(settings.proxy?.nbCliRoot ? { nbCliRoot: normalizeOptionalString(settings.proxy.nbCliRoot) } : {}),
-                        ...(settings.proxy?.upstreamHost || settings.proxy?.host
-                            ? {
-                                upstreamHost: normalizeOptionalString(settings.proxy?.upstreamHost ?? settings.proxy.host),
-                            }
-                            : {}),
-                    },
-                }
-                : {}),
-        },
-        lastEnv: config.lastEnv ||
-            config.currentEnv ||
-            'default',
-        envs: Object.fromEntries(Object.entries(config.envs || {}).map(([envName, entry]) => [envName, normalizeEnvConfigEntry(entry) ?? {}])),
-    };
-}
-function getConfigFile(options = {}) {
-    return path.join(resolveCliHomeDir(options.scope), 'config.json');
-}
-function createDefaultConfig() {
-    return {
-        lastEnv: 'default',
-        envs: {},
-    };
-}
-async function readStoredAuthConfig(filePath) {
-    try {
-        const content = await fs.readFile(filePath, 'utf8');
-        const parsed = JSON.parse(content);
-        return normalizeAuthConfig(parsed);
-    }
-    catch (_error) {
-        return undefined;
-    }
-}
-export async function loadExactAuthConfig(options = {}) {
-    return (await readStoredAuthConfig(getConfigFile(options))) ?? createDefaultConfig();
-}
-export async function loadAuthConfig(options = {}) {
-    return await loadExactAuthConfig(options);
-}
-export async function saveAuthConfig(config, options = {}) {
-    const filePath = getConfigFile(options);
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(normalizeAuthConfig(config), null, 2));
-}
-export async function listEnvs(options = {}) {
-    const config = await loadAuthConfig(options);
-    return {
-        lastEnv: config.lastEnv || 'default',
-        envs: config.envs,
-    };
-}
-export async function getCurrentEnvName(options = {}) {
-    const config = await loadAuthConfig(options);
-    return await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
-        scope: options.scope,
-        lastEnv: config.lastEnv,
-    });
-}
-export async function setCurrentEnv(envName, options = {}) {
-    const config = await loadExactAuthConfig(options);
-    if (!config.envs[envName]) {
-        throw new Error(`Env "${envName}" is not configured`);
-    }
-    config.lastEnv = envName;
-    await setSessionCurrentEnv(envName, options.scope);
-    await saveAuthConfig(config, options);
-}
-export class Env {
-    config;
-    constructor(config = {}) {
-        this.config = config;
-    }
-    get name() {
-        return this.config.name;
-    }
-    get baseUrl() {
-        return readEnvApiBaseUrl(this.config);
-    }
-    get apiBaseUrl() {
-        return readEnvApiBaseUrl(this.config);
-    }
-    get auth() {
-        return this.config.auth;
-    }
-    get authType() {
-        return resolveConfiguredAuthType(this.config);
-    }
-    get runtime() {
-        return this.config.runtime;
-    }
-    get kind() {
-        return resolveEnvKind(this.config);
-    }
-    get appRootPath() {
-        if (this.kind === 'ssh') {
-            const configuredPath = String(this.config.appRootPath ?? '').trim();
-            if (configuredPath) {
-                return configuredPath;
-            }
-        }
-        const legacyPath = resolveConfiguredEnvPath(this.config.appRootPath);
-        if (legacyPath) {
-            return legacyPath;
-        }
-        return this.kind === 'local' ? this.sourcePath : resolveEnvRelativePath('.');
-    }
-    get appPath() {
-        if (this.kind === 'ssh') {
-            const configuredPath = String(this.config.appPath ?? inferConfiguredAppPathFromLegacyConfig(this.config) ?? '').trim();
-            if (configuredPath) {
-                return configuredPath;
-            }
-        }
-        return resolveConfiguredAppPath(this.config) ?? resolveEnvRelativePath('.');
-    }
-    get sourcePath() {
-        if (this.kind === 'ssh') {
-            const configuredPath = String(this.config.appRootPath ?? '').trim();
-            if (configuredPath) {
-                return configuredPath;
-            }
-        }
-        return resolveConfiguredSourcePath(this.config) ?? path.join(this.appPath, 'source');
-    }
-    get storagePath() {
-        if (this.kind === 'ssh') {
-            const configuredPath = String(this.config.storagePath ?? '').trim();
-            if (configuredPath) {
-                return configuredPath;
-            }
-        }
-        const resolvedStoragePath = resolveConfiguredStoragePath(this.config);
-        if (resolvedStoragePath) {
-            return resolvedStoragePath;
-        }
-        return this.kind === 'local' || this.kind === 'docker'
-            ? path.join(this.appPath, 'storage')
-            : resolveEnvRelativePath('.');
-    }
-    get appPort() {
-        return this.config.appPort;
-    }
-    get envVars() {
-        const out = {
-            STORAGE_PATH: this.storagePath,
-        };
-        const put = (key, value) => {
-            if (value === undefined || value === null) {
-                return;
-            }
-            out[key] = String(value);
-        };
-        put('APP_PORT', this.appPort);
-        put('APP_PUBLIC_PATH', this.config.appPublicPath ? resolveAppPublicPath(this.config.appPublicPath) : undefined);
-        put('CDN_BASE_URL', this.config.cdnBaseUrl);
-        put('APP_KEY', this.config.appKey);
-        put('TZ', this.config.timezone);
-        put('DB_DIALECT', this.config.dbDialect);
-        if (!this.config.builtinDb) {
-            put('DB_HOST', this.config.dbHost);
-            put('DB_PORT', this.config.dbPort);
-        }
-        else if (String(this.config.source ?? '').trim() !== 'docker') {
-            put('DB_PORT', this.config.dbPort);
-        }
-        put('DB_DATABASE', this.config.dbDatabase);
-        put('DB_USER', this.config.dbUser);
-        put('DB_PASSWORD', this.config.dbPassword);
-        put('DB_SCHEMA', this.config.dbSchema);
-        put('DB_TABLE_PREFIX', this.config.dbTablePrefix);
-        put('DB_UNDERSCORED', this.config.dbUnderscored);
-        return out;
-    }
-}
-export async function getEnv(envName, options = {}) {
-    const { config: snapshot, ...loadOptions } = options;
-    const config = snapshot ?? (await loadAuthConfig(loadOptions));
-    const resolved = envName?.trim() ||
-        (await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
-            scope: loadOptions.scope,
-            lastEnv: config.lastEnv,
-        }));
-    const envConfig = config.envs[resolved];
-    if (!envConfig) {
-        return undefined;
-    }
-    return new Env({ ...(normalizeEnvConfigEntry(envConfig) ?? {}), name: resolved });
-}
-function areAuthConfigsEquivalent(left, right) {
-    if (!left && !right) {
-        return true;
-    }
-    if (!left || !right || left.type !== right.type) {
-        return false;
-    }
-    if (left.type === 'token' && right.type === 'token') {
-        return left.accessToken === right.accessToken;
-    }
-    if (left.type === 'oauth' && right.type === 'oauth') {
-        return (left.accessToken === right.accessToken &&
-            left.refreshToken === right.refreshToken &&
-            left.expiresAt === right.expiresAt &&
-            left.scope === right.scope &&
-            left.issuer === right.issuer &&
-            left.clientId === right.clientId &&
-            left.resource === right.resource);
-    }
-    return false;
-}
-async function writeEnv(envName, updater, options = {}) {
-    const config = await loadExactAuthConfig(options);
-    const previous = config.envs[envName];
-    config.envs[envName] = updater(previous);
-    await saveAuthConfig(config, options);
-}
-function normalizeConfiguredAuthType(value) {
-    return value === 'basic' || value === 'token' || value === 'oauth' ? value : undefined;
-}
-export function resolveConfiguredAuthType(config) {
-    return normalizeConfiguredAuthType(config?.authType) ?? normalizeConfiguredAuthType(config?.auth?.type);
-}
-export async function upsertEnv(envName, config, options = {}) {
-    await writeEnv(envName, (previous) => {
-        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, ...rest } = config;
-        const nextApiBaseUrl = readEnvApiBaseUrl(config);
-        const previousApiBaseUrl = readEnvApiBaseUrl(previous);
-        const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
-        const previousAuthType = resolveConfiguredAuthType(previous);
-        const requestedAuthType = normalizeConfiguredAuthType(authType);
-        const nextAuthType = requestedAuthType ?? (accessToken ? 'token' : previousAuthType);
-        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) ?? previous?.authUsername : undefined;
-        const nextAuth = accessToken
-            ? {
-                type: 'token',
-                accessToken,
-            }
-            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
-                ? previous.auth
-                : undefined;
-        const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
-        const authTypeChanged = previousAuthType !== nextAuthType;
-        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
-        return {
-            ...previous,
-            apiBaseUrl: nextApiBaseUrl,
-            authType: nextAuthType,
-            authUsername: nextAuthUsername,
-            auth: nextAuth,
-            ...rest,
-            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
-        };
-    }, options);
-}
-export async function updateEnvConnection(envName, updates, options = {}) {
-    await writeEnv(envName, (previous) => {
-        const nextApiBaseUrl = readEnvApiBaseUrl(updates) ?? readEnvApiBaseUrl(previous);
-        const previousApiBaseUrl = readEnvApiBaseUrl(previous);
-        const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
-        const previousAuthType = resolveConfiguredAuthType(previous);
-        const requestedAuthType = normalizeConfiguredAuthType(updates.authType);
-        const nextAuthType = requestedAuthType ?? (updates.accessToken ? 'token' : previousAuthType);
-        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(updates.authUsername) ?? previous?.authUsername : undefined;
-        const nextAuth = updates.accessToken
-            ? {
-                type: 'token',
-                accessToken: updates.accessToken,
-            }
-            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
-                ? previous.auth
-                : undefined;
-        const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
-        const authTypeChanged = previousAuthType !== nextAuthType;
-        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
-        return {
-            ...previous,
-            ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
-            authType: nextAuthType,
-            authUsername: nextAuthUsername,
-            auth: nextAuth,
-            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
-        };
-    }, options);
-}
-export async function replaceEnvConfig(envName, config, options = {}) {
-    await writeEnv(envName, (previous) => {
-        if (!previous) {
-            throw new Error(`Env "${envName}" is not configured`);
-        }
-        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, ...rest } = config;
-        const nextApiBaseUrl = readEnvApiBaseUrl(config);
-        const previousApiBaseUrl = readEnvApiBaseUrl(previous);
-        const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
-        const previousAuthType = resolveConfiguredAuthType(previous);
-        const nextAuthType = normalizeConfiguredAuthType(authType) ?? (accessToken ? 'token' : undefined);
-        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) : undefined;
-        const nextAuth = accessToken
-            ? {
-                type: 'token',
-                accessToken,
-            }
-            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
-                ? previous.auth
-                : undefined;
-        const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
-        const authTypeChanged = previousAuthType !== nextAuthType;
-        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
-        return {
-            ...rest,
-            ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
-            ...(nextAuthType ? { authType: nextAuthType } : {}),
-            ...(nextAuthUsername ? { authUsername: nextAuthUsername } : {}),
-            ...(nextAuth ? { auth: nextAuth } : {}),
-            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
-        };
-    }, options);
-}
-export async function setEnvOauthSession(envName, auth, options = {}) {
-    await writeEnv(envName, (previous) => ({
-        ...previous,
-        authType: 'oauth',
-        auth,
-        runtime: options.preserveRuntime ? previous?.runtime : undefined,
-    }), options);
-}
-export async function setEnvRuntime(envName, runtime, options = {}) {
-    const config = await loadExactAuthConfig(options);
-    const current = config.envs[envName] ?? {};
-    config.envs[envName] = {
-        ...current,
-        runtime,
-    };
-    await saveAuthConfig(config, options);
-}
-export async function clearEnvRootSetup(envName, options = {}) {
-    const config = await loadExactAuthConfig(options);
-    const current = config.envs[envName];
-    if (!current) {
-        return false;
-    }
-    const { rootUsername: _rootUsername, rootEmail: _rootEmail, rootPassword: _rootPassword, rootNickname: _rootNickname, ...rest } = current;
-    config.envs[envName] = rest;
-    await saveAuthConfig(config, options);
-    return true;
-}
-export async function removeEnv(envName, options = {}) {
-    const config = await loadExactAuthConfig(options);
-    if (!config.envs[envName]) {
-        throw new Error(`Env "${envName}" is not configured`);
-    }
-    delete config.envs[envName];
-    if (config.lastEnv === envName) {
-        const nextEnv = Object.keys(config.envs).sort()[0];
-        config.lastEnv = nextEnv ?? 'default';
-    }
-    await saveAuthConfig(config, options);
-    const remainingEnvNames = Object.keys(config.envs).sort();
-    const fallbackEnv = remainingEnvNames.length
-        ? await resolveEffectiveCurrentEnv(remainingEnvNames, {
-            scope: options.scope,
-            lastEnv: config.lastEnv,
-        })
-        : undefined;
-    await cleanupCurrentSessionAfterEnvRemoval(envName, {
-        scope: options.scope,
-        fallbackEnv,
-    });
-    return {
-        removed: envName,
-        lastEnv: config.lastEnv || 'default',
-        hasEnvs: Object.keys(config.envs).length > 0,
-    };
-}