@nocobase/cli 2.1.0-beta.36 → 2.1.0-beta.38

package/README.md

@@ -61,7 +61,7 @@ When creating a new app, it can also install NocoBase AI coding skills
 (`nocobase/skills`) globally.
 
 Use `--skip-skills` if the skills are managed separately, or when running in CI
-or offline environments where `nb init` should not install or update them.
+or offline environments where `nb init` should not install them.
 
 ### Non-Interactive Setup
 
@@ -265,28 +265,40 @@ nb db logs --env app1
 
 Notes:
 
+- `nb db start` can also recreate the saved built-in database container when it has been removed.
 - `nb db start` and `nb db stop` only work for envs created with the built-in database option enabled.
 - `nb db logs` only works for envs created with the built-in database option enabled.
 - `nb db ps` can also show `external` or `remote` status for envs that do not have a CLI-managed database container.
 
 ## Cleanup
 
-Bring down a local env:
+Stop only the app runtime:
 
 ```bash
-nb app down --env app1
+nb app stop --env app1
+```
+
+Stop the app runtime and also remove the CLI-managed built-in database runtime when present:
+
+```bash
+nb app stop --env app1 --with-db
 ```
 
-By default, `nb app down` stops the app and removes app/database containers if they
-exist. For local envs, it also deletes the saved local app files. It keeps storage data and CLI env config.
+- `nb app stop` keeps storage data and the saved CLI env config.
+- Docker envs remove the saved app container when stopped.
+- `--with-db` only affects CLI-managed built-in databases. External databases are not touched.
 
-Use explicit flags for destructive cleanup:
+Destroy the env's managed local resources:
 
 ```bash
-nb app down --env app1 --all --yes
+nb app destroy --env app1
+nb app destroy --env app1 --force
 ```
 
-- `--all`: delete everything for the env, including storage data and the saved env config. This requires `--yes`.
+- `nb app destroy` removes managed runtime resources, storage data, and the saved CLI env config.
+- For downloaded npm/Git envs, `nb app destroy` also removes the saved local app files. Custom local app directories are kept.
+- In interactive terminals, `nb app destroy` requires a strong confirmation prompt. In non-interactive mode, re-run with `--env <name> --force`.
+- `nb app down` is deprecated. Use `nb app stop --with-db` for runtime cleanup, or `nb app destroy` for destructive cleanup.
 
 ## Environment Management
 

package/README.zh-CN.md

@@ -55,7 +55,7 @@ nb init --ui
 
 `nb init` 可以连接已有的 NocoBase 应用，也可以安装一个新的 NocoBase 应用。创建新应用时，还可以全局安装 NocoBase AI coding skills (`nocobase/skills`)。
 
-如果已经自行管理 skills，或在 CI、离线环境中运行，不希望 `nb init` 安装或更新 skills，可以传入 `--skip-skills`。
+如果已经自行管理 skills，或在 CI、离线环境中运行，不希望 `nb init` 安装 skills，可以传入 `--skip-skills`。
 
 ### 非交互式初始化
 
@@ -225,28 +225,40 @@ nb db logs --env app1
 
 说明：
 
+- `nb db start` 在内置数据库容器已被删除时，也可以根据已保存的 env 配置自动恢复它。
 - `nb db start` 和 `nb db stop` 只适用于启用了内置数据库的 env。
 - `nb db logs` 只适用于启用了内置数据库的 env。
 - 对于没有 CLI 托管数据库容器的 env，`nb db ps` 也会显示 `external` 或 `remote` 状态。
 
 ## 清理
 
-关闭并清理某个本地 env：
+只停止应用运行态：
 
 ```bash
-nb app down --env app1
+nb app stop --env app1
+```
+
+如果还要一并移除 CLI 托管的内置数据库运行态，可以使用：
+
+```bash
+nb app stop --env app1 --with-db
 ```
 
-默认情况下，`nb app down` 会停止应用，并在存在时移除应用容器和数据库容器。它不会删除用户数据、源码文件和 CLI env 配置。
-对于本地 env，它还会删除已保存的本地 app 目录。默认仍会保留 storage 数据和 CLI env 配置。
+- `nb app stop` 会保留 storage 数据和已保存的 CLI env 配置。
+- Docker env 停止时会移除已保存的 app container。
+- `--with-db` 只会影响 CLI 托管的内置数据库，external db 不会被处理。
 
-如需执行破坏性清理，需要显式指定参数：
+销毁该 env 的本地托管资源：
 
 ```bash
-nb app down --env app1 --all --yes
+nb app destroy --env app1
+nb app destroy --env app1 --force
 ```
 
-- `--all`：删除该 env 的所有内容，包括 storage 数据和已保存的 CLI env 配置。必须同时传 `--yes`。
+- `nb app destroy` 会删除托管的运行时资源、storage 数据以及已保存的 CLI env 配置。
+- 对于通过 npm/Git 下载的 env，`nb app destroy` 还会删除已保存的本地 app 文件。自定义的本地源码目录会被保留。
+- 在交互终端中，`nb app destroy` 需要强确认；在非交互模式下，需要显式传入 `--env <name> --force`。
+- `nb app down` 已废弃。运行态清理请使用 `nb app stop --with-db`，彻底销毁请使用 `nb app destroy`。
 
 ## Env 管理
 

package/bin/run.js

@@ -4,6 +4,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import pc from 'picocolors';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { normalizeNodeOptions, normalizeSessionEnv } from './session-env.js';
 
@@ -130,6 +131,6 @@ try {
   flush();
 } catch (error) {
   const message = formatCliEntryError(error, process.argv.slice(2));
-  console.error(message);
-  process.exitCode = 1;
+  console.error(pc.red(message));
+  process.exit(1);
 }

package/dist/commands/app/destroy.js

@@ -0,0 +1,225 @@
+/**
+ * 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 { Command, Flags } from '@oclif/core';
+import { removeEnv } from '../../lib/auth-store.js';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { input } from "../../lib/inquirer.js";
+import { announceTargetEnv, failTask, isInteractiveTerminal, printInfo, startTask, succeedTask } from '../../lib/ui.js';
+import { builtinDbContainerName, managedDockerNetworkName, removeDockerContainerIfExists, removeDockerNetworkIfUnused, removePathIfExists, resolveConfiguredPath, resolveManagedLocalAppPath, shouldRemoveManagedLocalAppFiles, } from './shared.js';
+function formatDestroyFailure(envName, message) {
+    return [
+        `Couldn't destroy env "${envName}".`,
+        'Some managed local resources may still exist. Check Docker, local app files, and storage data, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function formatDestroyForceRequiredMessage(envName, explicitEnv) {
+    if (!explicitEnv) {
+        return [
+            `Refusing to destroy current env "${envName}" without explicit selection in non-interactive mode.`,
+            `Re-run with \`--env ${envName} --force\` to destroy this env.`,
+        ].join('\n');
+    }
+    return [
+        `Refusing to destroy env "${envName}" without confirmation in non-interactive mode.`,
+        `Re-run with \`--env ${envName} --force\` to destroy this env.`,
+    ].join('\n');
+}
+function buildDestroyPrompt(runtime, options) {
+    const subject = options.explicitEnv ? `env "${runtime.envName}"` : `current env "${runtime.envName}"`;
+    const lines = [`Destroy ${subject}?`];
+    if (runtime.kind === 'http' || runtime.kind === 'ssh') {
+        lines.push('This env has no CLI-managed local app or database runtime on this machine.');
+        lines.push('Only the saved CLI env config will be removed. External services are not touched.');
+    }
+    else {
+        lines.push('This removes managed app runtime resources.');
+        if (runtime.env.config.builtinDb) {
+            lines.push('CLI-managed built-in database runtime will also be removed.');
+        }
+        else {
+            lines.push('External database resources are not managed by the CLI and will be left untouched.');
+        }
+        if (options.removesManagedLocalAppFiles) {
+            lines.push('CLI-managed local app files will also be removed.');
+        }
+        else if (runtime.kind === 'local') {
+            lines.push('Custom local app source files will be kept.');
+        }
+        if (options.removesStorageData) {
+            lines.push('Storage data will be removed.');
+        }
+        else {
+            lines.push('No saved storage path was found for this env.');
+        }
+        lines.push('The saved CLI env config will be removed.');
+    }
+    lines.push(`Type "${runtime.envName}" to confirm:`);
+    return lines.join('\n');
+}
+async function confirmDestroy(runtime, options) {
+    if (!isInteractiveTerminal()) {
+        if (!options.explicitEnv) {
+            throw new Error(formatDestroyForceRequiredMessage(runtime.envName, false));
+        }
+        if (options.force) {
+            return true;
+        }
+        throw new Error(formatDestroyForceRequiredMessage(runtime.envName, options.explicitEnv));
+    }
+    if (options.force) {
+        return true;
+    }
+    try {
+        await input({
+            message: buildDestroyPrompt(runtime, options),
+            required: true,
+            validate: (value) => (value.trim() === runtime.envName ? true : `Type "${runtime.envName}" to confirm.`),
+            placeholder: runtime.envName,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export default class AppDestroy extends Command {
+    static hidden = false;
+    static description = 'Destroy the selected env by removing managed runtime resources, storage data, and the saved CLI env config.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --force',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to destroy. Defaults to the current env when omitted in interactive mode',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation and destroy the selected env immediately',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw output from destruction commands',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppDestroy);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const explicitEnv = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const removesManagedLocalAppFiles = runtime.kind === 'local' &&
+            Boolean(resolveManagedLocalAppPath(runtime)) &&
+            shouldRemoveManagedLocalAppFiles(runtime);
+        const removesStorageData = (runtime.kind === 'local' || runtime.kind === 'docker') &&
+            Boolean(resolveConfiguredPath(runtime.env.config.storagePath));
+        let confirmed = false;
+        try {
+            confirmed = await confirmDestroy(runtime, {
+                explicitEnv,
+                force: flags.force,
+                removesManagedLocalAppFiles,
+                removesStorageData,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+        if (!confirmed) {
+            return;
+        }
+        announceTargetEnv(runtime.envName);
+        try {
+            if (runtime.kind === 'docker') {
+                startTask(`Removing Docker app container for "${runtime.envName}"...`);
+                const state = await removeDockerContainerIfExists(runtime.containerName, {
+                    stdio: flags.verbose ? 'inherit' : 'ignore',
+                });
+                succeedTask(state === 'removed'
+                    ? `Docker app container removed for "${runtime.envName}".`
+                    : `No Docker app container found for "${runtime.envName}".`);
+            }
+            else if (runtime.kind === 'local') {
+                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 dbContainer = builtinDbContainerName(runtime);
+                if (dbContainer) {
+                    startTask(`Removing built-in database container for "${runtime.envName}"...`);
+                    const state = await removeDockerContainerIfExists(dbContainer, {
+                        stdio: flags.verbose ? 'inherit' : 'ignore',
+                    });
+                    succeedTask(state === 'removed'
+                        ? `Built-in database container removed for "${runtime.envName}".`
+                        : `No built-in database container found for "${runtime.envName}".`);
+                }
+                else {
+                    printInfo(`External database resources for "${runtime.envName}" were left untouched.`);
+                }
+                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 = resolveManagedLocalAppPath(runtime);
+                    if (localAppPath && removesManagedLocalAppFiles) {
+                        startTask(`Removing managed local app files for "${runtime.envName}"...`);
+                        await removePathIfExists(localAppPath, `managed app files for "${runtime.envName}"`);
+                        succeedTask(`Managed local app files removed for "${runtime.envName}".`);
+                    }
+                    else if (localAppPath) {
+                        printInfo(`Keeping custom local app files for "${runtime.envName}" at "${localAppPath}".`);
+                    }
+                    else {
+                        printInfo(`No saved local app path found for "${runtime.envName}".`);
+                    }
+                }
+                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}".`);
+                }
+            }
+            else {
+                printInfo(`No CLI-managed local app or database runtime exists for "${runtime.envName}" on this machine.`);
+            }
+            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})` : ''}.`);
+        }
+        catch (error) {
+            failTask(`Failed to destroy env "${runtime.envName}".`);
+            this.error(formatDestroyFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+        }
+    }
+}

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);
     }
 }