@nocobase/cli 2.1.0-alpha.40 → 2.1.0-alpha.46

package/dist/commands/app/down.js

@@ -7,145 +7,13 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
-import fsp from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { buildDockerDbContainerName, formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
-import { getCurrentEnvName, removeEnv } from '../../lib/auth-store.js';
-import { resolveConfiguredEnvPath } from '../../lib/cli-home.js';
-import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
-import { confirm } from "../../lib/inquirer.js";
-import { commandOutput, commandSucceeds, run } from '../../lib/run-npm.js';
-import { failTask, isInteractiveTerminal, printInfo, startTask, succeedTask, } from '../../lib/ui.js';
-function resolveConfiguredPath(value) {
-    return resolveConfiguredEnvPath(value);
-}
-function assertSafeRemovalPath(target, label) {
-    const resolved = path.resolve(target);
-    const cwd = path.resolve(process.cwd());
-    const home = path.resolve(os.homedir());
-    const root = path.parse(resolved).root;
-    if (resolved === root || resolved === cwd || resolved === home) {
-        throw new Error(`Refusing to remove ${label} at "${resolved}" because it is too broad.`);
-    }
-}
-async function removePathIfExists(target, label) {
-    const resolved = path.resolve(target);
-    assertSafeRemovalPath(resolved, label);
-    await fsp.rm(resolved, { recursive: true, force: true });
-}
-async function dockerContainerExists(containerName) {
-    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
-}
-async function removeDockerContainerIfExists(containerName) {
-    if (!(await dockerContainerExists(containerName))) {
-        return 'missing';
-    }
-    await run('docker', ['rm', '-f', containerName], {
-        errorName: 'docker rm',
-        stdio: 'ignore',
-    });
-    return 'removed';
-}
-async function dockerNetworkExists(networkName) {
-    return await commandSucceeds('docker', ['network', 'inspect', networkName]);
-}
-async function dockerNetworkHasActiveEndpoints(networkName) {
-    try {
-        const output = await commandOutput('docker', [
-            'network',
-            'inspect',
-            networkName,
-            '--format',
-            '{{json .Containers}}',
-        ], {
-            errorName: 'docker network inspect',
-        });
-        const containers = JSON.parse(output || '{}');
-        return Boolean(containers && typeof containers === 'object' && Object.keys(containers).length > 0);
-    }
-    catch {
-        return false;
-    }
-}
-async function removeDockerNetworkIfUnused(networkName) {
-    if (!(await dockerNetworkExists(networkName))) {
-        return 'missing';
-    }
-    try {
-        await run('docker', ['network', 'rm', networkName], {
-            errorName: 'docker network rm',
-            stdio: 'ignore',
-        });
-        return 'removed';
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (/has active endpoints|is in use|active endpoints/i.test(message)
-            || (await dockerNetworkExists(networkName) && await dockerNetworkHasActiveEndpoints(networkName))) {
-            return 'in-use';
-        }
-        throw error;
-    }
-}
-function builtinDbContainerName(runtime) {
-    if (!runtime.env.config.builtinDb) {
-        return undefined;
-    }
-    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
-    return buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
-}
-function managedDockerNetworkName(runtime) {
-    return runtime.dockerNetworkName?.trim() || runtime.workspaceName?.trim() || undefined;
-}
-async function confirmDownAll(envName, force, options) {
-    if (force) {
-        return true;
-    }
-    const usedCurrentEnv = options?.explicitEnv === false;
-    if (!isInteractiveTerminal()) {
-        if (usedCurrentEnv) {
-            throw new Error(`\`nb app down --all\` is using the current env "${envName}". Re-run with --env ${envName} --force to delete everything for that env in non-interactive mode.`);
-        }
-        throw new Error(`\`nb app down --all\` needs confirmation. Re-run with --force to delete everything for "${envName}" in non-interactive mode.`);
-    }
-    try {
-        return await confirm({
-            message: usedCurrentEnv
-                ? `Delete everything for current env "${envName}"? This removes the app, managed containers, storage data, and the saved CLI env config.`
-                : `Delete everything for "${envName}"? This removes the app, managed containers, storage data, and the saved CLI env config.`,
-            default: false,
-        });
-    }
-    catch {
-        return false;
-    }
-}
-function formatDownCrossEnvForceRequiredMessage(currentEnv, requestedEnv) {
-    return [
-        `Refusing to run against env "${requestedEnv}" because the current env is "${currentEnv}" and interactive confirmation is unavailable in the current agent session.`,
-        '',
-        'For safety, the agent will not switch envs automatically and will not add --force on your behalf.',
-        '',
-        'To continue:',
-        `- run \`nb env use ${requestedEnv}\` yourself and then re-run the command, or`,
-        `- re-run the same command with \`--env ${requestedEnv} --force\` to confirm this one-off cross-env operation.`,
-    ].join('\n');
-}
-function formatDownFailure(envName, message) {
-    return [
-        `Couldn't bring down NocoBase for "${envName}".`,
-        'Some local runtime resources may still exist. Check Docker or the local app process, then try again.',
-        `Details: ${message}`,
-    ].join('\n');
-}
+import { printWarning } from '../../lib/ui.js';
 export default class AppDown extends Command {
-    static hidden = false;
-    static description = 'Bring down the selected env by removing runtime containers and the saved local app files. Storage data and env config are kept unless explicitly requested.';
+    static hidden = true;
+    static description = 'Deprecated compatibility alias for `nb app stop --with-db` and `nb app destroy`.';
     static examples = [
         '<%= config.bin %> <%= command.id %> --env app1',
         '<%= config.bin %> <%= command.id %> --env app1 --all --force',
-        '<%= config.bin %> <%= command.id %> --env app1 --force',
     ];
     static flags = {
         env: Flags.string({
@@ -158,12 +26,12 @@ export default class AppDown extends Command {
         }),
         yes: Flags.boolean({
             char: 'y',
-            description: 'Confirm using --env when it targets a different env than the current env',
+            description: 'Compatibility alias for confirmation flags on the replacement command',
             default: false,
         }),
         force: Flags.boolean({
             char: 'f',
-            description: 'Force a one-off cross-env operation when --env targets a different env in non-interactive mode',
+            description: 'Compatibility alias for confirmation flags on the replacement command',
             default: false,
         }),
         verbose: Flags.boolean({
@@ -173,129 +41,31 @@ export default class AppDown extends Command {
     };
     async run() {
         const { flags } = await this.parse(AppDown);
-        const requestedEnv = flags.env?.trim() || undefined;
-        if (requestedEnv && hasExplicitEnvSelection(this.argv)) {
-            if (!isInteractiveTerminal()) {
-                const currentEnv = await getCurrentEnvName();
-                const normalizedCurrentEnv = String(currentEnv ?? '').trim() || undefined;
-                if (normalizedCurrentEnv && normalizedCurrentEnv !== requestedEnv && !flags.force) {
-                    this.error(formatDownCrossEnvForceRequiredMessage(normalizedCurrentEnv, requestedEnv));
-                }
-            }
-            else {
-                const confirmed = await ensureCrossEnvConfirmed({
-                    command: this,
-                    requestedEnv,
-                    yes: flags.yes,
-                });
-                if (!confirmed) {
-                    return;
-                }
-            }
+        const runCommand = this.config.runCommand.bind(this.config);
+        const envName = flags.env?.trim();
+        const argv = [];
+        if (envName) {
+            argv.push('--env', envName);
         }
-        const explicitEnv = Boolean(requestedEnv);
-        const removeData = Boolean(flags.all);
-        const removeEnvConfig = Boolean(flags.all);
-        const runtime = await resolveManagedAppRuntime(requestedEnv);
-        if (!runtime) {
-            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
-        }
-        if (runtime.kind === 'http') {
-            this.error([
-                `Can't bring down "${runtime.envName}" from this machine.`,
-                'This env only has an API connection, so there is no saved local app, Docker app, or managed database to remove here.',
-                'Use `nb env remove` if you only want to remove the CLI connection config.',
-            ].join('\n'));
-        }
-        if (runtime.kind === 'ssh') {
-            this.error([
-                `Can't bring down "${runtime.envName}" yet.`,
-                'SSH env support is reserved but not implemented yet.',
-                'Use `nb env remove` if you only want to remove the saved CLI config for now.',
-            ].join('\n'));
+        if (flags.verbose) {
+            argv.push('--verbose');
         }
         if (flags.all) {
-            let confirmed = false;
-            try {
-                confirmed = await confirmDownAll(runtime.envName, flags.force, { explicitEnv });
-            }
-            catch (error) {
-                this.error(error instanceof Error ? error.message : String(error));
-            }
-            if (!confirmed) {
-                return;
+            printWarning('`nb app down --all` is deprecated. Use `nb app destroy` instead.');
+            if (flags.force || flags.yes) {
+                argv.push('--force');
             }
+            await runCommand('app:destroy', argv);
+            return;
         }
-        try {
-            if (runtime.kind === 'docker') {
-                startTask(`Removing Docker app container for "${runtime.envName}"...`);
-                const state = await removeDockerContainerIfExists(runtime.containerName);
-                succeedTask(state === 'removed'
-                    ? `Docker app container removed for "${runtime.envName}".`
-                    : `No Docker app container found for "${runtime.envName}".`);
-            }
-            else {
-                startTask(`Stopping local NocoBase app for "${runtime.envName}"...`);
-                await runLocalNocoBaseCommand(runtime, ['pm2', 'kill'], {
-                    stdio: flags.verbose ? 'inherit' : 'ignore',
-                });
-                succeedTask(`Local NocoBase app stopped for "${runtime.envName}".`);
-            }
-            if (runtime.kind === 'local' || runtime.kind === 'docker') {
-                const dbContainerName = builtinDbContainerName(runtime);
-                if (dbContainerName) {
-                    startTask(`Removing built-in database container for "${runtime.envName}"...`);
-                    const state = await removeDockerContainerIfExists(dbContainerName);
-                    succeedTask(state === 'removed'
-                        ? `Built-in database container removed for "${runtime.envName}".`
-                        : `No built-in database container found for "${runtime.envName}".`);
-                }
-                const networkName = managedDockerNetworkName(runtime);
-                if (networkName) {
-                    startTask(`Removing Docker network for "${runtime.envName}" if unused...`);
-                    const state = await removeDockerNetworkIfUnused(networkName);
-                    if (state === 'removed') {
-                        succeedTask(`Docker network removed for "${runtime.envName}".`);
-                    }
-                    else if (state === 'missing') {
-                        succeedTask(`No Docker network found for "${runtime.envName}".`);
-                    }
-                    else {
-                        succeedTask(`Docker network is still in use for "${runtime.envName}". Keeping it.`);
-                    }
-                }
-            }
-            if (runtime.kind === 'local') {
-                const localAppPath = resolveConfiguredPath(runtime.env.config.appRootPath) || runtime.projectRoot;
-                if (localAppPath) {
-                    startTask(`Removing local app files for "${runtime.envName}"...`);
-                    await removePathIfExists(localAppPath, `app files for "${runtime.envName}"`);
-                    succeedTask(`Local app files removed for "${runtime.envName}".`);
-                }
-                else {
-                    printInfo(`No saved local app path found for "${runtime.envName}".`);
-                }
-            }
-            if (removeData) {
-                const configuredStoragePath = resolveConfiguredPath(runtime.env.config.storagePath);
-                if (configuredStoragePath) {
-                    startTask(`Removing storage data for "${runtime.envName}"...`);
-                    await removePathIfExists(configuredStoragePath, `storage data for "${runtime.envName}"`);
-                    succeedTask(`Storage data removed for "${runtime.envName}".`);
-                }
-                else {
-                    printInfo(`No saved storage path found for "${runtime.envName}".`);
-                }
-            }
-            if (removeEnvConfig) {
-                startTask(`Removing saved CLI env config for "${runtime.envName}"...`);
-                const result = await removeEnv(runtime.envName);
-                succeedTask(`Saved CLI env config removed for "${runtime.envName}"${result.lastEnv ? ` (last env: ${result.lastEnv})` : ''}.`);
-            }
+        printWarning('`nb app down` is deprecated. Use `nb app stop --with-db` instead.');
+        argv.push('--with-db');
+        if (flags.yes) {
+            argv.push('--yes');
         }
-        catch (error) {
-            failTask(`Failed to bring down NocoBase for "${runtime.envName}".`);
-            this.error(formatDownFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+        if (flags.force) {
+            argv.push('--force');
         }
+        await runCommand('app:stop', argv);
     }
 }

package/dist/commands/app/restart.js

@@ -55,7 +55,11 @@ export default class AppRestart extends Command {
             default: false,
         }),
         quickstart: Flags.boolean({ description: 'Quickstart the application after stopping it', required: false }),
-        port: Flags.string({ description: 'Port (overrides appPort from env config when set)', char: 'p', required: false }),
+        port: Flags.string({
+            description: 'Port (overrides appPort from env config when set)',
+            char: 'p',
+            required: false,
+        }),
         daemon: Flags.boolean({
             description: 'Run the application as a daemon after stopping it (default: true; use --no-daemon to stay in the foreground)',
             char: 'd',
@@ -63,7 +67,11 @@ export default class AppRestart extends Command {
             default: true,
             allowNo: true,
         }),
-        instances: Flags.integer({ description: 'Number of instances to run after stopping it', char: 'i', required: false }),
+        instances: Flags.integer({
+            description: 'Number of instances to run after stopping it',
+            char: 'i',
+            required: false,
+        }),
         'launch-mode': Flags.string({ description: 'Launch Mode', required: false, options: ['pm2', 'node'] }),
         verbose: Flags.boolean({
             description: 'Show raw shutdown/startup output from the underlying local or Docker command',
@@ -121,14 +129,13 @@ export default class AppRestart extends Command {
                 failTask(`Failed to recreate NocoBase for "${runtime.envName}".`);
                 this.error(formatDockerRestartFailure(runtime.envName, message));
             }
-            const appUrl = formatAppUrl(runtime.env.appPort === undefined || runtime.env.appPort === null
-                ? undefined
-                : String(runtime.env.appPort));
+            const appUrl = formatAppUrl(runtime.env.appPort === undefined || runtime.env.appPort === null ? undefined : String(runtime.env.appPort));
             await waitForAppReady({
                 envName: runtime.envName,
                 apiBaseUrl: resolveManagedAppApiBaseUrl(runtime),
                 containerName: runtime.containerName,
                 logHint: `You can inspect startup logs with \`nb app logs --env ${runtime.envName}\`.`,
+                ...(flags.verbose ? { verbose: true } : {}),
             });
             succeedTask(`NocoBase is running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
             return;

package/dist/commands/app/shared.js

@@ -0,0 +1,122 @@
+/**
+ * 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 fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { buildDockerDbContainerName } from '../../lib/app-runtime.js';
+import { resolveConfiguredEnvPath } from '../../lib/cli-home.js';
+import { commandOutput, run } from '../../lib/run-npm.js';
+export function resolveConfiguredPath(value) {
+    return resolveConfiguredEnvPath(value);
+}
+function assertSafeRemovalPath(target, label) {
+    const resolved = path.resolve(target);
+    const cwd = path.resolve(process.cwd());
+    const home = path.resolve(os.homedir());
+    const root = path.parse(resolved).root;
+    if (resolved === root || resolved === cwd || resolved === home) {
+        throw new Error(`Refusing to remove ${label} at "${resolved}" because it is too broad.`);
+    }
+}
+export async function removePathIfExists(target, label) {
+    const resolved = path.resolve(target);
+    assertSafeRemovalPath(resolved, label);
+    await fsp.rm(resolved, { recursive: true, force: true });
+}
+function isMissingDockerContainerError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /No such (container|object)/i.test(message);
+}
+function isMissingDockerNetworkError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /No such network|network .* not found/i.test(message);
+}
+export async function removeDockerContainerIfExists(containerName, options) {
+    try {
+        await commandOutput('docker', ['container', 'inspect', containerName], {
+            errorName: 'docker container inspect',
+        });
+    }
+    catch (error) {
+        if (isMissingDockerContainerError(error)) {
+            return 'missing';
+        }
+        throw error;
+    }
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: options?.stdio ?? 'ignore',
+    });
+    return 'removed';
+}
+async function dockerNetworkExists(networkName) {
+    try {
+        await commandOutput('docker', ['network', 'inspect', networkName], {
+            errorName: 'docker network inspect',
+        });
+        return true;
+    }
+    catch (error) {
+        if (isMissingDockerNetworkError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function dockerNetworkHasActiveEndpoints(networkName) {
+    try {
+        const output = await commandOutput('docker', ['network', 'inspect', networkName, '--format', '{{json .Containers}}'], {
+            errorName: 'docker network inspect',
+        });
+        const containers = JSON.parse(output || '{}');
+        return Boolean(containers && typeof containers === 'object' && Object.keys(containers).length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+export async function removeDockerNetworkIfUnused(networkName) {
+    if (!(await dockerNetworkExists(networkName))) {
+        return 'missing';
+    }
+    try {
+        await run('docker', ['network', 'rm', networkName], {
+            errorName: 'docker network rm',
+            stdio: 'ignore',
+        });
+        return 'removed';
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/has active endpoints|is in use|active endpoints/i.test(message) ||
+            ((await dockerNetworkExists(networkName)) && (await dockerNetworkHasActiveEndpoints(networkName)))) {
+            return 'in-use';
+        }
+        if (isMissingDockerNetworkError(error)) {
+            return 'missing';
+        }
+        throw error;
+    }
+}
+export function builtinDbContainerName(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return undefined;
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    return buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
+}
+export function managedDockerNetworkName(runtime) {
+    return runtime.dockerNetworkName?.trim() || runtime.workspaceName?.trim() || undefined;
+}
+export function resolveManagedLocalAppPath(runtime) {
+    return resolveConfiguredPath(runtime.env.config.appRootPath) || runtime.projectRoot;
+}
+export function shouldRemoveManagedLocalAppFiles(runtime) {
+    return runtime.source === 'npm' || runtime.source === 'git';
+}

package/dist/commands/app/start.js

@@ -8,11 +8,14 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
-import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, } from '../../lib/app-runtime.js';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
 import { AppHealthCheckError, formatAppUrl, isAppReady, resolveManagedAppApiBaseUrl, waitForAppReady, } from '../../lib/app-health.js';
 import { ensureBuiltinDbReady, ensureLocalPostinstall, ensureSavedLocalSource, recreateSavedDockerApp, } from '../../lib/app-managed-resources.js';
 import { run } from '../../lib/run-npm.js';
 import { announceTargetEnv, failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
+function shouldPrintStartSuccess() {
+    return process.env.NB_SKIP_APP_START_SUCCESS_LOG !== '1';
+}
 function argvHasToken(argv, tokens) {
     return tokens.some((token) => argv.includes(token));
 }
@@ -52,7 +55,7 @@ function formatLocalReadyFailure(envName, message, options) {
 }
 export default class AppStart extends Command {
     static hidden = false;
-    static description = 'Start NocoBase for the selected env. Local npm/git installs run the app command, and Docker installs start the saved app container.';
+    static description = 'Start NocoBase for the selected env. Local npm/git installs run the app command, and Docker installs recreate the saved app container.';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --env local',
@@ -76,7 +79,11 @@ export default class AppStart extends Command {
             default: false,
         }),
         quickstart: Flags.boolean({ description: 'Quickstart the application', required: false }),
-        port: Flags.string({ description: 'Port (overrides appPort from env config when set)', char: 'p', required: false }),
+        port: Flags.string({
+            description: 'Port (overrides appPort from env config when set)',
+            char: 'p',
+            required: false,
+        }),
         daemon: Flags.boolean({
             description: 'Run the application as a daemon (default: true; use --no-daemon to stay in the foreground)',
             char: 'd',
@@ -90,10 +97,6 @@ export default class AppStart extends Command {
             description: 'Show raw startup output from the underlying local or Docker command',
             default: false,
         }),
-        recreate: Flags.boolean({
-            description: 'Recreate the saved Docker app container before starting it',
-            default: false,
-        }),
     };
     async run() {
         const { flags } = await this.parse(AppStart);
@@ -131,7 +134,6 @@ export default class AppStart extends Command {
         announceTargetEnv(runtime.envName);
         if (runtime.kind === 'docker') {
             const unsupportedFlags = [
-                flags.quickstart ? '--quickstart' : undefined,
                 flags.port ? '--port' : undefined,
                 daemonFlagWasProvided ? (flags.daemon ? '--daemon' : '--no-daemon') : undefined,
                 flags.instances !== undefined ? '--instances' : undefined,
@@ -141,7 +143,7 @@ export default class AppStart extends Command {
                 this.error([
                     `Can't apply ${unsupportedFlags.join(', ')} to "${runtime.envName}".`,
                     'This env is managed by Docker, so those options are only available for local npm/git installs.',
-                    `Run \`nb app start --env ${runtime.envName}\` to start the saved container, or recreate the env if you need different runtime settings.`,
+                    `Run \`nb app start --env ${runtime.envName}\` to recreate the saved container, or recreate the env if you need different runtime settings.`,
                 ].join('\n'));
             }
             await ensureBuiltinDbReady(runtime, {
@@ -150,60 +152,34 @@ export default class AppStart extends Command {
                 onSucceedTask: succeedTask,
                 onFailTask: failTask,
             });
-            const appUrl = formatAppUrl(runtime.env.appPort === undefined || runtime.env.appPort === null
-                ? undefined
-                : String(runtime.env.appPort));
+            const appUrl = formatAppUrl(runtime.env.appPort === undefined || runtime.env.appPort === null ? undefined : String(runtime.env.appPort));
             const apiBaseUrl = resolveManagedAppApiBaseUrl(runtime);
-            if (flags.recreate) {
-                startTask(`Recreating the Docker app container for "${runtime.envName}"...`);
-                try {
-                    await run('docker', ['rm', '-f', runtime.containerName], {
-                        errorName: 'docker rm',
-                        stdio: commandStdio,
-                    }).catch(() => undefined);
-                    await recreateSavedDockerApp(runtime, {
-                        verbose: flags.verbose,
-                    });
-                    succeedTask(`Docker app container is ready for "${runtime.envName}".`);
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    failTask(`Failed to recreate NocoBase for "${runtime.envName}".`);
-                    this.error(formatDockerStartFailure(runtime.envName, message));
-                }
+            startTask(`Recreating the Docker app container for "${runtime.envName}"...`);
+            try {
+                await run('docker', ['rm', '-f', runtime.containerName], {
+                    errorName: 'docker rm',
+                    stdio: commandStdio,
+                }).catch(() => undefined);
+                await recreateSavedDockerApp(runtime, {
+                    verbose: flags.verbose,
+                });
+                succeedTask(`Docker app container is ready for "${runtime.envName}".`);
             }
-            else {
-                startTask(`Starting NocoBase for "${runtime.envName}"...`);
-                try {
-                    const state = await startDockerContainer(runtime.containerName, {
-                        stdio: commandStdio,
-                    });
-                    if (state === 'already-running' && await isAppReady(apiBaseUrl)) {
-                        succeedTask(`NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
-                        return;
-                    }
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (/does not exist/i.test(message)) {
-                        printInfo(`The saved Docker app container for "${runtime.envName}" is missing. Recreating it from the saved Docker env settings...`);
-                        await recreateSavedDockerApp(runtime, {
-                            verbose: flags.verbose,
-                        });
-                    }
-                    else {
-                        failTask(`Failed to start NocoBase for "${runtime.envName}".`);
-                        this.error(formatDockerStartFailure(runtime.envName, message));
-                    }
-                }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failTask(`Failed to recreate NocoBase for "${runtime.envName}".`);
+                this.error(formatDockerStartFailure(runtime.envName, message));
             }
             await waitForAppReady({
                 envName: runtime.envName,
                 apiBaseUrl,
                 containerName: runtime.containerName,
                 logHint: `You can inspect startup logs with \`nb app logs --env ${runtime.envName}\`.`,
+                ...(flags.verbose ? { verbose: true } : {}),
             });
-            succeedTask(`NocoBase is running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
+            if (shouldPrintStartSuccess()) {
+                succeedTask(`NocoBase is running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
+            }
             return;
         }
         await ensureBuiltinDbReady(runtime, {
@@ -229,7 +205,9 @@ export default class AppStart extends Command {
         if (flags.port) {
             npmArgs.push('--port', flags.port);
         }
-        else if (runtime.env.appPort !== undefined && runtime.env.appPort !== null && String(runtime.env.appPort).trim() !== '') {
+        else if (runtime.env.appPort !== undefined &&
+            runtime.env.appPort !== null &&
+            String(runtime.env.appPort).trim() !== '') {
             npmArgs.push('--port', String(runtime.env.appPort));
         }
         if (flags.daemon !== false) {
@@ -241,8 +219,8 @@ export default class AppStart extends Command {
         if (flags['launch-mode']) {
             npmArgs.push('--launch-mode', flags['launch-mode']);
         }
-        const effectivePort = flags.port
-            || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
+        const effectivePort = flags.port ||
+            (runtime.env.appPort !== undefined && runtime.env.appPort !== null
                 ? String(runtime.env.appPort).trim()
                 : undefined);
         const appUrl = formatAppUrl(effectivePort);
@@ -254,7 +232,9 @@ export default class AppStart extends Command {
                 printInfo(`NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}. Use \`nb app stop --env ${runtime.envName}\` before starting it again in the foreground.`);
             }
             else {
-                succeedTask(`NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
+                if (shouldPrintStartSuccess()) {
+                    succeedTask(`NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
+                }
             }
             return;
         }
@@ -285,7 +265,9 @@ export default class AppStart extends Command {
                     apiBaseUrl,
                     logHint: `You can inspect startup logs with \`nb app logs --env ${runtime.envName}\`.`,
                 });
-                succeedTask(`NocoBase is running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
+                if (shouldPrintStartSuccess()) {
+                    succeedTask(`NocoBase is running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
+                }
             }
         }
         catch (error) {