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

package/dist/commands/v1.js

@@ -0,0 +1,210 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Command } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../lib/env-guard.js';
+import { announceTargetEnv } from '../lib/ui.js';
+const SILENT_LIKE_PASSTHROUGH_FLAGS = new Set(['--help', '-h', '--silent']);
+const SILENT_RUNTIME_ENV_VARS = {
+    LOGGER_SILENT: 'true',
+    NODE_NO_WARNINGS: '1',
+};
+const SILENT_STDERR_FILTERS = [
+    /^\(node:\d+\) \[DEP0040\] DeprecationWarning: The `punycode` module is deprecated\..*$/,
+    /^\(Use `node --trace-deprecation .*$/,
+    /^About to overwrite ArrayBuffer\.prototype properties /,
+];
+function parseBridgeArgv(argv) {
+    let requestedEnv;
+    let yes = false;
+    const passthroughArgs = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--') {
+            passthroughArgs.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token === '--env') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `--env`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--env=')) {
+            requestedEnv = token.slice('--env='.length).trim() || undefined;
+            continue;
+        }
+        if (token === '-e') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `-e`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-e') && token.length > 2) {
+            requestedEnv = token.slice(2).trim() || undefined;
+            continue;
+        }
+        if (token === '--yes') {
+            yes = true;
+            continue;
+        }
+        passthroughArgs.push(...argv.slice(index));
+        break;
+    }
+    return {
+        requestedEnv,
+        yes,
+        passthroughArgs,
+    };
+}
+function formatHttpEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'This env only has an API connection, so the v1 bridge is not available here.',
+        'Use a local or Docker env instead.',
+    ].join('\n');
+}
+function formatSshEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'SSH env support is reserved but not implemented yet.',
+        'Use a local or Docker env right now.',
+    ].join('\n');
+}
+function hasSilentLikePassthrough(args) {
+    return args.some((arg) => SILENT_LIKE_PASSTHROUGH_FLAGS.has(arg));
+}
+function shouldFilterSilentStderrLine(line) {
+    const normalized = line.replace(/\r$/, '');
+    return SILENT_STDERR_FILTERS.some((pattern) => pattern.test(normalized));
+}
+function createSilentBridgeOptions() {
+    let pendingStderr = '';
+    const flushBufferedStderr = (force) => {
+        while (true) {
+            const newlineIndex = pendingStderr.indexOf('\n');
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = pendingStderr.slice(0, newlineIndex);
+            pendingStderr = pendingStderr.slice(newlineIndex + 1);
+            if (!shouldFilterSilentStderrLine(line)) {
+                process.stderr.write(`${line}\n`);
+            }
+        }
+        if (force && pendingStderr) {
+            if (!shouldFilterSilentStderrLine(pendingStderr)) {
+                process.stderr.write(pendingStderr);
+            }
+            pendingStderr = '';
+        }
+    };
+    return {
+        commandOptions: {
+            stdio: 'pipe',
+            env: {
+                ...SILENT_RUNTIME_ENV_VARS,
+            },
+            onStdout: (chunk) => {
+                process.stdout.write(chunk);
+            },
+            onStderr: (chunk) => {
+                pendingStderr += chunk;
+                flushBufferedStderr(false);
+            },
+        },
+        flush: () => {
+            flushBufferedStderr(true);
+        },
+    };
+}
+export default class V1 extends Command {
+    static hidden = true;
+    static strict = false;
+    static summary = 'Forward commands to the selected env through the v1 bridge';
+    static description = 'Forward v1-compatible commands to the selected env. Defaults to the current env when `--env` is omitted. Local envs run `nocobase-v1`, and Docker envs run inside the saved app container. Bridge flags (`--env`, `--yes`) must appear before the forwarded command. Use `--` when the forwarded command needs the same flag names.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> build',
+        '<%= config.bin %> <%= command.id %> --env local pm list',
+        '<%= config.bin %> <%= command.id %> --env docker-local -- pm enable @nocobase/plugin-sample --yes',
+    ];
+    async run() {
+        const originalArgv = [...this.argv];
+        await this.parse({ strict: false, flags: {}, args: {} }, []);
+        this.argv = originalArgv;
+        let parsed;
+        try {
+            parsed = parseBridgeArgv(this.argv);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+        const { requestedEnv, yes, passthroughArgs } = parsed;
+        if (passthroughArgs.length === 0) {
+            this.error('Pass at least one v1 command to forward.');
+        }
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const silentLike = hasSilentLikePassthrough(passthroughArgs);
+        const silentBridge = silentLike ? createSilentBridgeOptions() : undefined;
+        if (!silentLike) {
+            announceTargetEnv(runtime.envName);
+        }
+        if (runtime.kind === 'local') {
+            try {
+                await runLocalNocoBaseCommand(runtime, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'docker') {
+            try {
+                await runDockerNocoBaseCommand(runtime.containerName, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'http') {
+            this.error(formatHttpEnvError(runtime.envName));
+        }
+        this.error(formatSshEnvError(runtime.envName));
+    }
+}

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

@@ -32,6 +32,18 @@ function localSourceLabel(source) {
 function trimValue(value) {
     return String(value ?? '').trim();
 }
+function pushOptionalEnvArg(args, key, value) {
+    if (typeof value === 'string') {
+        if (!value) {
+            return;
+        }
+        args.push('-e', `${key}=${value}`);
+        return;
+    }
+    if (typeof value === 'boolean') {
+        args.push('-e', `${key}=${String(value)}`);
+    }
+}
 function normalizeDockerPlatform(value) {
     const text = trimValue(value);
     if (!text || text === 'auto') {
@@ -109,6 +121,9 @@ export async function buildSavedDockerRunArgs(runtime) {
     const dbDatabase = trimValue(config.dbDatabase);
     const dbUser = trimValue(config.dbUser);
     const dbPassword = trimValue(config.dbPassword);
+    const dbSchema = trimValue(config.dbSchema);
+    const dbTablePrefix = trimValue(config.dbTablePrefix);
+    const dbUnderscored = typeof config.dbUnderscored === 'boolean' ? config.dbUnderscored : undefined;
     const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
     const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
     const imageRef = resolveDockerImageRef(dockerRegistry, version, {
@@ -163,7 +178,11 @@ export async function buildSavedDockerRunArgs(runtime) {
     if (envFile) {
         args.push('--env-file', envFile);
     }
-    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`, imageRef);
+    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`);
+    pushOptionalEnvArg(args, 'DB_SCHEMA', dbSchema || undefined);
+    pushOptionalEnvArg(args, 'DB_TABLE_PREFIX', dbTablePrefix || undefined);
+    pushOptionalEnvArg(args, 'DB_UNDERSCORED', dbUnderscored);
+    args.push(imageRef);
     return {
         appPort: appPort || undefined,
         storagePath,

package/dist/lib/app-runtime.js

@@ -119,8 +119,13 @@ export async function runLocalNocoBaseCommand(runtime, args, options) {
     const envVars = await buildRuntimeEnvVars(runtime);
     await runNocoBaseCommand(args, {
         cwd: runtime.projectRoot,
-        env: envVars,
+        env: {
+            ...envVars,
+            ...options?.env,
+        },
         stdio: options?.stdio,
+        onStdout: options?.onStdout,
+        onStderr: options?.onStderr,
     });
 }
 export async function dockerContainerExists(containerName) {
@@ -163,9 +168,13 @@ export async function stopDockerContainer(containerName, options) {
     });
     return 'stopped';
 }
-export async function runDockerNocoBaseCommand(containerName, args) {
-    await startDockerContainer(containerName);
-    await run('docker', ['exec', '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
+export async function runDockerNocoBaseCommand(containerName, args, options) {
+    await startDockerContainer(containerName, { stdio: options?.stdio });
+    const dockerEnvArgs = Object.entries(options?.env ?? {}).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
+    await run('docker', ['exec', ...dockerEnvArgs, '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
         errorName: 'docker exec',
+        stdio: options?.stdio,
+        onStdout: options?.onStdout,
+        onStderr: options?.onStderr,
     });
 }

package/dist/lib/auth-store.js

@@ -159,6 +159,9 @@ export class Env {
     get auth() {
         return this.config.auth;
     }
+    get authType() {
+        return resolveConfiguredAuthType(this.config);
+    }
     get runtime() {
         return this.config.runtime;
     }
@@ -210,6 +213,9 @@ export class Env {
         put('DB_DATABASE', this.config.dbDatabase);
         put('DB_USER', this.config.dbUser);
         put('DB_PASSWORD', this.config.dbPassword);
+        put('DB_SCHEMA', this.config.dbSchema);
+        put('DB_TABLE_PREFIX', this.config.dbTablePrefix);
+        put('DB_UNDERSCORED', this.config.dbUnderscored);
         return out;
     }
 }
@@ -253,27 +259,38 @@ async function writeEnv(envName, updater, options = {}) {
     config.envs[envName] = updater(previous);
     await saveAuthConfig(config, options);
 }
+function normalizeConfiguredAuthType(value) {
+    return value === 'token' || value === 'oauth' ? value : undefined;
+}
+export function resolveConfiguredAuthType(config) {
+    return normalizeConfiguredAuthType(config?.authType) ?? normalizeConfiguredAuthType(config?.auth?.type);
+}
 export async function upsertEnv(envName, config, options = {}) {
     await writeEnv(envName, (previous) => {
-        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, ...rest } = config;
+        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, ...rest } = config;
         const nextApiBaseUrl = readEnvApiBaseUrl(config);
         const previousApiBaseUrl = readEnvApiBaseUrl(previous);
         const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
+        const previousAuthType = resolveConfiguredAuthType(previous);
+        const requestedAuthType = normalizeConfiguredAuthType(authType);
+        const nextAuthType = requestedAuthType ?? (accessToken ? 'token' : previousAuthType);
         const nextAuth = accessToken
             ? {
                 type: 'token',
                 accessToken,
             }
-            : baseUrlChanged || previous?.auth?.type === 'token'
+            : nextAuthType === 'token' || baseUrlChanged || previous?.auth?.type === 'token'
                 ? undefined
                 : previous?.auth;
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        const authTypeChanged = previousAuthType !== nextAuthType;
         return {
             ...previous,
             apiBaseUrl: nextApiBaseUrl,
+            authType: nextAuthType,
             auth: nextAuth,
             ...rest,
-            runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
+            runtime: baseUrlChanged || authChanged || authTypeChanged ? undefined : previous?.runtime,
         };
     }, options);
 }
@@ -282,26 +299,32 @@ export async function updateEnvConnection(envName, updates, options = {}) {
         const nextApiBaseUrl = readEnvApiBaseUrl(updates) ?? readEnvApiBaseUrl(previous);
         const previousApiBaseUrl = readEnvApiBaseUrl(previous);
         const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
+        const previousAuthType = resolveConfiguredAuthType(previous);
+        const requestedAuthType = normalizeConfiguredAuthType(updates.authType);
+        const nextAuthType = requestedAuthType ?? (updates.accessToken ? 'token' : previousAuthType);
         const nextAuth = updates.accessToken
             ? {
                 type: 'token',
                 accessToken: updates.accessToken,
             }
-            : baseUrlChanged || previous?.auth?.type === 'token'
+            : nextAuthType === 'token' || baseUrlChanged || previous?.auth?.type === 'token'
                 ? undefined
                 : previous?.auth;
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        const authTypeChanged = previousAuthType !== nextAuthType;
         return {
             ...previous,
             ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
+            authType: nextAuthType,
             auth: nextAuth,
-            runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
+            runtime: baseUrlChanged || authChanged || authTypeChanged ? undefined : previous?.runtime,
         };
     }, options);
 }
 export async function setEnvOauthSession(envName, auth, options = {}) {
     await writeEnv(envName, (previous) => ({
         ...previous,
+        authType: 'oauth',
         auth,
         runtime: options.preserveRuntime ? previous?.runtime : undefined,
     }), options);

package/dist/lib/backup.js

@@ -0,0 +1,171 @@
+/**
+ * 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 { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getCurrentEnvName, getEnv, listEnvs } from './auth-store.js';
+import { updateEnvRuntime } from './bootstrap.js';
+import { resolveDefaultConfigScope } from './cli-home.js';
+import { commandOutput } from './run-npm.js';
+import { loadRuntimeSync } from './runtime-store.js';
+import { failTask, startTask, succeedTask } from './ui.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const CLI_CONFIG_FILE = path.join(CLI_PACKAGE_ROOT, 'nocobase-ctl.config.json');
+const CLI_ENTRY_FILE = path.join(CLI_PACKAGE_ROOT, 'bin', 'run.js');
+export const BACKUP_POLL_INTERVAL_MS = 2_000;
+export const BACKUP_CREATE_TIMEOUT_MS = 600_000;
+export const BACKUP_RUNTIME_COMMANDS = {
+    create: 'backup create',
+    status: 'backup status',
+    download: 'backup download',
+    restoreUpload: 'backup restore-upload',
+};
+function hasRequiredBackupCommands(runtime, commandIds) {
+    if (!runtime) {
+        return false;
+    }
+    const available = new Set(runtime.commands.map((command) => command.commandId));
+    return commandIds.every((commandId) => available.has(commandId));
+}
+function formatMissingBackupRuntimeCommands(envName, commandIds) {
+    const missing = commandIds.map((commandId) => `nb api ${commandId}`).join(', ');
+    return [
+        `The selected env "${envName}" does not expose the backup API commands required by \`nb backup\`.`,
+        `Missing commands: ${missing}`,
+        'Enable or upgrade the backup/restore capability for that env, then try again.',
+    ].join('\n');
+}
+export function buildBackupEnvArgv(options) {
+    const argv = [];
+    if (options.explicitEnvSelection && options.requestedEnv) {
+        argv.push('--env', options.requestedEnv);
+    }
+    if (options.yes || options.explicitEnvSelection) {
+        argv.push('--yes');
+    }
+    return argv;
+}
+export async function resolveBackupTargetEnv(requestedEnv) {
+    const scope = resolveDefaultConfigScope();
+    const envName = requestedEnv?.trim() || (await getCurrentEnvName({ scope }));
+    const env = await getEnv(envName, { scope });
+    if (env) {
+        return { scope, envName, env };
+    }
+    const { envs } = await listEnvs({ scope });
+    const configuredEnvNames = Object.keys(envs);
+    if (!configuredEnvNames.length) {
+        throw new Error('No env is configured. Run `nb env add <name> --api-base-url <url>` first.');
+    }
+    if (requestedEnv?.trim()) {
+        throw new Error(`Env "${envName}" is not configured. Run \`nb env add ${envName} --api-base-url <url>\` first.`);
+    }
+    throw new Error([
+        `Current env "${envName}" is not configured.`,
+        'Switch to an existing env with `nb env use <name>`, or add one with `nb env add <name> --api-base-url <url>`.',
+    ].join('\n'));
+}
+export async function ensureBackupRuntimeCommands(params) {
+    const scope = resolveDefaultConfigScope();
+    const env = params.env ?? (await getEnv(params.envName, { scope }));
+    const currentRuntime = loadRuntimeSync(env?.runtime?.version, { scope });
+    if (hasRequiredBackupCommands(currentRuntime, params.commandIds)) {
+        return;
+    }
+    if (!params.quiet) {
+        startTask(`Refreshing env runtime for "${params.envName}" to load backup commands...`);
+    }
+    try {
+        const runtime = await updateEnvRuntime({
+            envName: params.envName,
+            scope,
+            configFile: CLI_CONFIG_FILE,
+            quiet: params.quiet,
+        });
+        if (!hasRequiredBackupCommands(runtime, params.commandIds)) {
+            throw new Error(formatMissingBackupRuntimeCommands(params.envName, params.commandIds));
+        }
+        if (!params.quiet) {
+            succeedTask(`Env runtime is ready for backup commands in "${params.envName}".`);
+        }
+    }
+    catch (error) {
+        if (!params.quiet) {
+            failTask(`Failed to refresh backup commands for "${params.envName}".`);
+        }
+        throw error;
+    }
+}
+export async function runBackupCliCommand(argv, options) {
+    return await commandOutput(process.execPath, [CLI_ENTRY_FILE, ...argv], {
+        errorName: options?.errorName ?? `nb ${argv.join(' ')}`,
+        env: {
+            NB_SKIP_STARTUP_UPDATE: '1',
+            // When the parent CLI already runs in tsx source mode, it sets
+            // `_NOCO_CLI_TSX_CHILD=1`. Clear it here so `bin/run.js` can re-exec
+            // itself with `--import tsx` again instead of trying to import `.ts`
+            // sources without the loader.
+            _NOCO_CLI_TSX_CHILD: '',
+        },
+    });
+}
+export async function runBackupCliJsonCommand(argv, options) {
+    const output = await runBackupCliCommand([...argv, '--json-output'], options);
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        throw new Error(`Unexpected JSON output from ${options?.errorName ?? `nb ${argv.join(' ')}`}: ${output || '(empty output)'}`);
+    }
+}
+export async function resolveBackupCreateOutputPath(output, remoteName) {
+    const requestedOutput = String(output ?? '').trim();
+    if (!requestedOutput) {
+        return path.resolve(process.cwd(), remoteName);
+    }
+    const resolvedOutput = path.resolve(process.cwd(), requestedOutput);
+    try {
+        const stats = await fs.stat(resolvedOutput);
+        if (stats.isDirectory()) {
+            return path.join(resolvedOutput, remoteName);
+        }
+    }
+    catch {
+        // Treat non-existing paths as an explicit target file path.
+    }
+    return resolvedOutput;
+}
+export async function resolveBackupRestoreFilePath(file) {
+    const resolvedFile = path.resolve(process.cwd(), file);
+    let stats;
+    try {
+        stats = await fs.stat(resolvedFile);
+    }
+    catch {
+        throw new Error(`Backup file not found: ${resolvedFile}`);
+    }
+    if (!stats.isFile()) {
+        throw new Error(`Backup restore input must be a file: ${resolvedFile}`);
+    }
+    return resolvedFile;
+}
+export function resolveBackupWaitApiBaseUrl(env) {
+    const baseUrl = String(env.baseUrl ?? '').trim();
+    if (baseUrl) {
+        return baseUrl.replace(/\/+$/, '');
+    }
+    const appPort = env.appPort === undefined || env.appPort === null
+        ? ''
+        : String(env.appPort).trim();
+    return appPort ? `http://127.0.0.1:${appPort}/api` : undefined;
+}
+export async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/bootstrap.js

@@ -137,7 +137,7 @@ function getSwaggerUrl(baseUrl) {
 function getHealthCheckUrl(baseUrl) {
     return `${baseUrl.replace(/\/+$/, '')}/__health_check`;
 }
-async function waitForServiceReady(baseUrl, token, role) {
+async function waitForServiceReady(baseUrl, token, role, options) {
     const healthCheckUrl = getHealthCheckUrl(baseUrl);
     const startedAt = Date.now();
     let notified = false;
@@ -162,18 +162,22 @@ async function waitForServiceReady(baseUrl, token, role) {
             return;
         }
         if (!notified) {
-            printVerbose(`Waiting for health check: ${healthCheckUrl}`);
-            updateTask(`Waiting for application readiness (${healthCheckUrl})`);
+            if (!options?.quiet) {
+                printVerbose(`Waiting for health check: ${healthCheckUrl}`);
+                updateTask(`Waiting for application readiness (${healthCheckUrl})`);
+            }
             notified = true;
         }
         await sleep(APP_RETRY_INTERVAL);
     }
     throw new Error(`The application did not become ready in time. Expected \`${healthCheckUrl}\` to respond with \`ok\`.`);
 }
-async function waitForSwaggerSchema(baseUrl, token, role) {
+async function waitForSwaggerSchema(baseUrl, token, role, options) {
     const swaggerUrl = getSwaggerUrl(baseUrl);
     const startedAt = Date.now();
-    printVerbose(`Checking swagger schema: ${swaggerUrl}`);
+    if (!options?.quiet) {
+        printVerbose(`Checking swagger schema: ${swaggerUrl}`);
+    }
     while (Date.now() - startedAt < APP_RETRY_TIMEOUT) {
         const response = await requestJson(swaggerUrl, { token, role });
         if (response.ok) {
@@ -182,7 +186,7 @@ async function waitForSwaggerSchema(baseUrl, token, role) {
         if (!shouldRetryAppAvailability(response)) {
             return response;
         }
-        await waitForServiceReady(baseUrl, token, role);
+        await waitForServiceReady(baseUrl, token, role, options);
     }
     return await requestJson(swaggerUrl, { token, role });
 }
@@ -200,9 +204,9 @@ async function confirmEnableApiDoc() {
 async function fetchSwaggerSchema(baseUrl, token, role, context = {}, options = {}) {
     let response = options.retryAppAvailability === false
         ? await requestJson(getSwaggerUrl(baseUrl), { token, role })
-        : await waitForSwaggerSchema(baseUrl, token, role);
+        : await waitForSwaggerSchema(baseUrl, token, role, { quiet: options.quiet });
     if (response.status === 404) {
-        if (options.allowEnableApiDoc === false) {
+        if (options.allowEnableApiDoc === false || options.quiet) {
             throw new Error('`swagger:get` returned 404. Check the base URL and enable the `API documentation plugin` if needed.');
         }
         printInfo('The API documentation plugin is not enabled.');
@@ -257,7 +261,7 @@ export function formatSwaggerSchemaError(response, context) {
             `Authentication failed while loading the command runtime from \`swagger:get\`${envLabel}.`,
             `Base URL: ${context.baseUrl}`,
             details,
-            'Update the API key with `nb env add <name> --api-base-url <url> --auth-type token --token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--token <api-key>`.',
+            'Update the API key with `nb env add <name> --api-base-url <url> --auth-type token --access-token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--access-token <api-key>`.',
             commandHint,
         ].join('\n');
     }
@@ -368,10 +372,14 @@ export async function updateEnvRuntime(options) {
             .filter(Boolean)
             .join('\n'));
     }
-    updateTask('Loading command runtime...');
+    if (!options.quiet) {
+        updateTask('Loading command runtime...');
+    }
     try {
-        printVerbose(`Runtime source: ${baseUrl}`);
-        const document = await fetchSwaggerSchema(baseUrl, token, options.role, { envName });
+        if (!options.quiet) {
+            printVerbose(`Runtime source: ${baseUrl}`);
+        }
+        const document = await fetchSwaggerSchema(baseUrl, token, options.role, { envName }, { quiet: options.quiet });
         const runtime = await generateRuntime(document, options.configFile, baseUrl);
         await saveRuntime(runtime, { scope: options.scope });
         if (options.baseUrl !== undefined || options.token !== undefined) {
@@ -388,6 +396,8 @@ export async function updateEnvRuntime(options) {
         return runtime;
     }
     finally {
-        stopTask();
+        if (!options.quiet) {
+            stopTask();
+        }
     }
 }

package/dist/lib/env-config.js

@@ -26,6 +26,8 @@ const STRING_ENV_CONFIG_KEYS = [
     'dbDatabase',
     'dbUser',
     'dbPassword',
+    'dbSchema',
+    'dbTablePrefix',
     'rootUsername',
     'rootEmail',
     'rootPassword',
@@ -36,6 +38,7 @@ const BOOLEAN_ENV_CONFIG_KEYS = [
     'devDependencies',
     'build',
     'buildDts',
+    'dbUnderscored',
 ];
 function trimConfigValue(value) {
     const text = String(value ?? '').trim();
@@ -80,6 +83,9 @@ export function buildStoredEnvConfig(input) {
         }
     }
     const authType = trimConfigValue(input.authType);
+    if (authType === 'token' || authType === 'oauth') {
+        envConfig.authType = authType;
+    }
     const accessToken = trimConfigValue(input.accessToken);
     if (authType === 'token' && accessToken) {
         envConfig.accessToken = accessToken;