@nocobase/cli 2.1.0-alpha.27 → 2.1.0-alpha.29

package/dist/commands/app/down.js

@@ -97,15 +97,21 @@ function builtinDbContainerName(runtime) {
 function managedDockerNetworkName(runtime) {
     return runtime.dockerNetworkName?.trim() || runtime.workspaceName?.trim() || undefined;
 }
-async function confirmDownAll(envName, yes) {
+async function confirmDownAll(envName, yes, options) {
     if (yes) {
         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} --yes to delete everything for that env in non-interactive mode.`);
+        }
         throw new Error(`\`nb app down --all\` needs confirmation. Re-run with --yes to delete everything for "${envName}" in non-interactive mode.`);
     }
     const answer = await p.confirm({
-        message: `Delete everything for "${envName}"? This removes the app, managed containers, storage data, and the saved CLI env config.`,
+        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.`,
         active: 'yes',
         inactive: 'no',
         initialValue: false,
@@ -152,6 +158,7 @@ export default class AppDown extends Command {
     async run() {
         const { flags } = await this.parse(AppDown);
         const requestedEnv = flags.env?.trim() || undefined;
+        const explicitEnv = Boolean(requestedEnv);
         const removeData = Boolean(flags.all);
         const removeEnvConfig = Boolean(flags.all);
         const runtime = await resolveManagedAppRuntime(requestedEnv);
@@ -175,7 +182,7 @@ export default class AppDown extends Command {
         if (flags.all) {
             let confirmed = false;
             try {
-                confirmed = await confirmDownAll(runtime.envName, flags.yes);
+                confirmed = await confirmDownAll(runtime.envName, flags.yes, { explicitEnv });
             }
             catch (error) {
                 this.error(error instanceof Error ? error.message : String(error));

package/dist/commands/app/logs.js

@@ -39,7 +39,7 @@ export default class AppLogs extends Command {
         follow: Flags.boolean({
             char: 'f',
             description: 'Keep streaming new log lines',
-            default: true,
+            default: false,
             allowNo: true,
         }),
     };
@@ -65,7 +65,7 @@ export default class AppLogs extends Command {
             ].join('\n'));
         }
         const tail = String(flags.tail ?? 100);
-        const follow = flags.follow !== false;
+        const follow = flags.follow === true;
         printInfo(follow
             ? `Showing logs for "${runtime.envName}" (press Ctrl+C to stop).`
             : `Showing recent logs for "${runtime.envName}".`);

package/dist/commands/app/start.js

@@ -10,7 +10,7 @@ import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, } from '../../lib/app-runtime.js';
 import { AppHealthCheckError, formatAppUrl, isAppReady, resolveManagedAppApiBaseUrl, waitForAppReady, } from '../../lib/app-health.js';
 import { ensureBuiltinDbReady, ensureSavedLocalSource, recreateSavedDockerApp, } from '../../lib/app-managed-resources.js';
-import { failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
 function argvHasToken(argv, tokens) {
     return tokens.some((token) => argv.includes(token));
 }
@@ -107,6 +107,7 @@ export default class AppStart extends Command {
                 'Use a local or Docker env if you need CLI-managed start and stop right now.',
             ].join('\n'));
         }
+        announceTargetEnv(runtime.envName);
         if (runtime.kind === 'docker') {
             const unsupportedFlags = [
                 flags.quickstart ? '--quickstart' : undefined,

package/dist/commands/app/stop.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, stopDockerContainer, } from '../../lib/app-runtime.js';
-import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, startTask, succeedTask } from '../../lib/ui.js';
 function formatStopFailure(envName, message) {
     if (/does not exist/i.test(message)) {
         return [
@@ -65,6 +65,7 @@ export default class AppStop extends Command {
                 'Use a local or Docker env if you need CLI-managed stop right now.',
             ].join('\n'));
         }
+        announceTargetEnv(runtime.envName);
         if (runtime.kind === 'docker') {
             startTask(`Stopping NocoBase for "${runtime.envName}"...`);
             try {

package/dist/commands/app/upgrade.js

@@ -10,8 +10,9 @@ import { Command, Flags } from '@oclif/core';
 import { upsertEnv } from '../../lib/auth-store.js';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, stopDockerContainer, } from '../../lib/app-runtime.js';
 import { resolveConfiguredEnvPath } from '../../lib/cli-home.js';
+import { deriveBuiltinDbConnection } from '../../lib/builtin-db.js';
 import { commandSucceeds, run } from '../../lib/run-npm.js';
-import { failTask, printInfo, startTask, stopTask, succeedTask, updateTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, printInfo, startTask, stopTask, succeedTask, updateTask } from '../../lib/ui.js';
 const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
 const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
 const APP_HEALTH_CHECK_INTERVAL_MS = 2_000;
@@ -312,9 +313,10 @@ export default class AppUpgrade extends Command {
         const storagePath = readEnvValue(runtime.env, 'storagePath');
         const appKey = readEnvValue(runtime.env, 'appKey');
         const timeZone = readEnvValue(runtime.env, 'timezone');
-        const dbDialect = readEnvValue(runtime.env, 'dbDialect');
-        const dbHost = readEnvValue(runtime.env, 'dbHost');
-        const dbPort = readEnvValue(runtime.env, 'dbPort');
+        const builtinDbConnection = runtime.env.config.builtinDb ? deriveBuiltinDbConnection(runtime) : undefined;
+        const dbDialect = builtinDbConnection?.dbDialect || readEnvValue(runtime.env, 'dbDialect');
+        const dbHost = builtinDbConnection?.dbHost || readEnvValue(runtime.env, 'dbHost');
+        const dbPort = builtinDbConnection?.dbPort || readEnvValue(runtime.env, 'dbPort');
         const dbDatabase = readEnvValue(runtime.env, 'dbDatabase');
         const dbUser = readEnvValue(runtime.env, 'dbUser');
         const dbPassword = readEnvValue(runtime.env, 'dbPassword');
@@ -561,6 +563,7 @@ export default class AppUpgrade extends Command {
                 'Use a local or Docker env if you need CLI-managed upgrades right now.',
             ].join('\n'));
         }
+        announceTargetEnv(runtime.envName);
         try {
             const resolvedVersion = AppUpgrade.resolveUpgradeVersion(runtime, parsed);
             const runCommand = this.config.runCommand.bind(this.config);

package/dist/commands/db/check.js

@@ -8,6 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { resolveBuiltinDbConnection } from '../../lib/builtin-db.js';
 import { checkExternalDbConnection, formatDbCheckAddress, readExternalDbConnectionConfig, } from "../../lib/db-connection-check.js";
 import { commandOutput } from '../../lib/run-npm.js';
 import { validateTcpPort } from "../../lib/prompt-validators.js";
@@ -95,7 +96,14 @@ async function resolveDbCheckInput(command, flags) {
     if (!runtime) {
         command.error(formatMissingManagedAppEnvMessage(envName));
     }
-    const dbConfig = resolveDbConfigFromFlags(flags, runtime.env.config);
+    const envConfig = { ...runtime.env.config };
+    if ((runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb) {
+        const builtinDbConnection = await resolveBuiltinDbConnection(runtime);
+        envConfig.dbHost = builtinDbConnection.dbHost;
+        envConfig.dbPort = builtinDbConnection.dbPort;
+        envConfig.dbDialect = builtinDbConnection.dbDialect;
+    }
+    const dbConfig = resolveDbConfigFromFlags(flags, envConfig);
     validateDbConfigOrThrow(command, dbConfig, true);
     return {
         envName: runtime.envName,

package/dist/commands/db/logs.js

@@ -47,7 +47,7 @@ export default class DbLogs extends Command {
         follow: Flags.boolean({
             char: 'f',
             description: 'Keep streaming new log lines',
-            default: true,
+            default: false,
             allowNo: true,
         }),
     };
@@ -62,7 +62,7 @@ export default class DbLogs extends Command {
             this.error(formatUnmanagedDbLogsMessage(runtime));
         }
         const tail = String(flags.tail ?? 100);
-        const follow = flags.follow !== false;
+        const follow = flags.follow === true;
         printInfo(follow
             ? `Showing built-in database logs for "${runtime.envName}" (press Ctrl+C to stop).`
             : `Showing recent built-in database logs for "${runtime.envName}".`);

package/dist/commands/db/shared.js

@@ -6,7 +6,8 @@
  * 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, resolveManagedAppRuntime, } from '../../lib/app-runtime.js';
+import { dockerContainerExists, dockerContainerIsRunning, resolveManagedAppRuntime, } from '../../lib/app-runtime.js';
+import { resolveBuiltinDbConnection } from '../../lib/builtin-db.js';
 function formatAddress(host, port, fallbackHost) {
     const normalizedHost = String(host ?? '').trim() || String(fallbackHost ?? '').trim();
     const normalizedPort = String(port ?? '').trim();
@@ -23,14 +24,14 @@ export async function resolveDbRuntime(envName) {
     const source = runtime.kind === 'http' || runtime.kind === 'ssh' ? runtime.kind : runtime.source;
     const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
     if ((runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb) {
-        const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
+        const connection = await resolveBuiltinDbConnection(runtime);
         return {
             kind: 'builtin',
             envName: runtime.envName,
             source,
-            dbDialect,
-            containerName,
-            address: formatAddress(runtime.env.config.dbHost, runtime.env.config.dbPort, containerName),
+            dbDialect: connection.dbDialect,
+            containerName: connection.containerName,
+            address: formatAddress(connection.dbHost, connection.dbPort, connection.containerName),
             appRuntime: runtime,
         };
     }

package/dist/commands/db/start.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, startDockerContainer, } from '../../lib/app-runtime.js';
-import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, startTask, succeedTask } from '../../lib/ui.js';
 import { formatUnmanagedDbMessage, resolveDbRuntime } from './shared.js';
 function formatDbStartFailure(envName, message) {
     if (/does not exist/i.test(message)) {
@@ -52,6 +52,7 @@ export default class DbStart extends Command {
         if (runtime.kind !== 'builtin') {
             this.error(formatUnmanagedDbMessage('start', runtime));
         }
+        announceTargetEnv(runtime.envName);
         startTask(`Starting the built-in database for "${runtime.envName}"...`);
         try {
             const state = await startDockerContainer(runtime.containerName, {

package/dist/commands/db/stop.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, stopDockerContainer, } from '../../lib/app-runtime.js';
-import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, startTask, succeedTask } from '../../lib/ui.js';
 import { formatUnmanagedDbMessage, resolveDbRuntime } from './shared.js';
 function formatDbStopFailure(envName, message) {
     if (/does not exist/i.test(message)) {
@@ -52,6 +52,7 @@ export default class DbStop extends Command {
         if (runtime.kind !== 'builtin') {
             this.error(formatUnmanagedDbMessage('stop', runtime));
         }
+        announceTargetEnv(runtime.envName);
         startTask(`Stopping the built-in database for "${runtime.envName}"...`);
         try {
             const state = await stopDockerContainer(runtime.containerName, {

package/dist/commands/env/info.js

@@ -8,6 +8,7 @@
  */
 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';
 function normalizeJsonValue(value) {
@@ -85,6 +86,9 @@ export default class EnvInfo extends Command {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
         }
         const auth = runtime.env.auth;
+        const builtinDbConnection = (runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb
+            ? await resolveBuiltinDbConnection(runtime)
+            : undefined;
         const appGroup = {
             appRootPath: appRootPath(runtime),
             storagePath: storagePath(runtime),
@@ -101,8 +105,8 @@ export default class EnvInfo extends Command {
             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,
+            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),

package/dist/commands/license/activate.js

@@ -10,7 +10,7 @@ import * as p from '@clack/prompts';
 import { Command, Flags } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { ensureInstanceId, licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, redactLicenseKey, requireLicenseRuntime, resolveLicenseKeyFile, resolveLicenseServiceUrl, saveLicenseKey, sanitizeLicenseOutput, validateLicenseKey, } from './shared.js';
-import { isInteractiveTerminal } from '../../lib/ui.js';
+import { announceTargetEnv, isInteractiveTerminal } from '../../lib/ui.js';
 import { appUrl } from '../env/shared.js';
 function resolveOnlineInputValue(value) {
     return String(value ?? '').trim();
@@ -210,6 +210,9 @@ export default class LicenseActivate extends Command {
     async run() {
         const { flags } = await this.parse(LicenseActivate);
         const runtime = await requireLicenseRuntime(flags.env);
+        if (!flags.json) {
+            announceTargetEnv(runtime.envName);
+        }
         let key = String(flags.key ?? '').trim();
         let keyFile = String(flags['key-file'] ?? '').trim();
         let online = Boolean(flags.online);

package/dist/commands/license/generate-id.js

@@ -21,6 +21,7 @@ function formatMissingFieldsMessage(missing) {
     ].join('\n');
 }
 export default class LicenseGenerateId extends Command {
+    static hidden = true;
     static summary = 'Generate a commercial license instance ID from explicit database settings';
     static description = 'Generate the commercial licensing instance ID from explicit `--db-*` flags. This command only prints the generated ID and does not save it.';
     static examples = [

package/dist/commands/license/id.js

@@ -8,6 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { generateAndSaveInstanceId, licenseEnvFlag, licenseJsonFlag, readSavedInstanceId, requireLicenseRuntime, resolveInstanceIdFile, } from './shared.js';
+import { announceTargetEnv } from '../../lib/ui.js';
 export default class LicenseId extends Command {
     static summary = 'Show the instance ID for the selected env';
     static description = 'Show the commercial licensing instance ID for the selected env, generating and saving it if needed.';
@@ -28,6 +29,9 @@ export default class LicenseId extends Command {
     async run() {
         const { flags } = await this.parse(LicenseId);
         const runtime = await requireLicenseRuntime(flags.env);
+        if (!flags.json) {
+            announceTargetEnv(runtime.envName);
+        }
         const savedBefore = await readSavedInstanceId(runtime);
         const shouldGenerate = Boolean(flags.force) || !savedBefore;
         const instanceId = shouldGenerate

package/dist/commands/license/plugins/clean.js

@@ -11,6 +11,7 @@ import pc from 'picocolors';
 import { licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, requireLicenseRuntime } from '../shared.js';
 import { cleanLicensedPlugins } from './shared.js';
 import { resolvePluginStoragePath } from '../../../lib/plugin-storage.js';
+import { announceTargetEnv } from '../../../lib/ui.js';
 function formatActionLabel(action) {
     switch (action) {
         case 'removed':
@@ -38,7 +39,6 @@ export default class LicensePluginsClean extends Command {
             default: false,
         }),
         verbose: Flags.boolean({
-            char: 'V',
             description: 'Show detailed per-plugin clean logs',
             default: false,
         }),
@@ -46,6 +46,9 @@ export default class LicensePluginsClean extends Command {
     async run() {
         const { flags } = await this.parse(LicensePluginsClean);
         const runtime = await requireLicenseRuntime(flags.env);
+        if (!flags.json) {
+            announceTargetEnv(runtime.envName);
+        }
         const shouldStreamLogs = !flags.json && Boolean(flags.verbose);
         const pluginStoragePath = resolvePluginStoragePath(runtime.env.storagePath);
         if (!flags.json) {

package/dist/commands/license/plugins/sync.js

@@ -14,11 +14,10 @@ import { licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, requireLicenseRunti
 import { syncLicensedPlugins } from './shared.js';
 import { resolvePluginStoragePath } from '../../../lib/plugin-storage.js';
 import { commandOutput } from '../../../lib/run-npm.js';
-import { startTask, stopTask, succeedTask, updateTask } from '../../../lib/ui.js';
+import { announceTargetEnv, startTask, stopTask, succeedTask, updateTask } from '../../../lib/ui.js';
 const SYNC_LOADING_DELAY_MS = 1200;
 const SYNC_LOADING_UPDATE_MS = 5000;
-const LOCAL_CLI_PACKAGE_JSON_PATH = 'node_modules/@nocobase/cli/package.json';
-const DOCKER_CLI_PACKAGE_JSON_PATH = '/opt/nb/node_modules/@nocobase/cli/package.json';
+const LOCAL_APP_PACKAGE_JSON_PATH = 'node_modules/@nocobase/app/package.json';
 const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
 const DEFAULT_DOCKER_VERSION = 'alpha';
 function formatActionLabel(action) {
@@ -78,13 +77,13 @@ async function parseVersionFromPackageJson(content, sourceLabel) {
     return version;
 }
 async function resolveLocalAppVersion(runtime) {
-    const packageJsonPath = path.join(runtime.projectRoot, LOCAL_CLI_PACKAGE_JSON_PATH);
+    const packageJsonPath = path.join(runtime.projectRoot, LOCAL_APP_PACKAGE_JSON_PATH);
     let content;
     try {
         content = await readFile(packageJsonPath, 'utf8');
     }
     catch {
-        throw new Error(`Missing ${LOCAL_CLI_PACKAGE_JSON_PATH} for env "${runtime.envName}" at ${packageJsonPath}.`);
+        throw new Error(`Missing ${LOCAL_APP_PACKAGE_JSON_PATH} for env "${runtime.envName}" at ${packageJsonPath}.`);
     }
     return await parseVersionFromPackageJson(content, packageJsonPath);
 }
@@ -101,7 +100,7 @@ async function resolveDockerAppVersion(runtime) {
     if (dockerPlatform) {
         args.push('--platform', dockerPlatform);
     }
-    args.push('--entrypoint', 'node', imageRef, '-p', `JSON.stringify(require(${JSON.stringify(DOCKER_CLI_PACKAGE_JSON_PATH)}).version)`);
+    args.push('--entrypoint', 'nb', imageRef, '--version');
     let output;
     try {
         output = await commandOutput('docker', args, {
@@ -110,11 +109,12 @@ async function resolveDockerAppVersion(runtime) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Missing ${DOCKER_CLI_PACKAGE_JSON_PATH} for env "${runtime.envName}" inside Docker image ${imageRef}. ${message}`);
+        throw new Error(`Failed to read app version for env "${runtime.envName}" from Docker image ${imageRef}. ${message}`);
     }
-    const version = trimValue(output.replace(/^"+|"+$/g, ''));
+    const versionMatch = output.match(/@nocobase\/cli\/([^\s]+)/);
+    const version = trimValue(versionMatch?.[1] ?? output.replace(/^"+|"+$/g, ''));
     if (!version) {
-        throw new Error(`Missing version in ${DOCKER_CLI_PACKAGE_JSON_PATH} for env "${runtime.envName}" inside Docker image ${imageRef}.`);
+        throw new Error(`Missing app version for env "${runtime.envName}" inside Docker image ${imageRef}.`);
     }
     return version;
 }
@@ -148,7 +148,6 @@ export default class LicensePluginsSync extends Command {
             description: 'Registry version or dist-tag to synchronize. Defaults to the current workspace version.',
         }),
         verbose: Flags.boolean({
-            char: 'V',
             description: 'Show detailed per-plugin sync logs',
             default: false,
         }),
@@ -156,6 +155,9 @@ export default class LicensePluginsSync extends Command {
     async run() {
         const { flags } = await this.parse(LicensePluginsSync);
         const runtime = await requireLicenseRuntime(flags.env);
+        if (!flags.json) {
+            announceTargetEnv(runtime.envName);
+        }
         const version = trimValue(flags.version) || await resolveManagedAppVersion(runtime);
         const registryVersion = normalizePluginRegistryVersion(version);
         const shouldStreamLogs = !flags.json && Boolean(flags.verbose);

package/dist/commands/license/shared.js

@@ -13,6 +13,7 @@ import { getEnvAsync, getInstanceIdAsync, keyDecrypt } from '@nocobase/license-k
 import _ from 'lodash';
 import { checkExternalDbConnection, readExternalDbConnectionConfig, } from "../../lib/db-connection-check.js";
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { buildRuntimeEnvVars } from '../../lib/runtime-env-vars.js';
 import { resolveLicensePkgUrlFromConfig } from '../../lib/cli-config.js';
 import { commandOutput } from '../../lib/run-npm.js';
 import { appUrl } from '../env/shared.js';
@@ -156,14 +157,15 @@ export async function withLicenseEnvVars(nextEnv, task) {
     }
 }
 async function withLicenseEnv(runtime, task) {
-    return await withLicenseEnvVars(runtime.env.envVars, task);
+    return await withLicenseEnvVars(await buildRuntimeEnvVars(runtime), task);
 }
 export async function getCurrentLicenseEnv(runtime) {
     if (runtime.kind === 'docker') {
+        const envVars = await buildRuntimeEnvVars(runtime);
         const payload = await runDockerLicenseJsonCommand(runtime, [
             'license',
             'env',
-            ...buildDockerLicenseDbFlagArgs(runtime.env.envVars),
+            ...buildDockerLicenseDbFlagArgs(envVars),
         ]);
         return payload?.env;
     }
@@ -181,10 +183,11 @@ export async function generateValidatedInstanceIdFromEnvVars(envVars) {
     return await generateInstanceIdFromEnvVars(envVars);
 }
 async function generateInstanceIdForDockerRuntime(runtime) {
+    const envVars = await buildRuntimeEnvVars(runtime);
     const payload = await runDockerLicenseJsonCommand(runtime, [
         'license',
         'generate-id',
-        ...buildDockerLicenseDbFlagArgs(runtime.env.envVars),
+        ...buildDockerLicenseDbFlagArgs(envVars),
     ]);
     const instanceId = trimValue(payload.instanceId);
     if (!instanceId) {
@@ -197,7 +200,7 @@ export async function generateInstanceIdForRuntime(runtime) {
         return await generateInstanceIdForDockerRuntime(runtime);
     }
     if (runtime.kind === 'local') {
-        return await generateValidatedInstanceIdFromEnvVars(runtime.env.envVars);
+        return await generateValidatedInstanceIdFromEnvVars(await buildRuntimeEnvVars(runtime));
     }
     throw new Error(`Env "${runtime.envName}" does not support automatic instance ID generation.`);
 }

package/dist/commands/plugin/disable.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { announceTargetEnv } from '../../lib/ui.js';
 export default class PluginDisable extends Command {
     static hidden = false;
     static args = {
@@ -39,6 +40,7 @@ export default class PluginDisable extends Command {
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(flags.env));
         }
+        announceTargetEnv(runtime.envName);
         if (runtime.kind === 'local') {
             try {
                 await runLocalNocoBaseCommand(runtime, ['pm', 'disable', ...packages]);

package/dist/commands/plugin/enable.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { announceTargetEnv } from '../../lib/ui.js';
 export default class PluginEnable extends Command {
     static hidden = false;
     static args = {
@@ -39,6 +40,7 @@ export default class PluginEnable extends Command {
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(flags.env));
         }
+        announceTargetEnv(runtime.envName);
         if (runtime.kind === 'local') {
             try {
                 await runLocalNocoBaseCommand(runtime, ['pm', 'enable', ...packages]);

package/dist/commands/source/dev.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
-import { printInfo } from '../../lib/ui.js';
+import { announceTargetEnv, printInfo } from '../../lib/ui.js';
 function formatUnsupportedRuntimeMessage(kind, envName) {
     if (kind === 'docker') {
         return [
@@ -110,6 +110,7 @@ export default class SourceDev extends Command {
         if (runtime.kind === 'docker' || runtime.kind === 'http' || runtime.kind === 'ssh') {
             this.error(formatUnsupportedRuntimeMessage(runtime.kind, runtime.envName));
         }
+        announceTargetEnv(runtime.envName);
         const devPort = flags.port
             || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
                 ? String(runtime.env.appPort).trim()

package/dist/lib/app-managed-resources.js

@@ -8,6 +8,7 @@
  */
 import { mkdir, readdir } from 'node:fs/promises';
 import { dockerContainerExists, startDockerContainer } from './app-runtime.js';
+import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
 import { resolveConfiguredEnvPath } from './cli-home.js';
 import { commandSucceeds, run } from './run-npm.js';
 import Install from '../commands/install.js';
@@ -92,9 +93,10 @@ export function buildSavedDockerRunArgs(runtime) {
         : trimValue(runtime.env.appPort);
     const appKey = trimValue(config.appKey);
     const timeZone = trimValue(config.timezone) || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-    const dbDialect = trimValue(config.dbDialect);
-    const dbHost = trimValue(config.dbHost);
-    const dbPort = trimValue(config.dbPort);
+    const builtinDbConnection = config.builtinDb ? deriveBuiltinDbConnection(runtime) : undefined;
+    const dbDialect = builtinDbConnection?.dbDialect || trimValue(config.dbDialect);
+    const dbHost = builtinDbConnection?.dbHost || trimValue(config.dbHost);
+    const dbPort = builtinDbConnection?.dbPort || trimValue(config.dbPort);
     const dbDatabase = trimValue(config.dbDatabase);
     const dbUser = trimValue(config.dbUser);
     const dbPassword = trimValue(config.dbPassword);
@@ -178,14 +180,16 @@ export async function ensureBuiltinDbReady(runtime, options) {
     if (!config.builtinDb) {
         return;
     }
+    const builtinDbConnection = await resolveBuiltinDbConnection(runtime);
     const plan = Install.buildBuiltinDbPlan({
         envName: runtime.envName,
         workspaceName: runtime.workspaceName,
+        dockerContainerPrefix: runtime.dockerContainerPrefix,
         storagePath: config.storagePath,
         source: runtime.source,
-        dbDialect: config.dbDialect,
-        dbHost: config.dbHost,
-        dbPort: config.dbPort,
+        dbDialect: builtinDbConnection.dbDialect,
+        dbHost: builtinDbConnection.dbHost,
+        dbPort: builtinDbConnection.dbPort,
         dbDatabase: config.dbDatabase,
         dbUser: config.dbUser,
         dbPassword: config.dbPassword,

package/dist/lib/app-runtime.js

@@ -11,6 +11,7 @@ import { resolveEnvKind } from './auth-store.js';
 import { getEnv, loadAuthConfig } from './auth-store.js';
 import { DEFAULT_DOCKER_CONTAINER_PREFIX, DEFAULT_DOCKER_NETWORK, getEffectiveCliConfigValue, } from './cli-config.js';
 import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
+import { buildRuntimeEnvVars } from './runtime-env-vars.js';
 const DOCKER_APP_WORKDIR = '/app/nocobase';
 function sanitizeDockerResourceName(value) {
     const normalized = value
@@ -115,9 +116,10 @@ export function formatMissingManagedAppEnvMessage(envName) {
     return 'No NocoBase env is configured yet. Run `nb init` to create one first.';
 }
 export async function runLocalNocoBaseCommand(runtime, args, options) {
+    const envVars = await buildRuntimeEnvVars(runtime);
     await runNocoBaseCommand(args, {
         cwd: runtime.projectRoot,
-        env: runtime.env.envVars,
+        env: envVars,
         stdio: options?.stdio,
     });
 }

package/dist/lib/auth-store.js

@@ -195,8 +195,13 @@ export class Env {
         put('APP_KEY', this.config.appKey);
         put('TZ', this.config.timezone);
         put('DB_DIALECT', this.config.dbDialect);
-        put('DB_HOST', this.config.dbHost);
-        put('DB_PORT', this.config.dbPort);
+        if (!this.config.builtinDb) {
+            put('DB_HOST', this.config.dbHost);
+            put('DB_PORT', this.config.dbPort);
+        }
+        else if (String(this.config.source ?? '').trim() !== 'docker') {
+            put('DB_PORT', this.config.dbPort);
+        }
         put('DB_DATABASE', this.config.dbDatabase);
         put('DB_USER', this.config.dbUser);
         put('DB_PASSWORD', this.config.dbPassword);

package/dist/lib/bootstrap.js

@@ -36,14 +36,10 @@ function hasBooleanFlag(argv, name) {
     const exact = `--${name}`;
     const negated = `--no-${name}`;
     const prefix = `--${name}=`;
-    const alias = name === 'verbose' ? '-V' : undefined;
     for (const value of argv) {
         if (value === exact) {
             return true;
         }
-        if (alias && value === alias) {
-            return true;
-        }
         if (value === negated) {
             return false;
         }

package/dist/lib/builtin-db.js

@@ -0,0 +1,86 @@
+/**
+ * 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 } from './app-runtime.js';
+import { commandOutput } from './run-npm.js';
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+export function defaultBuiltinDbPortForDialect(value) {
+    const dialect = trimValue(value) || 'postgres';
+    switch (dialect) {
+        case 'mysql':
+        case 'mariadb':
+            return '3306';
+        case 'kingbase':
+            return '54321';
+        case 'postgres':
+        default:
+            return '5432';
+    }
+}
+export function resolveBuiltinDbContainerName(runtime, dbDialect) {
+    const dialect = trimValue(dbDialect ?? runtime.env.config.dbDialect) || 'postgres';
+    return buildDockerDbContainerName(runtime.envName, dialect, runtime.dockerContainerPrefix || runtime.workspaceName);
+}
+export function deriveBuiltinDbConnection(runtime, overrides = {}) {
+    const dbDialect = trimValue(overrides.dbDialect ?? runtime.env.config.dbDialect) || 'postgres';
+    const containerName = resolveBuiltinDbContainerName(runtime, dbDialect);
+    const networkName = trimValue(runtime.dockerNetworkName || runtime.workspaceName) || undefined;
+    if (runtime.source === 'docker') {
+        return {
+            builtinDb: true,
+            dbDialect,
+            dbHost: containerName,
+            dbPort: defaultBuiltinDbPortForDialect(dbDialect),
+            containerName,
+            networkName,
+        };
+    }
+    const dbPort = trimValue(overrides.dbPort ?? runtime.env.config.dbPort) || defaultBuiltinDbPortForDialect(dbDialect);
+    return {
+        builtinDb: true,
+        dbDialect,
+        dbHost: '127.0.0.1',
+        dbPort,
+        containerName,
+        networkName,
+    };
+}
+export async function resolveBuiltinDbConnection(runtime) {
+    const derived = deriveBuiltinDbConnection(runtime);
+    if (runtime.source === 'docker') {
+        return derived;
+    }
+    const mappedPort = await inspectBuiltinDbPublishedPort(derived.containerName, derived.dbDialect);
+    if (mappedPort) {
+        return {
+            ...derived,
+            dbPort: mappedPort,
+        };
+    }
+    return derived;
+}
+async function inspectBuiltinDbPublishedPort(containerName, dbDialect) {
+    const containerPort = defaultBuiltinDbPortForDialect(dbDialect);
+    try {
+        const output = await commandOutput('docker', [
+            'inspect',
+            '--format',
+            `{{with index .NetworkSettings.Ports "${containerPort}/tcp"}}{{(index . 0).HostPort}}{{end}}`,
+            containerName,
+        ], {
+            errorName: 'docker inspect',
+        });
+        const hostPort = trimValue(output);
+        return hostPort || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/env-config.js

@@ -71,6 +71,13 @@ export function buildStoredEnvConfig(input) {
     if (input.builtinDb === false) {
         envConfig.builtinDbImage = undefined;
     }
+    if (input.builtinDb === true) {
+        delete envConfig.dbHost;
+        const source = trimConfigValue(input.source);
+        if (source === 'docker') {
+            delete envConfig.dbPort;
+        }
+    }
     const authType = trimConfigValue(input.authType);
     const accessToken = trimConfigValue(input.accessToken);
     if (authType === 'token' && accessToken) {

package/dist/lib/run-npm.js

@@ -15,6 +15,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import spawn from 'cross-spawn';
 const FORWARDED_SIGNALS = ['SIGINT', 'SIGTERM'];
@@ -178,6 +180,57 @@ export function commandOutput(name, args, options) {
         });
     });
 }
+async function readCommandOutputFile(filePath) {
+    try {
+        return await fsp.readFile(filePath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export async function commandOutputViaFile(name, args, options) {
+    const cwd = resolveCwd(options?.cwd);
+    const label = options?.errorName ?? name;
+    const command = resolveCommandName(name);
+    const captureDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-output-'));
+    const stdoutPath = path.join(captureDir, 'stdout.log');
+    const stderrPath = path.join(captureDir, 'stderr.log');
+    const stdoutHandle = await fsp.open(stdoutPath, 'w');
+    const stderrHandle = await fsp.open(stderrPath, 'w');
+    try {
+        const result = await new Promise((resolve, reject) => {
+            const child = spawn(command, [...args], {
+                cwd,
+                env: {
+                    ...process.env,
+                    ...options?.env,
+                },
+                stdio: ['ignore', stdoutHandle.fd, stderrHandle.fd],
+                windowsHide: process.platform === 'win32',
+            });
+            child.once('error', reject);
+            child.once('close', (code, signal) => {
+                resolve({ code, signal });
+            });
+        });
+        await stdoutHandle.close();
+        await stderrHandle.close();
+        const stdout = await readCommandOutputFile(stdoutPath);
+        const stderr = await readCommandOutputFile(stderrPath);
+        if (result.code === 0) {
+            return stdout.trim();
+        }
+        if (result.signal) {
+            throw new Error(`${label} exited due to signal ${result.signal}`);
+        }
+        const details = stderr.trim() || stdout.trim();
+        throw new Error(details ? `${label} exited with code ${result.code}: ${details}` : `${label} exited with code ${result.code}`);
+    }
+    finally {
+        await Promise.allSettled([stdoutHandle.close(), stderrHandle.close()]);
+        await fsp.rm(captureDir, { recursive: true, force: true });
+    }
+}
 /** Run `yarn` with the given argument list, inheriting stdio (errors label as `npm` for compatibility). */
 export function runNpm(args, options) {
     return run('yarn', [...args], { ...options, errorName: 'npm' });

package/dist/lib/runtime-env-vars.js

@@ -0,0 +1,32 @@
+/**
+ * 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 { resolveBuiltinDbConnection } from './builtin-db.js';
+function put(out, key, value) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    out[key] = String(value);
+}
+export async function buildRuntimeEnvVars(runtime) {
+    const config = runtime.env.config ?? {};
+    const out = {
+        ...runtime.env.envVars,
+    };
+    if (runtime.kind !== 'local' && runtime.kind !== 'docker') {
+        return out;
+    }
+    if (!config.builtinDb) {
+        return out;
+    }
+    const connection = await resolveBuiltinDbConnection(runtime);
+    put(out, 'DB_DIALECT', connection.dbDialect);
+    put(out, 'DB_HOST', connection.dbHost);
+    put(out, 'DB_PORT', connection.dbPort);
+    return out;
+}

package/dist/lib/skills-manager.js

@@ -10,7 +10,7 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { resolveCliHomeDir } from './cli-home.js';
 import { compareVersions } from './self-manager.js';
-import { commandOutput, run } from './run-npm.js';
+import { commandOutput, commandOutputViaFile, run } from './run-npm.js';
 export const NOCOBASE_SKILLS_SOURCE = 'nocobase/skills';
 export const NOCOBASE_SKILLS_PACKAGE_NAME = '@nocobase/skills';
 const NOCOBASE_SKILLS_NAME_PREFIX = 'nocobase-';
@@ -57,7 +57,7 @@ async function writeManagedSkillsState(workspaceRoot, state) {
 export async function listGlobalSkills(options = {}) {
     const globalRoot = resolveSkillsRoot(options);
     await ensureSkillsWorkspaceRoot(globalRoot);
-    const output = await (options.commandOutputFn ?? commandOutput)('npx', ['-y', 'skills', 'list', '-g', '--json'], {
+    const output = await (options.commandOutputFn ?? commandOutputViaFile)('npx', ['-y', 'skills', 'list', '-g', '--json'], {
         cwd: globalRoot,
         errorName: 'skills list',
     });

package/dist/lib/ui.js

@@ -88,6 +88,9 @@ export function printInfo(message) {
     }
     console.log(pc.cyan(message));
 }
+export function announceTargetEnv(envName) {
+    printInfo(`Target env: ${envName}`);
+}
 export function printVerbose(message) {
     if (!verboseMode) {
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.0-alpha.27",
+  "version": "2.1.0-alpha.29",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -103,5 +103,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "a340a88d86d3ff7e06d723215b02aa3c122f4870"
+  "gitHead": "526e36e399a570755286f9a0d34fa202b4a58a03"
 }