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

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
 

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`。
 
 ### 非交互式初始化
 

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/config/delete.js

@@ -11,9 +11,13 @@ import { assertSupportedCliConfigKey, deleteCliConfigValue } from '../../lib/cli
 export default class ConfigDelete extends Command {
     static summary = 'Delete an explicitly configured CLI setting';
     static examples = [
+        '<%= config.bin %> <%= command.id %> locale',
         '<%= config.bin %> <%= command.id %> license.pkg-url',
         '<%= config.bin %> <%= command.id %> docker.network',
         '<%= config.bin %> <%= command.id %> docker.container-prefix',
+        '<%= config.bin %> <%= command.id %> bin.docker',
+        '<%= config.bin %> <%= command.id %> bin.git',
+        '<%= config.bin %> <%= command.id %> bin.yarn',
     ];
     static args = {
         key: Args.string({

package/dist/commands/config/get.js

@@ -11,9 +11,13 @@ import { assertSupportedCliConfigKey, getCliConfigValue } from '../../lib/cli-co
 export default class ConfigGet extends Command {
     static summary = 'Get the effective CLI configuration value for a key';
     static examples = [
+        '<%= config.bin %> <%= command.id %> locale',
         '<%= config.bin %> <%= command.id %> license.pkg-url',
         '<%= config.bin %> <%= command.id %> docker.network',
         '<%= config.bin %> <%= command.id %> docker.container-prefix',
+        '<%= config.bin %> <%= command.id %> bin.docker',
+        '<%= config.bin %> <%= command.id %> bin.git',
+        '<%= config.bin %> <%= command.id %> bin.yarn',
     ];
     static args = {
         key: Args.string({

package/dist/commands/config/set.js

@@ -10,11 +10,15 @@ import { Args, Command } from '@oclif/core';
 import { assertSupportedCliConfigKey, setCliConfigValue } from '../../lib/cli-config.js';
 export default class ConfigSet extends Command {
     static summary = 'Set a CLI configuration value';
-    static description = 'Set a supported CLI configuration key. Supported keys: license.pkg-url, docker.network, docker.container-prefix.';
+    static description = 'Set a supported CLI configuration key. Supported keys: locale, license.pkg-url, docker.network, docker.container-prefix, bin.docker, bin.git, bin.yarn.';
     static examples = [
+        '<%= config.bin %> <%= command.id %> locale zh-CN',
         '<%= config.bin %> <%= command.id %> license.pkg-url https://pkg.nocobase.com/',
         '<%= config.bin %> <%= command.id %> docker.network nocobase',
         '<%= config.bin %> <%= command.id %> docker.container-prefix nb',
+        '<%= config.bin %> <%= command.id %> bin.docker /usr/local/bin/docker',
+        '<%= config.bin %> <%= command.id %> bin.git /usr/bin/git',
+        '<%= config.bin %> <%= command.id %> bin.yarn yarn',
     ];
     static args = {
         key: Args.string({

package/dist/commands/env/add.js

@@ -54,9 +54,25 @@ const envAddAccessTokenPrompt = {
     required: true,
     hidden: (values) => values.authType !== 'token' || values.skipAuth === true,
 };
+const envAddUsernamePrompt = {
+    type: 'text',
+    message: envAddText('prompts.username.message'),
+    placeholder: envAddText('prompts.username.placeholder'),
+    required: true,
+    hidden: (values) => values.authType !== 'basic' || values.skipAuth === true,
+};
+const envAddPasswordPrompt = {
+    type: 'password',
+    message: envAddText('prompts.password.message'),
+    required: true,
+    hidden: (values) => values.authType !== 'basic' || values.skipAuth === true,
+};
 function formatDeferredAuthMessage(envName, authType) {
     const normalizedAuthType = String(authType ?? '').trim();
     const nextStep = `Authentication was skipped for env "${envName}". Run \`nb env auth ${envName}\` to finish setup.`;
+    if (normalizedAuthType === 'basic') {
+        return `${nextStep} You will be prompted for a username and password.`;
+    }
     if (normalizedAuthType === 'token') {
         return `${nextStep} You will be prompted for an access token.`;
     }
@@ -66,7 +82,7 @@ function formatDeferredAuthMessage(envName, authType) {
     return nextStep;
 }
 export default class EnvAdd extends Command {
-    static summary = 'Save a named NocoBase API endpoint (token or OAuth), then switch the CLI to use it';
+    static summary = 'Save a named NocoBase API endpoint (basic, token, or OAuth), then switch the CLI to use it';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> local',
@@ -109,14 +125,20 @@ export default class EnvAdd extends Command {
         }),
         'auth-type': Flags.string({
             char: 'a',
-            description: 'Authentication: token (API key) or oauth (browser login via `nb env auth`); prompted in a TTY when omitted',
-            options: ['token', 'oauth'],
+            description: 'Authentication: basic (username/password login), token (API key), or oauth (browser login via `nb env auth`); prompted in a TTY when omitted',
+            options: ['basic', 'token', 'oauth'],
         }),
         'access-token': Flags.string({
             char: 't',
             aliases: ['token'],
             description: 'API key or access token when using --auth-type token (prompted in a TTY when omitted)',
         }),
+        username: Flags.string({
+            description: 'Username when using --auth-type basic (prompted in a TTY when omitted)',
+        }),
+        password: Flags.string({
+            description: 'Password when using --auth-type basic (prompted in a TTY when omitted)',
+        }),
         'skip-auth': Flags.boolean({
             description: 'Save the env now and finish authentication later with `nb env auth`',
             default: false,
@@ -261,6 +283,11 @@ export default class EnvAdd extends Command {
             type: 'select',
             message: envAddText('prompts.authType.message'),
             options: [
+                {
+                    value: 'basic',
+                    label: envAddText('prompts.authType.basicLabel'),
+                    hint: envAddText('prompts.authType.basicHint'),
+                },
                 {
                     value: 'oauth',
                     label: envAddText('prompts.authType.oauthLabel'),
@@ -271,6 +298,8 @@ export default class EnvAdd extends Command {
             initialValue: 'oauth',
             required: true,
         },
+        username: envAddUsernamePrompt,
+        password: envAddPasswordPrompt,
         accessToken: envAddAccessTokenPrompt,
     };
     buildPromptValues(nameArg, flags) {
@@ -293,6 +322,12 @@ export default class EnvAdd extends Command {
         if (typeof token === 'string' && token !== '') {
             values.accessToken = token;
         }
+        if (flags.username !== undefined) {
+            values.username = String(flags.username ?? '').trim();
+        }
+        if (flags.password !== undefined) {
+            values.password = String(flags.password ?? '');
+        }
         return values;
     }
     buildPromptInitialValues(flags) {
@@ -309,6 +344,14 @@ export default class EnvAdd extends Command {
         }
         return {
             ...EnvAdd.prompts,
+            username: {
+                ...envAddUsernamePrompt,
+                hidden: () => true,
+            },
+            password: {
+                ...envAddPasswordPrompt,
+                hidden: () => true,
+            },
             accessToken: {
                 ...envAddAccessTokenPrompt,
                 hidden: () => true,
@@ -316,9 +359,14 @@ export default class EnvAdd extends Command {
         };
     }
     buildEnvConfig(results, flags) {
+        const authType = String(results.authType ?? '').trim();
+        const authUsername = authType === 'basic'
+            ? String(results.username ?? flags.username ?? '').trim()
+            : '';
         const envConfigInput = {
             apiBaseUrl: results.apiBaseUrl,
-            authType: results.authType,
+            authType,
+            authUsername: authUsername || undefined,
             accessToken: results.accessToken,
         };
         for (const [flagName, configKey] of Object.entries(ENV_RUNTIME_FLAG_MAP)) {
@@ -357,8 +405,20 @@ export default class EnvAdd extends Command {
             printInfo(formatDeferredAuthMessage(envName, results.authType));
             return;
         }
-        if (results.authType === 'oauth') {
-            await this.config.runCommand('env:auth', [envName]);
+        if (results.authType === 'oauth' || results.authType === 'basic') {
+            const authArgv = [envName];
+            if (results.authType === 'basic') {
+                authArgv.push('--auth-type', 'basic');
+                const username = String(results.username ?? '').trim();
+                const password = String(results.password ?? '');
+                if (username) {
+                    authArgv.push('--username', username);
+                }
+                if (password) {
+                    authArgv.push('--password', password);
+                }
+            }
+            await this.config.runCommand('env:auth', authArgv);
         }
         await this.config.runCommand('env:update', [envName]);
         printSuccess(`✔ Env "${envName}" is ready.`);

package/dist/commands/env/auth.js

@@ -7,30 +7,30 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Args, Command, Flags } from '@oclif/core';
-import { getCurrentEnvName, getEnv, resolveConfiguredAuthType, updateEnvConnection, } from '../../lib/auth-store.js';
+import { getCurrentEnvName, getEnv, resolveConfiguredAuthType, updateEnvConnection } from '../../lib/auth-store.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
-import { authenticateEnvWithOauth } from '../../lib/env-auth.js';
+import { authenticateEnvWithBasic, authenticateEnvWithOauth } from '../../lib/env-auth.js';
 import { runPromptCatalog } from '../../lib/prompt-catalog.js';
-import { failTask, printStage, startTask, stopTask, succeedTask } from '../../lib/ui.js';
+import { failTask, isInteractiveTerminal, printStage, startTask, stopTask, succeedTask } from '../../lib/ui.js';
 import EnvAdd from "./add.js";
 const envAuthPrompts = {
     authType: EnvAdd.prompts.authType,
+    username: EnvAdd.prompts.username,
+    password: EnvAdd.prompts.password,
     accessToken: EnvAdd.prompts.accessToken,
 };
 function resolveExplicitAuthType(value) {
-    return value === 'token' || value === 'oauth' ? value : undefined;
+    return value === 'basic' || value === 'token' || value === 'oauth' ? value : undefined;
 }
 function formatMissingEnvMessage(envName) {
-    return [
-        `Env "${envName}" is not configured.`,
-        `Run \`nb env add ${envName} --api-base-url <url>\` first.`,
-    ].join('\n');
+    return [`Env "${envName}" is not configured.`, `Run \`nb env add ${envName} --api-base-url <url>\` first.`].join('\n');
 }
 export default class EnvAuth extends Command {
-    static summary = 'Authenticate a saved NocoBase environment with a token or OAuth';
+    static summary = 'Authenticate a saved NocoBase environment with basic login, a token, or OAuth';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> prod',
+        '<%= config.bin %> <%= command.id %> prod --auth-type basic --username admin --password secret',
         '<%= config.bin %> <%= command.id %> prod --auth-type token --access-token <api-key>',
     ];
     static args = {
@@ -48,13 +48,19 @@ export default class EnvAuth extends Command {
         }),
         'auth-type': Flags.string({
             char: 'a',
-            description: 'Authentication: token (API key) or oauth (browser login)',
-            options: ['token', 'oauth'],
+            description: 'Authentication: basic (username/password login), token (API key), or oauth (browser login)',
+            options: ['basic', 'token', 'oauth'],
         }),
         'access-token': Flags.string({
             char: 't',
             description: 'API key or access token when using token authentication',
         }),
+        username: Flags.string({
+            description: 'Username when using basic authentication (prompted in a TTY when omitted)',
+        }),
+        password: Flags.string({
+            description: 'Password when using basic authentication (prompted in a TTY when omitted)',
+        }),
     };
     async run() {
         const { args, flags } = await this.parse(EnvAuth);
@@ -63,9 +69,6 @@ export default class EnvAuth extends Command {
         if (nameArg && nameFlag && nameArg !== nameFlag) {
             this.error(`Environment name was provided both as the argument ("${nameArg}") and as --env ("${nameFlag}"). Please use only one.`);
         }
-        if (flags['auth-type'] === 'oauth' && flags['access-token'] !== undefined) {
-            this.error('--access-token cannot be used with --auth-type oauth.');
-        }
         const envName = nameArg || nameFlag || (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
         const env = await getEnv(envName, { scope: resolveDefaultConfigScope() });
         if (!env) {
@@ -73,32 +76,88 @@ export default class EnvAuth extends Command {
         }
         const tokenFromFlags = flags['access-token'];
         const tokenFlagProvided = tokenFromFlags !== undefined;
-        const tokenProvided = typeof tokenFromFlags === 'string' && tokenFromFlags !== '';
+        const tokenValue = typeof tokenFromFlags === 'string' ? tokenFromFlags.trim() : '';
+        const tokenProvided = tokenValue !== '';
         if (tokenFlagProvided && !tokenProvided) {
             this.error('--access-token cannot be empty.');
         }
+        const usernameFromFlags = flags.username;
+        const usernameFlagProvided = usernameFromFlags !== undefined;
+        const usernameProvided = typeof usernameFromFlags === 'string' && usernameFromFlags.trim() !== '';
+        if (usernameFlagProvided && !usernameProvided) {
+            this.error('--username cannot be empty.');
+        }
+        const passwordFromFlags = flags.password;
+        const passwordFlagProvided = passwordFromFlags !== undefined;
+        const passwordProvided = typeof passwordFromFlags === 'string' && passwordFromFlags.trim() !== '';
+        if (passwordFlagProvided && !passwordProvided) {
+            this.error('--password cannot be empty.');
+        }
         const explicitAuthType = resolveExplicitAuthType(flags['auth-type']);
+        if (tokenFlagProvided && (usernameFlagProvided || passwordFlagProvided)) {
+            this.error('--access-token cannot be used with --username or --password.');
+        }
+        if (explicitAuthType === 'oauth' && (tokenFlagProvided || usernameFlagProvided || passwordFlagProvided)) {
+            this.error('--auth-type oauth cannot be used with --access-token, --username, or --password.');
+        }
+        if (explicitAuthType === 'token' && (usernameFlagProvided || passwordFlagProvided)) {
+            this.error('--auth-type token cannot be used with --username or --password.');
+        }
+        if (explicitAuthType === 'basic' && tokenFlagProvided) {
+            this.error('--auth-type basic cannot be used with --access-token.');
+        }
         const savedAuthType = resolveConfiguredAuthType(env.config);
-        const resolvedAuthType = explicitAuthType ?? (tokenProvided ? 'token' : savedAuthType);
+        const resolvedAuthType = explicitAuthType ??
+            (tokenProvided ? 'token' : usernameFlagProvided || passwordFlagProvided ? 'basic' : savedAuthType);
+        if (resolvedAuthType === 'basic' && !usernameProvided && !isInteractiveTerminal()) {
+            this.error('--username is required when using basic authentication in non-interactive mode.');
+        }
+        if (resolvedAuthType === 'basic' && !passwordProvided && !isInteractiveTerminal()) {
+            this.error('--password is required when using basic authentication in non-interactive mode.');
+        }
         const prompted = (resolvedAuthType === 'oauth'
             ? { authType: 'oauth' }
-            : resolvedAuthType === 'token' && tokenProvided
-                ? { authType: 'token', accessToken: tokenFromFlags }
-                : await runPromptCatalog(envAuthPrompts, {
-                    values: {
-                        ...(resolvedAuthType ? { authType: resolvedAuthType } : {}),
-                    },
-                    command: this,
-                })) ?? {};
+            : await runPromptCatalog(envAuthPrompts, {
+                values: {
+                    ...(resolvedAuthType ? { authType: resolvedAuthType } : {}),
+                    ...(usernameFlagProvided ? { username: String(usernameFromFlags ?? '').trim() } : {}),
+                    ...(passwordFlagProvided ? { password: String(passwordFromFlags ?? '') } : {}),
+                    ...(tokenFlagProvided ? { accessToken: tokenValue } : {}),
+                },
+                command: this,
+            })) ?? {};
         const authType = resolveExplicitAuthType(prompted.authType ?? resolvedAuthType);
         if (!authType) {
             this.error('Choose an authentication type before continuing.');
         }
         printStage('Authenticating');
         try {
-            if (authType === 'token') {
-                const accessToken = String(prompted.accessToken ?? tokenFromFlags ?? '');
-                if (accessToken.trim() === '') {
+            if (authType === 'basic') {
+                const username = String(prompted.username ?? usernameFromFlags ?? '').trim();
+                const password = String(prompted.password ?? passwordFromFlags ?? '');
+                if (!username) {
+                    this.error('--username is required when using basic authentication.');
+                }
+                if (!password) {
+                    this.error('--password cannot be empty.');
+                }
+                startTask(`Signing in with username and password for "${envName}"...`);
+                const accessToken = await authenticateEnvWithBasic({
+                    envName,
+                    username,
+                    password,
+                    scope: resolveDefaultConfigScope(),
+                });
+                await updateEnvConnection(envName, {
+                    authType: 'basic',
+                    authUsername: username,
+                    accessToken,
+                }, { scope: resolveDefaultConfigScope() });
+                stopTask();
+            }
+            else if (authType === 'token') {
+                const accessToken = String(prompted.accessToken ?? tokenFromFlags ?? '').trim();
+                if (accessToken === '') {
                     this.error('--access-token cannot be empty.');
                 }
                 startTask(`Saving access token for "${envName}"...`);

package/dist/commands/env/info.js

@@ -10,7 +10,9 @@ import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
 import { resolveBuiltinDbConnection } from '../../lib/builtin-db.js';
 import { renderTable } from '../../lib/ui.js';
-import { appRootPath, dbStatus, runtimeStatus, storagePath } from './shared.js';
+import { appRootPath, appUrl, dbStatus, runtimeStatus, storagePath } from './shared.js';
+const MISSING_FIELD = Symbol('missingField');
+const FORBIDDEN_FIELD_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
 function normalizeJsonValue(value) {
     if (value === undefined || value === null || value === '') {
         return '-';
@@ -43,6 +45,26 @@ function createGroupTable(title, values) {
 function serializeGroup(values) {
     return Object.fromEntries(Object.entries(values).map(([field, value]) => [field, normalizeJsonValue(value)]));
 }
+function resolveFieldPath(value, path) {
+    const segments = path
+        .split('.')
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return MISSING_FIELD;
+    }
+    let current = value;
+    for (const segment of segments) {
+        if (!current ||
+            typeof current !== 'object' ||
+            FORBIDDEN_FIELD_PATH_SEGMENTS.has(segment) ||
+            !Object.prototype.hasOwnProperty.call(current, segment)) {
+            return MISSING_FIELD;
+        }
+        current = current[segment];
+    }
+    return current;
+}
 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.';
@@ -50,6 +72,7 @@ export default class EnvInfo extends Command {
         '<%= config.bin %> <%= command.id %> app1',
         '<%= config.bin %> <%= command.id %> app1 --json',
         '<%= config.bin %> <%= command.id %> app1 --show-secrets',
+        '<%= config.bin %> <%= command.id %> app1 --field app.url',
     ];
     static args = {
         name: Args.string({
@@ -68,6 +91,9 @@ export default class EnvInfo extends Command {
             description: 'Output the result as JSON',
             default: false,
         }),
+        field: Flags.string({
+            description: 'Return only a single field using dot notation, for example app.url or api.auth.type',
+        }),
         'show-secrets': Flags.boolean({
             description: 'Show secret values in plain text',
             default: false,
@@ -82,6 +108,7 @@ export default class EnvInfo extends Command {
         }
         const requestedEnv = envNameArg || envNameFlag;
         const showSecrets = flags['show-secrets'];
+        const fieldPath = flags.field?.trim() || undefined;
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -90,7 +117,9 @@ export default class EnvInfo extends Command {
         const builtinDbConnection = (runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb
             ? await resolveBuiltinDbConnection(runtime)
             : undefined;
+        const dbDialect = builtinDbConnection?.dbDialect ?? runtime.env.config.dbDialect;
         const appGroup = {
+            url: appUrl(runtime),
             appRootPath: appRootPath(runtime),
             storagePath: storagePath(runtime),
             appPort: runtime.env.config.appPort,
@@ -104,16 +133,21 @@ export default class EnvInfo extends Command {
         const dbGroup = {
             databaseStatus: await dbStatus(runtime),
             builtinDb: runtime.env.config.builtinDb,
-            dbDialect: runtime.env.config.dbDialect,
+            dbDialect,
             builtinDbImage: runtime.env.config.builtinDbImage,
             dbHost: builtinDbConnection?.dbHost ?? runtime.env.config.dbHost,
             dbPort: builtinDbConnection?.dbPort ?? runtime.env.config.dbPort,
             dbDatabase: runtime.env.config.dbDatabase,
             dbUser: runtime.env.config.dbUser,
             dbPassword: maskSecret(runtime.env.config.dbPassword, showSecrets),
+            dbTablePrefix: runtime.env.config.dbTablePrefix,
+            dbUnderscored: runtime.env.config.dbUnderscored,
+            ...(dbDialect === 'postgres' ? { dbSchema: runtime.env.config.dbSchema } : {}),
         };
         const authGroup = {
-            type: auth?.type,
+            type: runtime.env.authType ?? auth?.type,
+            sessionType: auth?.type,
+            username: runtime.env.config.authUsername,
             expiresAt: auth?.type === 'oauth' ? auth.expiresAt : undefined,
             scope: auth?.type === 'oauth' ? auth.scope : undefined,
             issuer: auth?.type === 'oauth' ? auth.issuer : undefined,
@@ -125,6 +159,8 @@ export default class EnvInfo extends Command {
         const apiGroup = {
             apiBaseUrl: runtime.env.apiBaseUrl,
             'auth.type': authGroup.type,
+            'auth.sessionType': authGroup.sessionType,
+            'auth.username': authGroup.username,
             'auth.expiresAt': authGroup.expiresAt,
             'auth.scope': authGroup.scope,
             'auth.issuer': authGroup.issuer,
@@ -144,14 +180,22 @@ export default class EnvInfo extends Command {
                 auth: serializeGroup(authGroup),
             },
         };
+        if (fieldPath) {
+            const selected = resolveFieldPath(output, fieldPath);
+            if (selected === MISSING_FIELD) {
+                this.error(`Unknown field "${fieldPath}". Use dot notation like app.url, db.databaseStatus, or api.auth.type.`);
+            }
+            if (flags.json) {
+                this.log(JSON.stringify(selected, null, 2));
+                return;
+            }
+            this.log(typeof selected === 'object' ? JSON.stringify(selected, null, 2) : String(selected));
+            return;
+        }
         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'));
+        this.log([createGroupTable('App', appGroup), createGroupTable('DB', dbGroup), createGroupTable('API', apiGroup)].join('\n\n'));
     }
 }

package/dist/commands/env/list.js

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command } from '@oclif/core';
-import { getCurrentEnvName, listEnvs } from '../../lib/auth-store.js';
+import { getCurrentEnvName, listEnvs, resolveConfiguredAuthType } from '../../lib/auth-store.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
 import { renderTable } from '../../lib/ui.js';
 import { resolveApiBaseUrl } from './shared.js';
@@ -35,7 +35,7 @@ export default class EnvList extends Command {
                 name,
                 env.kind ?? '-',
                 resolveApiBaseUrl(env),
-                env.auth?.type ?? '',
+                resolveConfiguredAuthType(env) ?? env.auth?.type ?? '',
                 env.runtime?.version ?? '',
             ]);
         }

package/dist/commands/env/shared.js

@@ -11,13 +11,51 @@ import { executeRawApiRequest } from '../../lib/api-client.js';
 export function resolveApiBaseUrl(config) {
     return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
 }
+function buildAppPath(publicPath, subapp) {
+    const normalizedPublicPath = publicPath.replace(/\/+$/, '');
+    if (!subapp) {
+        return normalizedPublicPath ? `${normalizedPublicPath}/` : '/';
+    }
+    const normalizedSubapp = subapp.replace(/^\/+|\/+$/g, '');
+    return `${normalizedPublicPath ? normalizedPublicPath : ''}/apps/${normalizedSubapp}/`;
+}
+export function resolveAppUrlFromApiBaseUrl(apiBaseUrl) {
+    const value = String(apiBaseUrl ?? '').trim();
+    if (!value) {
+        return '';
+    }
+    try {
+        const url = new URL(value);
+        const subappMatch = url.pathname.match(/^(.*)\/api\/__app\/([^/]+)\/?$/);
+        if (subappMatch) {
+            url.pathname = buildAppPath(subappMatch[1] ?? '', subappMatch[2]);
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        }
+        const appMatch = url.pathname.match(/^(.*)\/api\/?$/);
+        if (appMatch) {
+            url.pathname = buildAppPath(appMatch[1] ?? '');
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        }
+    }
+    catch {
+        return value;
+    }
+    return value;
+}
 export function appUrl(runtime) {
+    const resolvedFromApiBaseUrl = resolveAppUrlFromApiBaseUrl(runtime.env.apiBaseUrl ?? resolveApiBaseUrl(runtime.env.config));
+    if (resolvedFromApiBaseUrl) {
+        return resolvedFromApiBaseUrl;
+    }
     const port = String(runtime.env.config.appPort ?? '').trim();
     if (port) {
-        return `http://127.0.0.1:${port}`;
+        return `http://127.0.0.1:${port}/`;
     }
-    const baseUrl = resolveApiBaseUrl(runtime.env.config);
-    return baseUrl.replace(/\/api\/?$/, '');
+    return '';
 }
 export function appRootPath(runtime) {
     if (runtime.kind === 'http' || runtime.kind === 'docker') {