@nocobase/cli 2.1.0-beta.43 → 2.1.0-beta.44.test.1

package/dist/commands/env/remove.js

@@ -7,26 +7,104 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Args, Command, Flags } from '@oclif/core';
+import { resolveManagedAppRuntime } from '../../lib/app-runtime.js';
 import { getCurrentEnvName, loadAuthConfig, removeEnv } from '../../lib/auth-store.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
-import { confirm } from "../../lib/inquirer.js";
-import { isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+import { confirm, input } from "../../lib/inquirer.js";
+import { isInteractiveTerminal, printInfo, printVerbose, setVerboseMode } from '../../lib/ui.js';
+function formatRemoveForceRequiredMessage(envName, purge) {
+    if (purge) {
+        return [
+            `Refusing to purge env "${envName}" without confirmation in non-interactive mode.`,
+            'Re-run with `--purge --force` to continue.',
+        ].join('\n');
+    }
+    return [
+        `Refusing to remove env "${envName}" without confirmation in non-interactive mode.`,
+        'Re-run with `--force` to continue.',
+    ].join('\n');
+}
+function buildRemovePrompt(runtime, options) {
+    const subject = options.isCurrent ? `current env "${runtime.envName}"` : `env "${runtime.envName}"`;
+    if (options.purge) {
+        const lines = [`Purge ${subject}?`];
+        if (runtime.kind === 'local' || runtime.kind === 'docker') {
+            lines.push('This removes CLI-managed local runtime resources for this env on this machine.');
+            lines.push('Storage data will be removed, and downloaded local app files will be removed when applicable.');
+            lines.push('External database services are not managed by the CLI and will be left untouched.');
+        }
+        else {
+            lines.push('This env has no CLI-managed local runtime resources on this machine.');
+            lines.push('Only the saved CLI env config will be removed. External services are not touched.');
+        }
+        lines.push(`Type "${runtime.envName}" to confirm:`);
+        return lines.join('\n');
+    }
+    const lines = [`Remove ${subject}?`];
+    if (runtime.kind === 'local' || runtime.kind === 'docker') {
+        lines.push('NocoBase and any CLI-managed built-in database for this env will be stopped on this machine.');
+        lines.push('The saved CLI env config will then be removed. Storage data and local app files will be kept.');
+    }
+    else {
+        lines.push('Only the saved CLI env config will be removed.');
+    }
+    return lines.join('\n');
+}
+async function confirmEnvRemoval(runtime, options) {
+    if (!isInteractiveTerminal()) {
+        if (options.force) {
+            return true;
+        }
+        throw new Error(formatRemoveForceRequiredMessage(runtime.envName, options.purge));
+    }
+    if (options.force) {
+        return true;
+    }
+    if (options.purge) {
+        try {
+            await input({
+                message: buildRemovePrompt(runtime, options),
+                required: true,
+                validate: (value) => (value.trim() === runtime.envName ? true : `Type "${runtime.envName}" to confirm.`),
+                placeholder: runtime.envName,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        return await confirm({
+            message: buildRemovePrompt(runtime, options),
+            default: false,
+        });
+    }
+    catch {
+        return false;
+    }
+}
 export default class EnvRemove extends Command {
     static summary = 'Remove a configured environment';
-    static description = 'Remove the saved CLI env config for an environment. This command does not clean local app files, containers, or storage data.';
+    static description = 'Remove a configured env. Local and Docker envs stop CLI-managed runtime resources on this machine first; pass `--purge` to also delete managed local resources, storage data, and downloaded app files when applicable.';
     static examples = [
         '<%= config.bin %> <%= command.id %> staging',
-        '<%= config.bin %> <%= command.id %> staging --yes',
+        '<%= config.bin %> <%= command.id %> staging --force',
+        '<%= config.bin %> <%= command.id %> staging --purge --force',
     ];
     static flags = {
         yes: Flags.boolean({
             char: 'y',
-            description: 'Skip confirmation and remove the saved CLI env config',
+            hidden: true,
             default: false,
         }),
         force: Flags.boolean({
             char: 'f',
-            hidden: true,
+            description: 'Skip confirmation for the selected remove mode',
+            default: false,
+        }),
+        purge: Flags.boolean({
+            description: 'Also remove CLI-managed local runtime resources, storage data, and downloaded app files when applicable. For remote API envs, only the saved CLI env config will be removed.',
             default: false,
         }),
         verbose: Flags.boolean({
@@ -49,25 +127,37 @@ export default class EnvRemove extends Command {
             this.error(`Env "${args.name}" is not configured`);
         }
         const currentEnv = await getCurrentEnvName({ scope });
+        const runtime = await resolveManagedAppRuntime(args.name);
+        if (!runtime) {
+            this.error(`Env "${args.name}" is not configured`);
+        }
         const skipConfirmation = flags.yes || flags.force;
-        if (!skipConfirmation) {
-            if (!isInteractiveTerminal()) {
-                this.error(`Refusing to remove env "${args.name}" without confirmation in non-interactive mode. Re-run with \`--yes\` to remove only the saved CLI env config.`);
-            }
-            const subject = args.name === currentEnv ? `current env "${args.name}"` : `env "${args.name}"`;
-            let confirmed = false;
-            try {
-                confirmed = await confirm({
-                    message: `Remove ${subject}? Only the saved CLI env config will be removed.`,
-                    default: false,
-                });
-            }
-            catch {
-                return;
-            }
-            if (!confirmed) {
+        let confirmed = false;
+        try {
+            confirmed = await confirmEnvRemoval(runtime, {
+                force: skipConfirmation,
+                isCurrent: args.name === currentEnv,
+                purge: flags.purge,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+        if (!confirmed) {
+            return;
+        }
+        const runCommand = this.config.runCommand.bind(this.config);
+        const verboseArgv = flags.verbose ? ['--verbose'] : [];
+        if (flags.purge) {
+            if (runtime.kind === 'local' || runtime.kind === 'docker') {
+                await runCommand('app:destroy', ['--env', runtime.envName, '--force', ...verboseArgv]);
                 return;
             }
+            printInfo(`No local CLI-managed resources were found for "${runtime.envName}". Removing the saved CLI env config only.`);
+        }
+        else if (runtime.kind === 'local' || runtime.kind === 'docker') {
+            printVerbose(`Stopping CLI-managed runtime resources for "${runtime.envName}" before removing the env config.`);
+            await runCommand('app:stop', ['--env', runtime.envName, '--with-db', '--yes', ...verboseArgv]);
         }
         printVerbose(`Removing env "${args.name}"`);
         const result = await removeEnv(args.name, { scope });

package/dist/commands/env/shared.js

@@ -8,6 +8,7 @@
  */
 import { buildDockerDbContainerName, dockerContainerExists, dockerContainerIsRunning, } from '../../lib/app-runtime.js';
 import { executeRawApiRequest } from '../../lib/api-client.js';
+import { buildLocalAppUrl } from '../../lib/app-public-path.js';
 export function resolveApiBaseUrl(config) {
     return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
 }
@@ -53,16 +54,23 @@ export function appUrl(runtime) {
     }
     const port = String(runtime.env.config.appPort ?? '').trim();
     if (port) {
-        return `http://127.0.0.1:${port}/`;
+        return buildLocalAppUrl(port, runtime.env.config?.appPublicPath) ?? '';
     }
     return '';
 }
-export function appRootPath(runtime) {
+export function appPath(runtime) {
+    if (runtime.kind === 'http') {
+        return '-';
+    }
+    const value = String(runtime.env.appPath ?? runtime.env.config.appPath ?? '').trim();
+    return value || '-';
+}
+export function sourcePath(runtime) {
     if (runtime.kind === 'http' || runtime.kind === 'docker') {
         return '-';
     }
     if (runtime.kind === 'local') {
-        return String(runtime.projectRoot ?? runtime.env.appRootPath ?? '').trim() || '-';
+        return String(runtime.projectRoot ?? runtime.env.sourcePath ?? runtime.env.appRootPath ?? '').trim() || '-';
     }
     return String(runtime.env.config.appRootPath ?? '').trim() || '-';
 }
@@ -98,15 +106,15 @@ function isNetworkFailure(error) {
     if (!(error instanceof Error)) {
         return false;
     }
-    return (error.name === 'AbortError'
-        || /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
+    return (error.name === 'AbortError' ||
+        /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
 }
 function isUnconfiguredFailure(error) {
     return error instanceof Error && /missing (a )?base url|missing base URL/i.test(error.message);
 }
 function isAuthFailure(error) {
-    return (error instanceof Error
-        && /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
+    return (error instanceof Error &&
+        /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
 }
 export async function apiStatus(envName, config, options = {}) {
     if (!resolveApiBaseUrl(config)) {
@@ -166,7 +174,7 @@ async function dockerStatus(containerName) {
     if (!(await dockerContainerExists(containerName))) {
         return 'missing';
     }
-    return await dockerContainerIsRunning(containerName) ? 'running' : 'stopped';
+    return (await dockerContainerIsRunning(containerName)) ? 'running' : 'stopped';
 }
 export async function dbStatus(runtime) {
     if (!runtime.env.config.builtinDb) {
@@ -192,5 +200,5 @@ export async function runtimeStatus(runtime) {
     if (runtime.kind === 'docker') {
         return await dockerStatus(runtime.containerName);
     }
-    return await isLocalAppHealthy(runtime) ? 'running' : 'stopped';
+    return (await isLocalAppHealthy(runtime)) ? 'running' : 'stopped';
 }

package/dist/commands/env/update.js

@@ -9,20 +9,168 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Args, Command, Flags } from '@oclif/core';
-import { getCurrentEnvName } from '../../lib/auth-store.js';
+import { getCurrentEnvName, getEnv, replaceEnvConfig } from '../../lib/auth-store.js';
 import { updateEnvRuntime } from '../../lib/bootstrap.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
-import { failTask, printVerbose, setVerboseMode, startTask, stopTask, succeedTask } from '../../lib/ui.js';
+import { ENV_BOOLEAN_CONFIG_FLAG_MAP, ENV_STRING_CONFIG_FLAG_MAP } from '../../lib/env-command-config.js';
+import { buildStoredEnvConfig } from '../../lib/env-config.js';
+import { failTask, printInfo, printVerbose, printWarningBlock, setVerboseMode, startTask, stopTask, succeedTask } from '../../lib/ui.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UPDATE_STRING_FLAGS = [
+    'source',
+    'download-version',
+    'docker-registry',
+    'docker-platform',
+    'git-url',
+    'npm-registry',
+    'app-path',
+    'app-root-path',
+    'storage-path',
+    'app-public-path',
+    'cdn-base-url',
+    'env-file',
+    'app-port',
+    'app-key',
+    'timezone',
+    'db-dialect',
+    'builtin-db-image',
+    'db-host',
+    'db-port',
+    'db-database',
+    'db-user',
+    'db-password',
+    'db-schema',
+    'db-table-prefix',
+];
+const UPDATE_BOOLEAN_FLAGS = ['builtin-db', 'dev-dependencies', 'build', 'build-dts', 'db-underscored'];
+const UPDATE_SPECIAL_FIELDS = ['api-base-url', 'auth-type', 'access-token', 'username'];
+const UNSETTABLE_FIELDS = new Set([...UPDATE_SPECIAL_FIELDS, ...UPDATE_STRING_FLAGS, ...UPDATE_BOOLEAN_FLAGS]);
+const SOURCE_SETTING_FIELDS = new Set([
+    'source',
+    'download-version',
+    'docker-registry',
+    'docker-platform',
+    'git-url',
+    'npm-registry',
+    'dev-dependencies',
+    'build',
+    'build-dts',
+]);
+const APP_RESTART_FIELDS = new Set([
+    'app-path',
+    'app-root-path',
+    'storage-path',
+    'app-public-path',
+    'env-file',
+    'app-port',
+    'app-key',
+    'timezone',
+    'db-host',
+    'db-port',
+    'db-database',
+    'db-user',
+    'db-password',
+    'db-schema',
+    'db-table-prefix',
+    'db-underscored',
+]);
+const APP_RESTART_WITH_DB_FIELDS = new Set([
+    'builtin-db',
+    'db-dialect',
+    'builtin-db-image',
+    'db-port',
+    'db-database',
+    'db-user',
+    'db-password',
+    'storage-path',
+]);
+const __dirnameConfigFile = path.join(path.dirname(path.dirname(path.dirname(__dirname))), 'nocobase-ctl.config.json');
+function hasTokenOverride(flags) {
+    return flags['access-token'] !== undefined || flags.token !== undefined;
+}
+function collectProvidedConfigFields(flags) {
+    const fields = new Set();
+    for (const field of UPDATE_SPECIAL_FIELDS) {
+        if (field === 'access-token') {
+            if (hasTokenOverride(flags)) {
+                fields.add(field);
+            }
+            continue;
+        }
+        if (flags[field] !== undefined) {
+            fields.add(field);
+        }
+    }
+    for (const field of UPDATE_STRING_FLAGS) {
+        if (flags[field] !== undefined) {
+            fields.add(field);
+        }
+    }
+    for (const field of UPDATE_BOOLEAN_FLAGS) {
+        if (flags[field] !== undefined) {
+            fields.add(field);
+        }
+    }
+    return fields;
+}
+function normalizeUnsetFields(unset) {
+    const normalized = (unset ?? [])
+        .flatMap((value) => value.split(','))
+        .map((value) => value.trim())
+        .filter(Boolean);
+    for (const field of normalized) {
+        if (!UNSETTABLE_FIELDS.has(field)) {
+            throw new Error(`Unsupported --unset field "${field}". Supported fields: ${Array.from(UNSETTABLE_FIELDS).sort().join(', ')}.`);
+        }
+    }
+    return Array.from(new Set(normalized));
+}
+function buildCurrentConfigInput(env) {
+    return {
+        ...env.config,
+        apiBaseUrl: env.apiBaseUrl,
+        authType: env.authType,
+        authUsername: env.config.authUsername,
+        accessToken: env.auth?.type === 'token' ? env.auth.accessToken : undefined,
+    };
+}
+function applyUnsetField(nextInput, field) {
+    switch (field) {
+        case 'api-base-url':
+            delete nextInput.apiBaseUrl;
+            return;
+        case 'auth-type':
+            delete nextInput.authType;
+            return;
+        case 'access-token':
+            delete nextInput.accessToken;
+            return;
+        case 'username':
+            delete nextInput.authUsername;
+            return;
+        default:
+            if (field in ENV_STRING_CONFIG_FLAG_MAP) {
+                delete nextInput[ENV_STRING_CONFIG_FLAG_MAP[field]];
+                return;
+            }
+            if (field in ENV_BOOLEAN_CONFIG_FLAG_MAP) {
+                delete nextInput[ENV_BOOLEAN_CONFIG_FLAG_MAP[field]];
+            }
+    }
+}
 export default class EnvUpdate extends Command {
-    static summary = 'Refresh an environment runtime from swagger:get and persist connection overrides';
+    static summary = 'Refresh an environment runtime from swagger:get, or update the saved env config for one environment';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> prod',
+        '<%= config.bin %> <%= command.id %> prod --api-base-url http://localhost:13000/api --access-token <token>',
+        '<%= config.bin %> <%= command.id %> local --app-port 13080 --timezone Asia/Shanghai',
+        '<%= config.bin %> <%= command.id %> local --cdn-base-url https://cdn.example.com/nocobase/',
+        '<%= config.bin %> <%= command.id %> local --unset git-url --unset npm-registry',
     ];
     static args = {
         name: Args.string({
-            description: 'Configured environment name to refresh. Defaults to the current env when omitted',
+            description: 'Configured environment name to update. Defaults to the current env when omitted',
             required: false,
         }),
     };
@@ -32,33 +180,138 @@ export default class EnvUpdate extends Command {
             default: false,
         }),
         'api-base-url': Flags.string({
-            description: 'NocoBase API base URL override. When provided, persist it to the target env before saving the refreshed runtime.',
+            char: 'u',
+            description: 'Root URL for HTTP API calls, including the /api prefix (e.g. http://localhost:13000/api)',
         }),
-        role: Flags.string({
-            description: 'Role override, sent as X-Role',
+        'auth-type': Flags.string({
+            description: 'Authentication: basic, token, or oauth',
+            options: ['basic', 'token', 'oauth'],
         }),
-        token: Flags.string({
+        'access-token': Flags.string({
             char: 't',
-            description: 'API key override. When provided, persist it to the target env before saving the refreshed runtime.',
+            aliases: ['token'],
+            description: 'API key or access token for token-based authentication',
+        }),
+        username: Flags.string({
+            description: 'Username to save for basic authentication',
+        }),
+        source: Flags.string({
+            description: 'Saved application source type for this env',
+            options: ['docker', 'git', 'local', 'npm'],
+        }),
+        'download-version': Flags.string({
+            aliases: ['version'],
+            description: 'Saved downloaded app version for this env',
+        }),
+        'docker-registry': Flags.string({
+            description: 'Saved Docker registry for this env',
+        }),
+        'docker-platform': Flags.string({
+            description: 'Saved Docker image platform for this env',
+            options: ['auto', 'linux/amd64', 'linux/arm64'],
+        }),
+        'git-url': Flags.string({
+            description: 'Saved Git repository URL for this env',
+        }),
+        'npm-registry': Flags.string({
+            description: 'Saved npm registry for this env',
+        }),
+        'dev-dependencies': Flags.boolean({
+            allowNo: true,
+            description: 'Whether development dependencies are installed for this env',
+        }),
+        build: Flags.boolean({
+            allowNo: true,
+            description: 'Whether the app should be built after source download',
+        }),
+        'build-dts': Flags.boolean({
+            allowNo: true,
+            description: 'Whether declaration files should be emitted during build',
+        }),
+        'app-path': Flags.string({
+            description: 'Saved app path for this env',
+        }),
+        'app-root-path': Flags.string({
+            hidden: true,
+            description: 'Saved application root path for this env',
+        }),
+        'storage-path': Flags.string({
+            hidden: true,
+            description: 'Saved storage path for this env',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Saved application public path for this env',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Saved client asset CDN base URL (CDN_BASE_URL) for this env',
+        }),
+        'env-file': Flags.string({
+            hidden: true,
+            description: 'Saved Docker --env-file path for this env',
+        }),
+        'app-port': Flags.string({
+            description: 'Saved application HTTP port for this env',
+        }),
+        'app-key': Flags.string({
+            description: 'Saved application secret key for this env',
+        }),
+        timezone: Flags.string({
+            description: 'Saved application timezone for this env',
+        }),
+        'builtin-db': Flags.boolean({
+            allowNo: true,
+            description: 'Whether this env uses a CLI-managed built-in database',
+        }),
+        'db-dialect': Flags.string({
+            description: 'Saved database dialect for this env',
+            options: ['kingbase', 'mariadb', 'mysql', 'postgres'],
+        }),
+        'builtin-db-image': Flags.string({
+            description: 'Saved built-in database image for this env',
+        }),
+        'db-host': Flags.string({
+            description: 'Saved database host for this env',
+        }),
+        'db-port': Flags.string({
+            description: 'Saved database port for this env',
+        }),
+        'db-database': Flags.string({
+            description: 'Saved database name for this env',
+        }),
+        'db-user': Flags.string({
+            description: 'Saved database user for this env',
+        }),
+        'db-password': Flags.string({
+            description: 'Saved database password for this env',
+        }),
+        'db-schema': Flags.string({
+            description: 'Saved database schema for this env',
+        }),
+        'db-table-prefix': Flags.string({
+            description: 'Saved database table prefix for this env',
+        }),
+        'db-underscored': Flags.boolean({
+            allowNo: true,
+            description: 'Whether this env uses underscored database naming',
+        }),
+        unset: Flags.string({
+            multiple: true,
+            description: 'Unset one or more saved env config fields by canonical flag name',
         }),
     };
-    async run() {
-        const { args, flags } = await this.parse(EnvUpdate);
-        setVerboseMode(Boolean(flags.verbose));
-        const envName = args.name;
-        const envLabel = envName ?? (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
-        startTask(`Updating env runtime: ${envLabel}`);
+    buildRuntimeUpdateTaskMessage(envLabel) {
+        return `Updating env runtime: ${envLabel}`;
+    }
+    async refreshRuntime(envName, envLabel, verbose) {
+        startTask(this.buildRuntimeUpdateTaskMessage(envLabel));
         try {
             const runtime = await updateEnvRuntime({
                 envName,
                 scope: resolveDefaultConfigScope(),
-                baseUrl: flags['api-base-url'],
-                role: flags.role,
-                token: flags.token,
-                configFile: path.join(path.dirname(path.dirname(path.dirname(__dirname))), 'nocobase-ctl.config.json'),
-                verbose: flags.verbose,
+                configFile: __dirnameConfigFile,
+                verbose,
             });
-            if (flags.verbose) {
+            if (verbose) {
                 succeedTask(`Updated env "${envLabel}" to runtime "${runtime.version}".`);
             }
             else {
@@ -71,4 +324,115 @@ export default class EnvUpdate extends Command {
             throw error;
         }
     }
+    printConfigUpdateHints(envName, changedFields, nextConfig) {
+        if (changedFields.size === 0) {
+            return;
+        }
+        printInfo('Saved env config was updated. Runtime commands were not refreshed automatically.');
+        const shouldRestartWithDb = Array.from(changedFields).some((field) => APP_RESTART_WITH_DB_FIELDS.has(field)) &&
+            (nextConfig.builtinDb === true || changedFields.has('builtin-db'));
+        if (shouldRestartWithDb) {
+            printInfo(`Run \`nb app restart --env ${envName} --with-db\` when you're ready to apply these changes.`);
+            return;
+        }
+        if (Array.from(changedFields).some((field) => APP_RESTART_FIELDS.has(field))) {
+            printInfo(`Run \`nb app restart --env ${envName}\` when you're ready to apply these changes.`);
+        }
+        if (Array.from(changedFields).some((field) => SOURCE_SETTING_FIELDS.has(field))) {
+            printInfo('Saved source settings were updated. Existing local source files are not replaced automatically.');
+        }
+        if (Array.from(changedFields).some((field) => field === 'auth-type' || field === 'access-token' || field === 'username') &&
+            (nextConfig.authType === 'basic' || nextConfig.authType === 'oauth' || !nextConfig.accessToken)) {
+            printInfo(`Run \`nb env auth ${envName}\` if you need to authenticate this env again before using runtime commands.`);
+        }
+    }
+    async run() {
+        const { args, flags } = await this.parse(EnvUpdate);
+        const parsedFlags = flags;
+        setVerboseMode(Boolean(parsedFlags.verbose));
+        const unsetFields = normalizeUnsetFields(parsedFlags.unset);
+        const providedFields = collectProvidedConfigFields(parsedFlags);
+        const hasConfigChanges = providedFields.size > 0 || unsetFields.length > 0;
+        const tokenOverride = hasTokenOverride(parsedFlags);
+        for (const field of unsetFields) {
+            if (providedFields.has(field)) {
+                this.error(`Cannot combine --unset ${field} with an explicit update for the same field.`);
+            }
+        }
+        if (tokenOverride && parsedFlags['auth-type'] && parsedFlags['auth-type'] !== 'token') {
+            this.error('--access-token or --token can only be used with --auth-type token.');
+        }
+        if (!hasConfigChanges) {
+            const envName = args.name;
+            const envLabel = envName ?? (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+            await this.refreshRuntime(envName, envLabel, Boolean(parsedFlags.verbose));
+            return;
+        }
+        const currentEnv = await getEnv(args.name, { scope: resolveDefaultConfigScope() });
+        if (!currentEnv) {
+            this.error(args.name?.trim()
+                ? `Env "${args.name.trim()}" is not configured`
+                : 'No env is configured. Run `nb init --ui` or `nb env add <name> --api-base-url <url>` first.');
+        }
+        const envName = String(currentEnv.name ?? '').trim();
+        const effectiveAuthType = parsedFlags['auth-type'] ?? (tokenOverride ? 'token' : currentEnv.authType);
+        if (parsedFlags.username !== undefined && effectiveAuthType !== 'basic') {
+            this.error('--username can only be used when the env uses basic authentication.');
+        }
+        const nextInput = buildCurrentConfigInput(currentEnv);
+        nextInput.apiBaseUrl = currentEnv.apiBaseUrl;
+        nextInput.authType = currentEnv.authType;
+        nextInput.authUsername = currentEnv.config.authUsername;
+        if (parsedFlags['api-base-url'] !== undefined) {
+            nextInput.apiBaseUrl = parsedFlags['api-base-url'];
+        }
+        if (parsedFlags['auth-type'] !== undefined) {
+            nextInput.authType = parsedFlags['auth-type'];
+        }
+        if (parsedFlags.username !== undefined) {
+            nextInput.authUsername = String(parsedFlags.username ?? '').trim();
+        }
+        if (tokenOverride) {
+            nextInput.authType = 'token';
+            nextInput.accessToken = parsedFlags['access-token'] ?? parsedFlags.token;
+        }
+        for (const field of UPDATE_STRING_FLAGS) {
+            if (parsedFlags[field] !== undefined) {
+                nextInput[ENV_STRING_CONFIG_FLAG_MAP[field]] = parsedFlags[field];
+            }
+        }
+        for (const field of UPDATE_BOOLEAN_FLAGS) {
+            if (parsedFlags[field] !== undefined) {
+                nextInput[ENV_BOOLEAN_CONFIG_FLAG_MAP[field]] = parsedFlags[field];
+            }
+        }
+        for (const field of unsetFields) {
+            applyUnsetField(nextInput, field);
+        }
+        const nextConfig = buildStoredEnvConfig(nextInput);
+        startTask(`Saving env config: ${envName}`);
+        try {
+            await replaceEnvConfig(envName, nextConfig, { scope: resolveDefaultConfigScope() });
+            succeedTask(`Saved env config for "${envName}".`);
+        }
+        catch (error) {
+            failTask(`Failed to save env config for "${envName}".`);
+            throw error;
+        }
+        const shouldRefreshRuntime = providedFields.has('api-base-url') || providedFields.has('access-token');
+        if (!shouldRefreshRuntime) {
+            this.printConfigUpdateHints(envName, new Set([...providedFields, ...unsetFields]), nextConfig);
+            return;
+        }
+        try {
+            await this.refreshRuntime(envName, envName, Boolean(parsedFlags.verbose));
+        }
+        catch (error) {
+            this.printConfigUpdateHints(envName, new Set([...providedFields, ...unsetFields]), nextConfig);
+            const message = error instanceof Error ? error.message : String(error);
+            printWarningBlock(`Saved env config for "${envName}", but failed to refresh the runtime.\n${message}`);
+            return;
+        }
+        printVerbose(`Updated env "${envName}" config and refreshed the runtime.`);
+    }
 }