@nocobase/cli 2.1.0-alpha.24 → 2.1.0-alpha.26

package/dist/commands/env/add.js

@@ -8,6 +8,8 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { upsertEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { buildStoredEnvConfig, } from '../../lib/env-config.js';
 import { runPromptCatalog, } from '../../lib/prompt-catalog.js';
 import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, localeText, } from '../../lib/cli-locale.js';
 import { validateApiBaseUrl } from '../../lib/prompt-validators.js';
@@ -32,6 +34,10 @@ const ENV_RUNTIME_FLAG_MAP = {
     'db-database': 'dbDatabase',
     'db-user': 'dbUser',
     'db-password': 'dbPassword',
+    'root-username': 'rootUsername',
+    'root-email': 'rootEmail',
+    'root-password': 'rootPassword',
+    'root-nickname': 'rootNickname',
 };
 const ENV_BOOLEAN_RUNTIME_FLAG_MAP = {
     'builtin-db': 'builtinDb',
@@ -45,7 +51,7 @@ export default class EnvAdd extends Command {
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> local',
-        '<%= config.bin %> <%= command.id %> local --scope project --api-base-url http://localhost:13000/api --auth-type oauth',
+        '<%= config.bin %> <%= command.id %> local --api-base-url http://localhost:13000/api --auth-type oauth',
     ];
     static args = {
         name: Args.string({
@@ -73,12 +79,6 @@ export default class EnvAdd extends Command {
             description: 'Skip command intro when invoked by another CLI command',
             default: false,
         }),
-        scope: Flags.string({
-            char: 's',
-            description: 'Where to store env config: project (.nocobase in the repo) or global (user-level); prompted in a TTY when omitted',
-            options: ['project', 'global'],
-            default: 'project',
-        }),
         'default-api-base-url': Flags.string({
             char: 'd',
             hidden: true,
@@ -86,7 +86,6 @@ export default class EnvAdd extends Command {
         }),
         'api-base-url': Flags.string({
             char: 'u',
-            aliases: ['base-url'],
             description: 'Root URL for HTTP API calls, including the /api prefix (e.g. http://localhost:13000/api); prompted in a TTY when omitted',
         }),
         'auth-type': Flags.string({
@@ -191,6 +190,22 @@ export default class EnvAdd extends Command {
             hidden: true,
             description: 'Database password saved with this env',
         }),
+        'root-username': Flags.string({
+            hidden: true,
+            description: 'Initial root username saved with this env',
+        }),
+        'root-email': Flags.string({
+            hidden: true,
+            description: 'Initial root email saved with this env',
+        }),
+        'root-password': Flags.string({
+            hidden: true,
+            description: 'Initial root password saved with this env',
+        }),
+        'root-nickname': Flags.string({
+            hidden: true,
+            description: 'Initial root nickname saved with this env',
+        }),
     };
     static prompts = {
         name: {
@@ -199,24 +214,6 @@ export default class EnvAdd extends Command {
             placeholder: envAddText('prompts.name.placeholder'),
             required: true,
         },
-        scope: {
-            type: 'select',
-            message: envAddText('prompts.scope.message'),
-            options: [
-                {
-                    value: 'project',
-                    label: envAddText('prompts.scope.projectLabel'),
-                    hint: envAddText('prompts.scope.projectHint'),
-                },
-                {
-                    value: 'global',
-                    label: envAddText('prompts.scope.globalLabel'),
-                    hint: envAddText('prompts.scope.globalHint'),
-                },
-            ],
-            initialValue: 'project',
-            required: true,
-        },
         apiBaseUrl: {
             type: 'text',
             message: envAddText('prompts.apiBaseUrl.message'),
@@ -252,10 +249,7 @@ export default class EnvAdd extends Command {
         if (name) {
             values.name = name;
         }
-        if (flags.scope) {
-            values.scope = flags.scope;
-        }
-        const apiFromFlag = flags['api-base-url'] ?? flags['base-url'];
+        const apiFromFlag = flags['api-base-url'];
         if (typeof apiFromFlag === 'string' && apiFromFlag.trim() !== '') {
             values.apiBaseUrl = apiFromFlag.trim();
         }
@@ -277,28 +271,20 @@ export default class EnvAdd extends Command {
         return initialValues;
     }
     buildEnvConfig(results, flags) {
-        const envConfig = {
-            baseUrl: String(results.apiBaseUrl ?? ''),
+        const envConfigInput = {
+            apiBaseUrl: results.apiBaseUrl,
+            authType: results.authType,
+            accessToken: results.accessToken,
         };
         for (const [flagName, configKey] of Object.entries(ENV_RUNTIME_FLAG_MAP)) {
             const value = flags[flagName];
-            if (typeof value === 'string' && value.trim() !== '') {
-                envConfig[configKey] = value.trim();
-            }
+            envConfigInput[configKey] = value;
         }
         for (const [flagName, configKey] of Object.entries(ENV_BOOLEAN_RUNTIME_FLAG_MAP)) {
             const value = flags[flagName];
-            if (typeof value === 'boolean') {
-                envConfig[configKey] = value;
-            }
-        }
-        if (flags['builtin-db'] === false) {
-            envConfig.builtinDbImage = undefined;
-        }
-        if (results.authType === 'token' && results.accessToken != null) {
-            envConfig.accessToken = String(results.accessToken);
+            envConfigInput[configKey] = value;
         }
-        return envConfig;
+        return buildStoredEnvConfig(envConfigInput);
     }
     async run() {
         const { args, flags } = await this.parse(EnvAdd);
@@ -314,10 +300,9 @@ export default class EnvAdd extends Command {
             command: this,
         });
         const envName = String(results.name);
-        const scope = results.scope;
         const envConfig = this.buildEnvConfig(results, parsedFlags);
-        printVerbose(`Saving env "${envName}" with scope "${scope}".`);
-        await upsertEnv(envName, envConfig, { scope });
+        printVerbose(`Saving env "${envName}" globally.`);
+        await upsertEnv(envName, envConfig, { scope: resolveDefaultConfigScope() });
         if (results.authType === 'oauth') {
             await this.config.runCommand('env:auth', [envName]);
         }

package/dist/commands/env/auth.js

@@ -8,7 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { getCurrentEnvName } from '../../lib/auth-store.js';
-import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
 import { authenticateEnvWithOauth } from '../../lib/env-auth.js';
 import { failTask, startTask, succeedTask } from '../../lib/ui.js';
 export default class EnvAuth extends Command {
@@ -16,7 +16,6 @@ export default class EnvAuth extends Command {
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> prod',
-        '<%= config.bin %> <%= command.id %> --scope global',
     ];
     static args = {
         name: Args.string({
@@ -31,31 +30,25 @@ export default class EnvAuth extends Command {
             deprecated: true,
             description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
         }),
-        scope: Flags.string({
-            char: 's',
-            description: 'Config scope',
-            options: ['project', 'global'],
-        }),
     };
     async run() {
         const { args, flags } = await this.parse(EnvAuth);
-        const scope = flags.scope;
         const nameArg = args.name?.trim();
         const nameFlag = flags.env?.trim() || undefined;
         if (nameArg && nameFlag && nameArg !== nameFlag) {
             this.error(`Environment name was provided both as the argument ("${nameArg}") and as --env ("${nameFlag}"). Please use only one.`);
         }
-        const envName = nameArg || nameFlag || (await getCurrentEnvName({ scope }));
-        startTask(`Starting browser sign-in for "${envName}"${scope ? ` (${formatCliHomeScope(scope)} scope)` : ''}...`);
+        const envName = nameArg || nameFlag || (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+        startTask(`Starting browser sign-in for "${envName}"...`);
         try {
             await authenticateEnvWithOauth({
                 envName,
-                scope,
+                scope: resolveDefaultConfigScope(),
             });
-            succeedTask(`Signed in to "${envName}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            succeedTask(`Signed in to "${envName}".`);
         }
         catch (error) {
-            failTask(`Sign-in failed for "${envName}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            failTask(`Sign-in failed for "${envName}".`);
             throw error;
         }
     }

package/dist/commands/env/info.js

@@ -0,0 +1,152 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { renderTable } from '../../lib/ui.js';
+import { appRootPath, dbStatus, runtimeStatus, storagePath } from './shared.js';
+function normalizeJsonValue(value) {
+    if (value === undefined || value === null || value === '') {
+        return '-';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}
+function normalizeValue(value) {
+    if (value === undefined || value === null || value === '') {
+        return '-';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    return String(value);
+}
+function maskSecret(value, showSecrets) {
+    const normalized = normalizeValue(value);
+    if (normalized === '-') {
+        return normalized;
+    }
+    return showSecrets ? normalized : '********';
+}
+function createGroupTable(title, values) {
+    const rows = Object.entries(values).map(([field, value]) => [field, normalizeValue(value)]);
+    return `${title}\n${renderTable(['Field', 'Value'], rows)}`;
+}
+function serializeGroup(values) {
+    return Object.fromEntries(Object.entries(values).map(([field, value]) => [field, normalizeJsonValue(value)]));
+}
+export default class EnvInfo extends Command {
+    static hidden = false;
+    static description = 'Show grouped details for the selected NocoBase env, including app, database, API, and auth settings.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> app1',
+        '<%= config.bin %> <%= command.id %> app1 --json',
+        '<%= config.bin %> <%= command.id %> app1 --show-secrets',
+        '<%= config.bin %> <%= command.id %> --env app1',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'CLI env name to inspect. Defaults to the current env when omitted',
+            required: false,
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to inspect. Defaults to the current env when omitted',
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+        'show-secrets': Flags.boolean({
+            description: 'Show secret values in plain text',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvInfo);
+        const envNameArg = args.name?.trim() || undefined;
+        const envNameFlag = flags.env?.trim() || undefined;
+        if (envNameArg && envNameFlag && envNameArg !== envNameFlag) {
+            this.error(`Environment name was provided both as the argument ("${envNameArg}") and as --env ("${envNameFlag}"). Please use only one.`);
+        }
+        const requestedEnv = envNameArg || envNameFlag;
+        const showSecrets = flags['show-secrets'];
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const auth = runtime.env.auth;
+        const appGroup = {
+            appRootPath: appRootPath(runtime),
+            storagePath: storagePath(runtime),
+            appPort: runtime.env.config.appPort,
+            appStatus: await runtimeStatus(runtime),
+            source: runtime.source,
+            downloadVersion: runtime.env.config.downloadVersion,
+            dockerRegistry: runtime.env.config.dockerRegistry,
+            dockerPlatform: runtime.env.config.dockerPlatform,
+            timezone: runtime.env.config.timezone,
+        };
+        const dbGroup = {
+            databaseStatus: await dbStatus(runtime),
+            builtinDb: runtime.env.config.builtinDb,
+            dbDialect: runtime.env.config.dbDialect,
+            builtinDbImage: runtime.env.config.builtinDbImage,
+            dbHost: runtime.env.config.dbHost,
+            dbPort: runtime.env.config.dbPort,
+            dbDatabase: runtime.env.config.dbDatabase,
+            dbUser: runtime.env.config.dbUser,
+            dbPassword: maskSecret(runtime.env.config.dbPassword, showSecrets),
+        };
+        const authGroup = {
+            type: auth?.type,
+            expiresAt: auth?.type === 'oauth' ? auth.expiresAt : undefined,
+            scope: auth?.type === 'oauth' ? auth.scope : undefined,
+            issuer: auth?.type === 'oauth' ? auth.issuer : undefined,
+            clientId: auth?.type === 'oauth' ? auth.clientId : undefined,
+            resource: auth?.type === 'oauth' ? auth.resource : undefined,
+            accessToken: maskSecret(auth?.accessToken, showSecrets),
+            refreshToken: maskSecret(auth?.type === 'oauth' ? auth.refreshToken : undefined, showSecrets),
+        };
+        const apiGroup = {
+            apiBaseUrl: runtime.env.apiBaseUrl,
+            'auth.type': authGroup.type,
+            'auth.expiresAt': authGroup.expiresAt,
+            'auth.scope': authGroup.scope,
+            'auth.issuer': authGroup.issuer,
+            'auth.clientId': authGroup.clientId,
+            'auth.resource': authGroup.resource,
+            'auth.accessToken': authGroup.accessToken,
+            'auth.refreshToken': authGroup.refreshToken,
+        };
+        const output = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            app: serializeGroup(appGroup),
+            db: serializeGroup(dbGroup),
+            api: {
+                apiBaseUrl: normalizeJsonValue(runtime.env.apiBaseUrl),
+                auth: serializeGroup(authGroup),
+            },
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        this.log([
+            createGroupTable('App', appGroup),
+            createGroupTable('DB', dbGroup),
+            createGroupTable('API', apiGroup),
+        ].join('\n\n'));
+    }
+}

package/dist/commands/env/list.js

@@ -6,36 +6,45 @@
  * 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 { Command } from '@oclif/core';
+import { resolveManagedAppRuntime } from '../../lib/app-runtime.js';
 import { listEnvs } from '../../lib/auth-store.js';
-import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
 import { renderTable } from '../../lib/ui.js';
+import { apiStatus, appUrl, resolveApiBaseUrl } from './shared.js';
 export default class EnvList extends Command {
-    static summary = 'List configured environments';
+    static summary = 'List configured environments and API auth status';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
     ];
-    static flags = {
-        scope: Flags.string({
-            char: 's',
-            description: 'Config scope',
-            options: ['project', 'global'],
-        }),
-    };
     async run() {
-        const { flags } = await this.parse(EnvList);
-        const scope = flags.scope;
+        await this.parse(EnvList);
+        const scope = resolveDefaultConfigScope();
         const { currentEnv, envs } = await listEnvs({ scope });
         const names = Object.keys(envs).sort();
         if (!names.length) {
-            this.log(`No envs configured${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
-            this.log('Run `nb env add <name> --base-url <url>` to add one.');
+            this.log('No envs configured.');
+            this.log('Run `nb env add <name> --api-base-url <url>` to add one.');
             return;
         }
-        const rows = names.map((name) => {
+        const rows = [];
+        for (const name of names) {
             const env = envs[name];
-            return [name === currentEnv ? '*' : '', name, env.baseUrl ?? '', env.auth?.type ?? '', env.runtime?.version ?? ''];
-        });
-        this.log(renderTable(['Current', 'Name', 'Base URL', 'Auth', 'Runtime'], rows));
+            const runtime = await resolveManagedAppRuntime(name);
+            const statusConfig = {
+                ...env,
+                ...(runtime?.env.config ?? {}),
+            };
+            rows.push([
+                name === currentEnv ? '*' : '',
+                name,
+                runtime?.kind ?? env.kind ?? '-',
+                await apiStatus(name, statusConfig, { scope }),
+                runtime ? appUrl(runtime) : resolveApiBaseUrl(env),
+                env.auth?.type ?? '',
+                env.runtime?.version ?? '',
+            ]);
+        }
+        this.log(renderTable(['Current', 'Name', 'Kind', 'App Status', 'URL', 'Auth', 'Runtime'], rows));
     }
 }

package/dist/commands/env/remove.js

@@ -8,7 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { getCurrentEnvName, removeEnv } from '../../lib/auth-store.js';
-import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
 import { confirmAction, isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
 export default class EnvRemove extends Command {
     static summary = 'Remove a configured environment';
@@ -26,11 +26,6 @@ export default class EnvRemove extends Command {
             description: 'Show detailed progress output',
             default: false,
         }),
-        scope: Flags.string({
-            char: 's',
-            description: 'Config scope',
-            options: ['project', 'global'],
-        }),
     };
     static args = {
         name: Args.string({
@@ -41,8 +36,7 @@ export default class EnvRemove extends Command {
     async run() {
         const { args, flags } = await this.parse(EnvRemove);
         setVerboseMode(flags.verbose);
-        const scope = flags.scope;
-        const currentEnv = await getCurrentEnvName({ scope });
+        const currentEnv = await getCurrentEnvName({ scope: resolveDefaultConfigScope() });
         if (args.name === currentEnv && !flags.force) {
             if (!isInteractiveTerminal()) {
                 this.error('Refusing to remove the current env without confirmation. Re-run with `--force`.');
@@ -54,8 +48,8 @@ export default class EnvRemove extends Command {
             }
         }
         printVerbose(`Removing env "${args.name}"`);
-        const result = await removeEnv(args.name, { scope });
-        this.log(`Removed env "${result.removed}"${scope ? ` from ${formatCliHomeScope(scope)} scope` : ''}.`);
+        const result = await removeEnv(args.name, { scope: resolveDefaultConfigScope() });
+        this.log(`Removed env "${result.removed}".`);
         if (result.hasEnvs) {
             this.log(`Current env: ${result.currentEnv}`);
             return;

package/dist/commands/env/shared.js

@@ -0,0 +1,158 @@
+/**
+ * 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 { buildDockerDbContainerName, dockerContainerExists, dockerContainerIsRunning, } from '../../lib/app-runtime.js';
+import { executeRawApiRequest } from '../../lib/api-client.js';
+export function resolveApiBaseUrl(config) {
+    return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
+}
+export function appUrl(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (port) {
+        return `http://127.0.0.1:${port}`;
+    }
+    const baseUrl = resolveApiBaseUrl(runtime.env.config);
+    return baseUrl.replace(/\/api\/?$/, '');
+}
+export function appRootPath(runtime) {
+    if (runtime.kind === 'http' || runtime.kind === 'docker') {
+        return '-';
+    }
+    if (runtime.kind === 'local') {
+        return String(runtime.projectRoot ?? runtime.env.appRootPath ?? '').trim() || '-';
+    }
+    return String(runtime.env.config.appRootPath ?? '').trim() || '-';
+}
+export function storagePath(runtime) {
+    if (runtime.kind === 'http') {
+        return '-';
+    }
+    const value = String(runtime.env.storagePath ?? runtime.env.config.storagePath ?? '').trim();
+    return value || '-';
+}
+function collectErrorCodes(value) {
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectErrorCodes(item));
+    }
+    const out = [];
+    const record = value;
+    if (typeof record.code === 'string') {
+        out.push(record.code);
+    }
+    for (const key of ['data', 'error', 'errors']) {
+        out.push(...collectErrorCodes(record[key]));
+    }
+    return out;
+}
+function isAuthFailureData(value) {
+    const codes = collectErrorCodes(value);
+    return codes.some((code) => ['EMPTY_TOKEN', 'INVALID_TOKEN', 'EXPIRED_TOKEN', 'BLOCKED_TOKEN', 'EXPIRED_SESSION', 'NOT_EXIST_USER'].includes(code));
+}
+function isNetworkFailure(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (error.name === 'AbortError'
+        || /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
+}
+function isUnconfiguredFailure(error) {
+    return error instanceof Error && /missing (a )?base url|missing base URL/i.test(error.message);
+}
+function isAuthFailure(error) {
+    return (error instanceof Error
+        && /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
+}
+export async function apiStatus(envName, config, options = {}) {
+    if (!resolveApiBaseUrl(config)) {
+        return 'unconfigured';
+    }
+    try {
+        const response = await executeRawApiRequest({
+            envName,
+            scope: options.scope,
+            method: 'GET',
+            path: '/auth:check',
+            timeoutMs: options.timeoutMs ?? 2000,
+        });
+        if (response.ok) {
+            return 'ok';
+        }
+        if (response.status === 401 || response.status === 403 || isAuthFailureData(response.data)) {
+            return 'auth failed';
+        }
+        return 'error';
+    }
+    catch (error) {
+        if (isUnconfiguredFailure(error)) {
+            return 'unconfigured';
+        }
+        if (isAuthFailure(error)) {
+            return 'auth failed';
+        }
+        if (isNetworkFailure(error)) {
+            return 'unreachable';
+        }
+        return 'error';
+    }
+}
+async function isLocalAppHealthy(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (!port) {
+        return false;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/api/__health_check`, {
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        return response.ok && text.trim().toLowerCase() === 'ok';
+    }
+    catch (_error) {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function dockerStatus(containerName) {
+    if (!(await dockerContainerExists(containerName))) {
+        return 'missing';
+    }
+    return await dockerContainerIsRunning(containerName) ? 'running' : 'stopped';
+}
+export async function dbStatus(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return runtime.kind === 'http' ? 'external' : '-';
+    }
+    if (runtime.kind === 'http') {
+        return 'external';
+    }
+    if (runtime.kind === 'ssh') {
+        return '-';
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.workspaceName);
+    return await dockerStatus(containerName);
+}
+export async function runtimeStatus(runtime) {
+    if (runtime.kind === 'http') {
+        return 'http';
+    }
+    if (runtime.kind === 'ssh') {
+        return 'ssh';
+    }
+    if (runtime.kind === 'docker') {
+        return await dockerStatus(runtime.containerName);
+    }
+    return await isLocalAppHealthy(runtime) ? 'running' : 'stopped';
+}

package/dist/commands/env/update.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { Args, Command, Flags } from '@oclif/core';
 import { getCurrentEnvName } from '../../lib/auth-store.js';
 import { updateEnvRuntime } from '../../lib/bootstrap.js';
-import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
 import { failTask, startTask, succeedTask } from '../../lib/ui.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export default class EnvUpdate extends Command {
@@ -31,12 +31,7 @@ export default class EnvUpdate extends Command {
             description: 'Show detailed progress output',
             default: false,
         }),
-        scope: Flags.string({
-            char: 's',
-            description: 'Config scope',
-            options: ['project', 'global'],
-        }),
-        'base-url': Flags.string({
+        'api-base-url': Flags.string({
             description: 'NocoBase API base URL override. When provided, persist it to the target env before saving the refreshed runtime.',
         }),
         role: Flags.string({
@@ -49,21 +44,20 @@ export default class EnvUpdate extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(EnvUpdate);
-        const scope = flags.scope;
         const envName = args.name;
-        const envLabel = envName ?? (await getCurrentEnvName({ scope }));
-        startTask(`Updating env runtime: ${envLabel}${scope ? ` (${formatCliHomeScope(scope)})` : ''}`);
+        const envLabel = envName ?? (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+        startTask(`Updating env runtime: ${envLabel}`);
         try {
             const runtime = await updateEnvRuntime({
                 envName,
-                scope,
-                baseUrl: flags['base-url'],
+                scope: resolveDefaultConfigScope(),
+                baseUrl: flags['api-base-url'],
                 role: flags.role,
                 token: flags.token,
                 configFile: path.join(path.dirname(path.dirname(path.dirname(__dirname))), 'nocobase-ctl.config.json'),
                 verbose: flags.verbose,
             });
-            succeedTask(`Updated env "${envLabel}" to runtime "${runtime.version}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            succeedTask(`Updated env "${envLabel}" to runtime "${runtime.version}".`);
         }
         catch (error) {
             failTask(`Failed to update env "${envLabel}".`);