@nocobase/cli 2.1.0-beta.37 → 2.1.0-beta.40

package/dist/commands/app/upgrade.js

@@ -7,34 +7,18 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
-import { upsertEnv } from '../../lib/auth-store.js';
-import { ensureLocalPostinstall } from '../../lib/app-managed-resources.js';
-import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, stopDockerContainer, } from '../../lib/app-runtime.js';
-import { resolveConfiguredEnvPath } from '../../lib/cli-home.js';
-import { deriveBuiltinDbConnection } from '../../lib/builtin-db.js';
-import { resolveDockerEnvFileArg } from "../../lib/docker-env-file.js";
+import { getCurrentEnvName, upsertEnv } from '../../lib/auth-store.js';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../lib/app-runtime.js';
 import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
-import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "../../lib/docker-image.js";
-import { commandSucceeds, run } from '../../lib/run-npm.js';
-import { announceTargetEnv, failTask, printInfo, startTask, stopTask, succeedTask, updateTask } from '../../lib/ui.js';
-const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
-const APP_HEALTH_CHECK_INTERVAL_MS = 2_000;
-const APP_HEALTH_CHECK_TIMEOUT_MS = 600_000;
-const APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS = 5_000;
+import { DEFAULT_DOCKER_REGISTRY } from "../../lib/docker-image.js";
+import { confirm } from "../../lib/inquirer.js";
+import { announceTargetEnv, isInteractiveTerminal, printInfo, printWarning, succeedTask } from '../../lib/ui.js';
 function trimValue(value) {
     return String(value ?? '').trim();
 }
-function pushOptionalEnvArg(args, key, value) {
-    if (typeof value === 'string') {
-        if (!value) {
-            return;
-        }
-        args.push('-e', `${key}=${value}`);
-        return;
-    }
-    if (typeof value === 'boolean') {
-        args.push('-e', `${key}=${String(value)}`);
-    }
+function normalizeEnvName(value) {
+    const text = trimValue(value);
+    return text || undefined;
 }
 function formatAppUrl(port) {
     const value = trimValue(port);
@@ -51,27 +35,21 @@ function formatDisplayUrl(apiBaseUrl, appPort) {
     }
     return value.replace(/\/api\/?$/, '');
 }
-function resolveApiBaseUrl(runtime) {
-    const baseUrl = trimValue(runtime.env.baseUrl);
-    if (baseUrl) {
-        return baseUrl.replace(/\/+$/, '');
-    }
-    const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
-        ? ''
-        : trimValue(runtime.env.appPort);
-    return appPort ? `http://127.0.0.1:${appPort}/api` : undefined;
-}
-function buildHealthCheckUrl(apiBaseUrl) {
-    return `${apiBaseUrl.replace(/\/+$/, '')}/__health_check`;
+function readEnvValue(env, key) {
+    return trimValue(env.config[key]);
 }
-function dockerRefLabel(source) {
-    if (source === 'git') {
-        return 'Git checkout';
+function normalizeDockerPlatform(value) {
+    const text = trimValue(value);
+    if (!text || text === 'auto') {
+        return undefined;
     }
-    if (source === 'npm') {
-        return 'npm app';
+    if (text === 'linux/amd64' || text === 'linux/arm64') {
+        return text;
     }
-    return 'local app';
+    return undefined;
+}
+function isDownloadableLocalRuntime(runtime) {
+    return runtime.kind === 'local' && (runtime.source === 'npm' || runtime.source === 'git');
 }
 function formatLocalDownloadFailure(envName, source, message) {
     const sourceLabel = source === 'git' ? 'the saved Git checkout' : 'the saved npm app';
@@ -82,16 +60,6 @@ function formatLocalDownloadFailure(envName, source, message) {
         `Details: ${message}`,
     ].join('\n');
 }
-function formatLocalStartFailure(envName, source, port, message) {
-    const sourceLabel = dockerRefLabel(source);
-    const portHint = trimValue(port) ? ` Expected app port: ${trimValue(port)}.` : '';
-    const details = trimValue(message) ? ` Details: ${trimValue(message)}` : '';
-    return [
-        `Couldn't finish the upgrade for "${envName}".`,
-        `The CLI updated ${sourceLabel}, but it could not start the upgraded app successfully.`,
-        `Check the local dependencies, database connection, and saved env settings, then try again.${portHint}${details}`,
-    ].join('\n');
-}
 function formatDockerDownloadFailure(envName, message) {
     return [
         `Couldn't refresh the Docker image for "${envName}".`,
@@ -100,122 +68,187 @@ function formatDockerDownloadFailure(envName, message) {
         `Details: ${message}`,
     ].join('\n');
 }
-function formatDockerStartFailure(envName, message) {
-    return [
-        `Couldn't finish the upgrade for "${envName}".`,
-        'The CLI was not able to start the upgraded Docker app successfully.',
-        'Check that the saved Docker image, container settings, and database connection are still valid, then try again.',
-        `Details: ${message}`,
-    ].join('\n');
+function buildManagedActionArgv(envName, flags, options) {
+    const argv = ['--env', envName, '--yes'];
+    if (flags.verbose) {
+        argv.push('--verbose');
+    }
+    if (options?.quickstart) {
+        argv.push('--quickstart');
+    }
+    return argv;
 }
-function normalizeDockerPlatform(value) {
-    const text = String(value ?? '').trim();
-    if (!text || text === 'auto') {
-        return undefined;
+function shouldSkipDownload(flags) {
+    return Boolean(flags['skip-download'] || flags['skip-code-update']);
+}
+function buildUpgradeCliArgv(envName, flags, options) {
+    const argv = ['--env', envName];
+    if (shouldSkipDownload(flags)) {
+        argv.push('--skip-download');
     }
-    if (text === 'linux/amd64' || text === 'linux/arm64') {
-        return text;
+    const version = normalizeEnvName(flags.version);
+    if (version) {
+        argv.push('--version', version);
     }
-    return undefined;
+    if (flags.verbose) {
+        argv.push('--verbose');
+    }
+    if (options?.yes ?? flags.yes) {
+        argv.push('--yes');
+    }
+    if (options?.force ?? flags.force) {
+        argv.push('--force');
+    }
+    return argv;
 }
-function readEnvValue(env, key) {
-    if (key === 'appRootPath' || key === 'storagePath') {
-        return trimValue(resolveConfiguredEnvPath(env.config[key]));
+function buildUpgradeCliCommand(envName, flags, options) {
+    return ['nb', 'app', 'upgrade', ...buildUpgradeCliArgv(envName, flags, options)].join(' ');
+}
+function formatUpgradeOperationSummary(runtime, flags) {
+    const mayRunUpgradeMigrations = 'It may also run upgrade migrations.';
+    if (shouldSkipDownload(flags)) {
+        const sourceLabel = runtime.kind === 'docker'
+            ? 'saved Docker image'
+            : runtime.source === 'local'
+                ? 'saved local app path'
+                : runtime.source === 'git'
+                    ? 'saved Git checkout'
+                    : 'saved npm app';
+        return [
+            'This operation will stop the app, skip source download and commercial plugin sync,',
+            `and start it again with the ${sourceLabel}.`,
+            mayRunUpgradeMigrations,
+        ].join(' ');
     }
-    return trimValue(env.config[key]);
+    if (runtime.kind === 'docker') {
+        return [
+            'This operation will stop the app, replace the saved Docker image,',
+            'sync commercial plugins when applicable, and start the app again.',
+            mayRunUpgradeMigrations,
+        ].join(' ');
+    }
+    if (runtime.source === 'local') {
+        return [
+            'This operation will stop the app, reuse the saved local app path,',
+            'sync commercial plugins when applicable, and start the app again.',
+            mayRunUpgradeMigrations,
+        ].join(' ');
+    }
+    return [
+        'This operation will stop the app, replace the saved source,',
+        'sync commercial plugins when applicable, and start the app again.',
+        mayRunUpgradeMigrations,
+    ].join(' ');
 }
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
+function formatUpgradePromptSummary(flags) {
+    if (shouldSkipDownload(flags)) {
+        return 'This will stop and restart the app, and may run upgrade migrations.';
+    }
+    return 'This will stop and restart the app, update the saved source or image, and may run upgrade migrations.';
 }
-async function requestAppHealthCheck(params) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => {
-        controller.abort();
-    }, params.requestTimeoutMs ?? APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS);
-    try {
-        const response = await (params.fetchImpl ?? fetch)(params.healthCheckUrl, {
-            method: 'GET',
-            signal: controller.signal,
-        });
-        const text = await response.text().catch(() => '');
-        const body = text.replace(/\s+/g, ' ').trim() || 'No response yet';
-        return {
-            ok: response.ok && text.trim().toLowerCase() === 'ok',
-            message: `HTTP ${response.status}: ${body}`,
-        };
+function formatUpgradeForceRequiredMessage(runtime, flags) {
+    return [
+        `\`nb app upgrade\` needs confirmation in non-interactive mode before upgrading "${runtime.envName}".`,
+        '',
+        formatUpgradeOperationSummary(runtime, flags),
+        '',
+        'Interactive confirmation is unavailable in the current AI agent session, and the agent will not add `--force` on your behalf.',
+        '',
+        'To continue:',
+        `- re-run \`${buildUpgradeCliCommand(runtime.envName, flags, { force: true })}\``,
+        `- or switch to an interactive terminal and re-run \`${buildUpgradeCliCommand(runtime.envName, flags, {
+            force: false,
+        })}\``,
+    ].join('\n');
+}
+function formatMissingUpgradeFlagList(options) {
+    const missingFlags = [
+        options.missingYes ? '`--yes`' : undefined,
+        options.missingForce ? '`--force`' : undefined,
+    ].filter(Boolean);
+    if (missingFlags.length <= 1) {
+        return missingFlags[0] ?? '';
     }
-    catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
-            return {
-                ok: false,
-                message: `No response within ${Math.ceil((params.requestTimeoutMs ?? APP_HEALTH_CHECK_REQUEST_TIMEOUT_MS) / 1000)}s`,
-            };
-        }
-        return {
-            ok: false,
-            message: error instanceof Error ? error.message : String(error),
-        };
+    return `${missingFlags[0]} or ${missingFlags[1]}`;
+}
+function formatUpgradeCrossEnvConfirmationRequiredMessage(currentEnv, runtime, flags, options) {
+    return [
+        `Refusing to upgrade env "${runtime.envName}" because the current env is "${currentEnv}" and interactive confirmation is unavailable in the current AI agent session.`,
+        '',
+        formatUpgradeOperationSummary(runtime, flags),
+        '',
+        `For safety, the agent will not switch envs automatically and will not add ${formatMissingUpgradeFlagList(options)} on your behalf.`,
+        '',
+        'To continue:',
+        `- run \`nb env use ${runtime.envName}\` yourself, then re-run \`${buildUpgradeCliCommand(runtime.envName, flags, {
+            yes: false,
+            force: true,
+        })}\``,
+        `- or re-run \`${buildUpgradeCliCommand(runtime.envName, flags, { yes: true, force: true })}\``,
+    ].join('\n');
+}
+function buildLicenseSyncArgv(envName, flags, options) {
+    const argv = ['--env', envName, '--yes', '--skip-if-no-license'];
+    if (flags.verbose) {
+        argv.push('--verbose');
     }
-    finally {
-        clearTimeout(timeout);
+    if (options?.version) {
+        argv.push('--version', options.version);
     }
+    return argv;
 }
-async function waitForAppHealthCheck(params) {
-    if (!params.apiBaseUrl) {
-        printInfo(`Skipping health check for "${params.envName}" because no local API URL is saved for this env.`);
-        return;
+function buildEnvUpdateArgv(envName, flags) {
+    const argv = [envName];
+    if (flags.verbose) {
+        argv.push('--verbose');
     }
-    const healthCheckUrl = buildHealthCheckUrl(params.apiBaseUrl);
-    const startedAt = Date.now();
-    let lastMessage = 'No response yet';
-    let spinnerActive = true;
-    startTask(`Waiting for NocoBase to become ready for "${params.envName}"...`);
+    return argv;
+}
+function formatEnvUpdateWarning(envName, message) {
+    return [
+        `NocoBase was upgraded for "${envName}", but the CLI could not refresh the saved env runtime.`,
+        `Run \`nb env update ${envName}\` to refresh it manually.`,
+        `Details: ${message}`,
+    ].join(' ');
+}
+async function runWithSuppressedTargetEnvLog(task) {
+    const previousTargetEnv = process.env.NB_SKIP_TARGET_ENV_LOG;
+    process.env.NB_SKIP_TARGET_ENV_LOG = '1';
     try {
-        while (Date.now() - startedAt < APP_HEALTH_CHECK_TIMEOUT_MS) {
-            const result = await requestAppHealthCheck({
-                healthCheckUrl,
-                fetchImpl: params.fetchImpl,
-            });
-            if (result.ok) {
-                stopTask();
-                spinnerActive = false;
-                return;
-            }
-            lastMessage = result.message;
-            const elapsedSeconds = Math.max(1, Math.floor((Date.now() - startedAt) / 1000));
-            updateTask(`Waiting for NocoBase to become ready for "${params.envName}"... (${elapsedSeconds}s elapsed, last status: ${lastMessage})`);
-            await sleep(APP_HEALTH_CHECK_INTERVAL_MS);
-        }
+        return await task();
     }
     finally {
-        if (spinnerActive) {
-            stopTask();
+        if (previousTargetEnv === undefined) {
+            delete process.env.NB_SKIP_TARGET_ENV_LOG;
+        }
+        else {
+            process.env.NB_SKIP_TARGET_ENV_LOG = previousTargetEnv;
         }
     }
-    const logHint = params.containerName
-        ? ` You can inspect startup logs with: docker logs ${params.containerName}`
-        : '';
-    throw new Error(`The upgraded app for "${params.envName}" did not become ready in time. Expected \`${healthCheckUrl}\` to respond with \`ok\`, but the last status was: ${lastMessage}.${logHint}`);
-}
-async function dockerContainerExists(containerName) {
-    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
 }
-async function ensureDockerNetwork(name) {
-    const exists = await commandSucceeds('docker', ['network', 'inspect', name]);
-    if (exists) {
-        return;
+async function runWithSuppressedStartSuccessLog(task) {
+    const previousStartSuccess = process.env.NB_SKIP_APP_START_SUCCESS_LOG;
+    process.env.NB_SKIP_APP_START_SUCCESS_LOG = '1';
+    try {
+        return await task();
+    }
+    finally {
+        if (previousStartSuccess === undefined) {
+            delete process.env.NB_SKIP_APP_START_SUCCESS_LOG;
+        }
+        else {
+            process.env.NB_SKIP_APP_START_SUCCESS_LOG = previousStartSuccess;
+        }
     }
-    await run('docker', ['network', 'create', name], {
-        errorName: 'docker network create',
-        stdio: 'ignore',
-    });
 }
 export default class AppUpgrade extends Command {
     static hidden = false;
-    static description = 'Upgrade the selected NocoBase app. Local npm/git installs refresh the saved source and restart with quickstart; Docker installs refresh the saved image and recreate the app container. Use --version to upgrade to a specific saved source version or image tag.';
+    static description = 'Upgrade the selected NocoBase app. The CLI stops the current app, optionally replaces the saved source or image, then starts the app again. Use --version to upgrade to a specific saved source version or image tag.';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --force',
         '<%= config.bin %> <%= command.id %> --env local',
+        '<%= config.bin %> <%= command.id %> --env local --force',
         '<%= config.bin %> <%= command.id %> --env local -s',
         '<%= config.bin %> <%= command.id %> --env local --version beta',
         '<%= config.bin %> <%= command.id %> --env local --verbose',
@@ -231,9 +264,20 @@ export default class AppUpgrade extends Command {
             description: 'Confirm using --env when it targets a different env than the current env',
             default: false,
         }),
-        'skip-code-update': Flags.boolean({
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip the upgrade confirmation prompt',
+            default: false,
+        }),
+        'skip-download': Flags.boolean({
             char: 's',
-            description: 'Restart with the saved local code or Docker image without downloading updates first',
+            description: 'Restart with the saved local source or Docker image without downloading updates first',
+            required: false,
+        }),
+        'skip-code-update': Flags.boolean({
+            hidden: true,
+            deprecated: true,
+            description: 'Deprecated alias for --skip-download',
             required: false,
         }),
         version: Flags.string({
@@ -247,9 +291,6 @@ export default class AppUpgrade extends Command {
     };
     static resolveUpgradeVersion(runtime, flags) {
         const requestedVersion = trimValue(flags.version);
-        if (requestedVersion && flags['skip-code-update']) {
-            throw new Error('`--version` and `--skip-code-update` cannot be used together. Use `--version` to download a specific upgrade target, or `--skip-code-update` to restart the saved code/image as-is.');
-        }
         if (runtime.kind === 'local' && runtime.source === 'local') {
             if (requestedVersion) {
                 throw new Error([
@@ -260,6 +301,11 @@ export default class AppUpgrade extends Command {
             }
             return {};
         }
+        if (shouldSkipDownload(flags)) {
+            return {
+                persistDownloadVersion: requestedVersion || undefined,
+            };
+        }
         const savedVersion = readEnvValue(runtime.env, 'downloadVersion');
         const downloadVersion = requestedVersion || savedVersion;
         if (!downloadVersion) {
@@ -276,15 +322,15 @@ export default class AppUpgrade extends Command {
     }
     static buildLocalDownloadArgv(runtime, downloadVersion, options) {
         const argv = ['-y', '--no-intro', '--source', runtime.source, '--replace'];
-        const gitUrl = readEnvValue(runtime.env, 'gitUrl');
-        const npmRegistry = readEnvValue(runtime.env, 'npmRegistry');
         if (options?.verbose) {
             argv.push('--verbose');
         }
         argv.push('--version', downloadVersion, '--output-dir', runtime.projectRoot);
+        const gitUrl = readEnvValue(runtime.env, 'gitUrl');
         if (gitUrl) {
             argv.push('--git-url', gitUrl);
         }
+        const npmRegistry = readEnvValue(runtime.env, 'npmRegistry');
         if (npmRegistry) {
             argv.push('--npm-registry', npmRegistry);
         }
@@ -299,278 +345,18 @@ export default class AppUpgrade extends Command {
         }
         return argv;
     }
-    static buildDockerDownloadArgv(runtime, plan, options) {
+    static buildDockerDownloadArgv(runtime, downloadVersion, options) {
         const argv = ['-y', '--no-intro'];
         if (options?.verbose) {
             argv.push('--verbose');
         }
-        argv.push('--source', 'docker', '--replace', '--docker-registry', plan.dockerRegistry, '--version', plan.downloadVersion);
+        argv.push('--source', 'docker', '--replace', '--docker-registry', readEnvValue(runtime.env, 'dockerRegistry') || DEFAULT_DOCKER_REGISTRY, '--version', downloadVersion);
         const dockerPlatform = normalizeDockerPlatform(runtime.env.config.dockerPlatform);
         if (dockerPlatform) {
             argv.push('--docker-platform', dockerPlatform);
         }
         return argv;
     }
-    static buildLocalStartArgv(runtime) {
-        const argv = ['start', '--quickstart'];
-        const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
-            ? ''
-            : trimValue(runtime.env.appPort);
-        if (appPort) {
-            argv.push('--port', appPort);
-        }
-        argv.push('--daemon');
-        return argv;
-    }
-    static async buildDockerUpgradePlan(runtime, downloadVersion) {
-        const dockerRegistry = readEnvValue(runtime.env, 'dockerRegistry') || DEFAULT_DOCKER_REGISTRY;
-        const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
-            ? ''
-            : trimValue(runtime.env.appPort);
-        const storagePath = readEnvValue(runtime.env, 'storagePath');
-        const envFile = await resolveDockerEnvFileArg(runtime.envName, runtime.env.config);
-        const appKey = readEnvValue(runtime.env, 'appKey');
-        const timeZone = readEnvValue(runtime.env, 'timezone');
-        const builtinDbConnection = runtime.env.config.builtinDb ? deriveBuiltinDbConnection(runtime) : undefined;
-        const dbDialect = builtinDbConnection?.dbDialect || readEnvValue(runtime.env, 'dbDialect');
-        const dbHost = builtinDbConnection?.dbHost || readEnvValue(runtime.env, 'dbHost');
-        const dbPort = builtinDbConnection?.dbPort || readEnvValue(runtime.env, 'dbPort');
-        const dbDatabase = readEnvValue(runtime.env, 'dbDatabase');
-        const dbUser = readEnvValue(runtime.env, 'dbUser');
-        const dbPassword = readEnvValue(runtime.env, 'dbPassword');
-        const dbSchema = readEnvValue(runtime.env, 'dbSchema');
-        const dbTablePrefix = readEnvValue(runtime.env, 'dbTablePrefix');
-        const dbUnderscored = typeof runtime.env.config.dbUnderscored === 'boolean'
-            ? runtime.env.config.dbUnderscored
-            : undefined;
-        const networkName = trimValue(runtime.dockerNetworkName || runtime.workspaceName);
-        const missing = [];
-        if (!networkName) {
-            missing.push('docker.network');
-        }
-        if (!storagePath) {
-            missing.push('storagePath');
-        }
-        if (!appKey) {
-            missing.push('appKey');
-        }
-        if (!timeZone) {
-            missing.push('timezone');
-        }
-        if (!dbDialect) {
-            missing.push('dbDialect');
-        }
-        if (!dbHost) {
-            missing.push('dbHost');
-        }
-        if (!dbPort) {
-            missing.push('dbPort');
-        }
-        if (!dbDatabase) {
-            missing.push('dbDatabase');
-        }
-        if (!dbUser) {
-            missing.push('dbUser');
-        }
-        if (!dbPassword) {
-            missing.push('dbPassword');
-        }
-        if (missing.length > 0) {
-            throw new Error(`The saved Docker settings for "${runtime.envName}" are incomplete. Missing: ${missing.join(', ')}. Re-run \`nb init\` or \`nb env add\` to refresh this env config.`);
-        }
-        const imageRef = resolveDockerImageRef(dockerRegistry, downloadVersion, {
-            defaultRegistry: DEFAULT_DOCKER_REGISTRY,
-            defaultVersion: DEFAULT_DOCKER_VERSION,
-        });
-        const args = [
-            'run',
-            '-d',
-            '--name',
-            runtime.containerName,
-            '--restart',
-            'always',
-            '--network',
-            networkName,
-        ];
-        if (appPort) {
-            args.push('-p', `${appPort}:80`);
-        }
-        if (envFile) {
-            args.push('--env-file', envFile);
-        }
-        args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`);
-        pushOptionalEnvArg(args, 'DB_SCHEMA', dbSchema || undefined);
-        pushOptionalEnvArg(args, 'DB_TABLE_PREFIX', dbTablePrefix || undefined);
-        pushOptionalEnvArg(args, 'DB_UNDERSCORED', dbUnderscored);
-        args.push(imageRef);
-        return {
-            containerName: runtime.containerName,
-            networkName,
-            dockerRegistry,
-            downloadVersion,
-            imageRef,
-            appPort: appPort || undefined,
-            storagePath,
-            envFile,
-            appKey,
-            timeZone,
-            dbDialect,
-            dbHost,
-            dbPort,
-            dbDatabase,
-            dbUser,
-            dbPassword,
-            args,
-        };
-    }
-    static async upgradeLocal(runCommand, runtime, downloadVersion, flags, commandStdio) {
-        const displayUrl = formatDisplayUrl(resolveApiBaseUrl(runtime), trimValue(runtime.env.appPort));
-        startTask(`Stopping NocoBase for "${runtime.envName}" before upgrade...`);
-        try {
-            await runLocalNocoBaseCommand(runtime, ['pm2', 'kill'], {
-                stdio: commandStdio,
-            });
-            succeedTask(`Stopped the current NocoBase process for "${runtime.envName}".`);
-        }
-        catch (error) {
-            stopTask();
-            const message = error instanceof Error ? error.message : String(error);
-            printInfo(`No running background process was stopped for "${runtime.envName}". Continuing with the upgrade. (${message})`);
-        }
-        if (!flags['skip-code-update'] && (runtime.source === 'npm' || runtime.source === 'git')) {
-            startTask(`Refreshing NocoBase files for "${runtime.envName}" from the saved ${runtime.source} source...`);
-            try {
-                await runCommand('source:download', AppUpgrade.buildLocalDownloadArgv(runtime, downloadVersion, {
-                    verbose: flags.verbose,
-                }));
-                succeedTask(`NocoBase files are up to date for "${runtime.envName}".`);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                failTask(`Failed to refresh NocoBase files for "${runtime.envName}".`);
-                throw new Error(formatLocalDownloadFailure(runtime.envName, runtime.source, message));
-            }
-        }
-        else if (flags['skip-code-update']) {
-            printInfo(`Skipping code download for "${runtime.envName}" (--skip-code-update).`);
-        }
-        else {
-            printInfo(`Skipping code download for "${runtime.envName}" because this env is managed from an existing local app path.`);
-        }
-        await ensureLocalPostinstall(runtime, {
-            verbose: flags.verbose,
-            onStartTask: startTask,
-            onSucceedTask: succeedTask,
-            onFailTask: failTask,
-        });
-        startTask(`Starting upgraded NocoBase for "${runtime.envName}"...`);
-        try {
-            await runLocalNocoBaseCommand(runtime, AppUpgrade.buildLocalStartArgv(runtime), {
-                stdio: commandStdio,
-            });
-            succeedTask(`Upgraded NocoBase is starting for "${runtime.envName}".`);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            failTask(`Failed to start upgraded NocoBase for "${runtime.envName}".`);
-            throw new Error(formatLocalStartFailure(runtime.envName, runtime.source, trimValue(runtime.env.appPort), message));
-        }
-        await waitForAppHealthCheck({
-            envName: runtime.envName,
-            apiBaseUrl: resolveApiBaseUrl(runtime),
-        });
-        return displayUrl;
-    }
-    static async upgradeDocker(runCommand, runtime, downloadVersion, flags, commandStdio) {
-        const apiBaseUrl = resolveApiBaseUrl(runtime);
-        const containerExists = await dockerContainerExists(runtime.containerName);
-        if (!flags['skip-code-update']) {
-            const plan = await AppUpgrade.buildDockerUpgradePlan(runtime, downloadVersion);
-            startTask(`Refreshing the Docker image for "${runtime.envName}"...`);
-            try {
-                await runCommand('source:download', AppUpgrade.buildDockerDownloadArgv(runtime, plan, {
-                    verbose: flags.verbose,
-                }));
-                succeedTask(`Docker image is ready for "${runtime.envName}".`);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                failTask(`Failed to refresh the Docker image for "${runtime.envName}".`);
-                throw new Error(formatDockerDownloadFailure(runtime.envName, message));
-            }
-        }
-        else {
-            printInfo(`Skipping image download for "${runtime.envName}" (--skip-code-update).`);
-        }
-        if (containerExists) {
-            startTask(`Stopping the current Docker app for "${runtime.envName}"...`);
-            try {
-                const state = await stopDockerContainer(runtime.containerName, {
-                    stdio: commandStdio,
-                });
-                succeedTask(state === 'already-stopped'
-                    ? `The current Docker app was already stopped for "${runtime.envName}".`
-                    : `Stopped the current Docker app for "${runtime.envName}".`);
-            }
-            catch (error) {
-                stopTask();
-                const message = error instanceof Error ? error.message : String(error);
-                printInfo(`Could not stop the existing Docker container for "${runtime.envName}" cleanly. Continuing with container recreation. (${message})`);
-            }
-        }
-        if (flags['skip-code-update'] && containerExists) {
-            startTask(`Starting NocoBase for "${runtime.envName}" with the saved Docker image...`);
-            try {
-                const state = await startDockerContainer(runtime.containerName, {
-                    stdio: commandStdio,
-                });
-                succeedTask(state === 'already-running'
-                    ? `NocoBase is already running for "${runtime.envName}".`
-                    : `NocoBase is starting for "${runtime.envName}".`);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                failTask(`Failed to start the Docker app for "${runtime.envName}".`);
-                throw new Error(formatDockerStartFailure(runtime.envName, message));
-            }
-        }
-        else {
-            const plan = await AppUpgrade.buildDockerUpgradePlan(runtime, downloadVersion);
-            const displayUrl = formatDisplayUrl(apiBaseUrl, plan.appPort);
-            startTask(`Recreating the Docker app container for "${runtime.envName}"...`);
-            try {
-                if (containerExists) {
-                    await run('docker', ['rm', '-f', runtime.containerName], {
-                        errorName: 'docker rm',
-                        stdio: commandStdio,
-                    });
-                }
-                await ensureDockerNetwork(plan.networkName);
-                await run('docker', plan.args, {
-                    errorName: 'docker run',
-                    stdio: commandStdio,
-                });
-                succeedTask(`Docker app container is ready for "${runtime.envName}".`);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                failTask(`Failed to recreate the Docker app for "${runtime.envName}".`);
-                throw new Error(formatDockerStartFailure(runtime.envName, message));
-            }
-            await waitForAppHealthCheck({
-                envName: runtime.envName,
-                apiBaseUrl,
-                containerName: runtime.containerName,
-            });
-            return displayUrl;
-        }
-        await waitForAppHealthCheck({
-            envName: runtime.envName,
-            apiBaseUrl,
-            containerName: runtime.containerName,
-        });
-        return formatDisplayUrl(apiBaseUrl, trimValue(runtime.env.appPort));
-    }
     static async persistDownloadVersion(runtime, downloadVersion) {
         const { name: _name, ...envConfig } = runtime.env.config;
         try {
@@ -587,18 +373,8 @@ export default class AppUpgrade extends Command {
     async run() {
         const { flags } = await this.parse(AppUpgrade);
         const parsed = flags;
-        const requestedEnv = parsed.env?.trim() || undefined;
-        if (requestedEnv && hasExplicitEnvSelection(this.argv)) {
-            const confirmed = await ensureCrossEnvConfirmed({
-                command: this,
-                requestedEnv,
-                yes: parsed.yes,
-            });
-            if (!confirmed) {
-                return;
-            }
-        }
-        const commandStdio = parsed.verbose ? 'inherit' : 'ignore';
+        const requestedEnv = normalizeEnvName(parsed.env);
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -617,16 +393,123 @@ export default class AppUpgrade extends Command {
                 'Use a local or Docker env if you need CLI-managed upgrades right now.',
             ].join('\n'));
         }
+        const interactiveTerminal = isInteractiveTerminal();
+        if (explicitEnvSelection) {
+            if (!interactiveTerminal) {
+                const currentEnv = normalizeEnvName(await getCurrentEnvName());
+                if (currentEnv && currentEnv !== requestedEnv) {
+                    const missingYes = !parsed.yes;
+                    const missingForce = !parsed.force;
+                    if (missingYes || missingForce) {
+                        this.error(formatUpgradeCrossEnvConfirmationRequiredMessage(currentEnv, runtime, parsed, {
+                            missingYes,
+                            missingForce,
+                        }));
+                    }
+                }
+            }
+            else {
+                const confirmed = await ensureCrossEnvConfirmed({
+                    command: this,
+                    requestedEnv,
+                    yes: parsed.yes,
+                });
+                if (!confirmed) {
+                    return;
+                }
+            }
+        }
+        if (!interactiveTerminal) {
+            if (!parsed.force) {
+                this.error(formatUpgradeForceRequiredMessage(runtime, parsed));
+            }
+        }
+        else if (!parsed.force) {
+            let confirmed = false;
+            try {
+                confirmed = await confirm({
+                    message: `Upgrade "${runtime.envName}"? ${formatUpgradePromptSummary(parsed)}`,
+                    default: false,
+                });
+            }
+            catch {
+                return;
+            }
+            if (!confirmed) {
+                return;
+            }
+        }
         announceTargetEnv(runtime.envName);
         try {
             const resolvedVersion = AppUpgrade.resolveUpgradeVersion(runtime, parsed);
+            const skipDownload = shouldSkipDownload(parsed);
             const runCommand = this.config.runCommand.bind(this.config);
-            const displayUrl = runtime.kind === 'docker'
-                ? await AppUpgrade.upgradeDocker(runCommand, runtime, resolvedVersion.downloadVersion, parsed, commandStdio)
-                : await AppUpgrade.upgradeLocal(runCommand, runtime, resolvedVersion.downloadVersion, parsed, commandStdio);
+            await runWithSuppressedTargetEnvLog(async () => {
+                await runCommand('app:stop', buildManagedActionArgv(runtime.envName, parsed));
+            });
+            if (skipDownload) {
+                printInfo(`Skipping source download for "${runtime.envName}" (--skip-download).`);
+                printInfo(`Skipping commercial plugin sync for "${runtime.envName}" (--skip-download).`);
+            }
+            else if (runtime.kind === 'local' && runtime.source === 'local') {
+                printInfo(`Skipping source download for "${runtime.envName}" because this env is managed from an existing local app path.`);
+            }
+            else {
+                const downloadVersion = resolvedVersion.downloadVersion;
+                if (!downloadVersion) {
+                    throw new Error(`Missing downloadVersion for "${runtime.envName}".`);
+                }
+                try {
+                    if (runtime.kind === 'docker') {
+                        await runCommand('source:download', AppUpgrade.buildDockerDownloadArgv(runtime, downloadVersion, {
+                            verbose: parsed.verbose,
+                        }));
+                    }
+                    else if (isDownloadableLocalRuntime(runtime)) {
+                        await runCommand('source:download', AppUpgrade.buildLocalDownloadArgv(runtime, downloadVersion, {
+                            verbose: parsed.verbose,
+                        }));
+                    }
+                    else {
+                        throw new Error(`Skipping source download for "${runtime.envName}" because this env is managed from an existing local app path.`);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (runtime.kind === 'docker') {
+                        throw new Error(formatDockerDownloadFailure(runtime.envName, message));
+                    }
+                    if (isDownloadableLocalRuntime(runtime)) {
+                        throw new Error(formatLocalDownloadFailure(runtime.envName, runtime.source, message));
+                    }
+                    throw new Error(message);
+                }
+            }
+            if (!skipDownload) {
+                await runWithSuppressedTargetEnvLog(async () => {
+                    await runCommand('license:plugins:sync', buildLicenseSyncArgv(runtime.envName, parsed, {
+                        version: resolvedVersion.persistDownloadVersion,
+                    }));
+                });
+            }
+            await runWithSuppressedTargetEnvLog(async () => {
+                await runWithSuppressedStartSuccessLog(async () => {
+                    await runCommand('app:start', buildManagedActionArgv(runtime.envName, parsed, { quickstart: true }));
+                });
+            });
             if (resolvedVersion.persistDownloadVersion) {
                 await AppUpgrade.persistDownloadVersion(runtime, resolvedVersion.persistDownloadVersion);
             }
+            try {
+                await runWithSuppressedTargetEnvLog(async () => {
+                    await runCommand('env:update', buildEnvUpdateArgv(runtime.envName, parsed));
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                printWarning(formatEnvUpdateWarning(runtime.envName, message));
+            }
+            const displayUrl = formatDisplayUrl(runtime.env.baseUrl, runtime.env.appPort === undefined || runtime.env.appPort === null ? undefined : String(runtime.env.appPort));
             succeedTask(`NocoBase has been upgraded for "${runtime.envName}"${displayUrl ? ` at ${displayUrl}` : ''}.`);
         }
         catch (error) {