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

package/dist/lib/auth-store.js

@@ -8,7 +8,8 @@
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath, } from './cli-home.js';
+import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
+import { normalizeCliLocale } from './cli-locale.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
@@ -24,13 +25,20 @@ function normalizeOptionalString(value) {
     const normalized = String(value ?? '').trim();
     return normalized || undefined;
 }
+function normalizeOptionalCliLocale(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return normalizeCliLocale(normalized);
+}
 export function readEnvApiBaseUrl(config) {
     if (!config) {
         return undefined;
     }
-    return (normalizeOptionalString(config.apiBaseUrl)
-        ?? normalizeOptionalString(config.baseUrl)
-        ?? normalizeOptionalString(config.apibaseUrl));
+    return (normalizeOptionalString(config.apiBaseUrl) ??
+        normalizeOptionalString(config.baseUrl) ??
+        normalizeOptionalString(config.apibaseUrl));
 }
 export function resolveEnvKind(config) {
     if (!config) {
@@ -70,9 +78,11 @@ function normalizeEnvConfigEntry(entry) {
 }
 function normalizeAuthConfig(config) {
     const settings = config.settings ?? {};
+    const locale = normalizeOptionalCliLocale(settings.locale);
     return {
         name: config.name || config.dockerResourcePrefix,
         settings: {
+            ...(locale ? { locale } : {}),
             ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
             ...(settings.docker?.network || settings.docker?.containerPrefix
                 ? {
@@ -84,8 +94,19 @@ function normalizeAuthConfig(config) {
                     },
                 }
                 : {}),
+            ...(settings.bin?.docker || settings.bin?.git || settings.bin?.yarn
+                ? {
+                    bin: {
+                        ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
+                        ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
+                        ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
+                    },
+                }
+                : {}),
         },
-        lastEnv: config.lastEnv || config.currentEnv || 'default',
+        lastEnv: config.lastEnv ||
+            config.currentEnv ||
+            'default',
         envs: Object.fromEntries(Object.entries(config.envs || {}).map(([envName, entry]) => [envName, normalizeEnvConfigEntry(entry) ?? {}])),
     };
 }
@@ -222,10 +243,11 @@ export class Env {
 export async function getEnv(envName, options = {}) {
     const { config: snapshot, ...loadOptions } = options;
     const config = snapshot ?? (await loadAuthConfig(loadOptions));
-    const resolved = envName?.trim() || (await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
-        scope: loadOptions.scope,
-        lastEnv: config.lastEnv,
-    }));
+    const resolved = envName?.trim() ||
+        (await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
+            scope: loadOptions.scope,
+            lastEnv: config.lastEnv,
+        }));
     const envConfig = config.envs[resolved];
     if (!envConfig) {
         return undefined;
@@ -260,37 +282,40 @@ async function writeEnv(envName, updater, options = {}) {
     await saveAuthConfig(config, options);
 }
 function normalizeConfiguredAuthType(value) {
-    return value === 'token' || value === 'oauth' ? value : undefined;
+    return value === 'basic' || 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, authType, ...rest } = config;
+        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, ...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 nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) ?? previous?.authUsername : undefined;
         const nextAuth = accessToken
             ? {
                 type: 'token',
                 accessToken,
             }
-            : nextAuthType === 'token' || baseUrlChanged || previous?.auth?.type === 'token'
-                ? undefined
-                : previous?.auth;
+            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
+                ? previous.auth
+                : undefined;
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
         const authTypeChanged = previousAuthType !== nextAuthType;
+        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
         return {
             ...previous,
             apiBaseUrl: nextApiBaseUrl,
             authType: nextAuthType,
+            authUsername: nextAuthUsername,
             auth: nextAuth,
             ...rest,
-            runtime: baseUrlChanged || authChanged || authTypeChanged ? undefined : previous?.runtime,
+            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
         };
     }, options);
 }
@@ -302,22 +327,25 @@ export async function updateEnvConnection(envName, updates, options = {}) {
         const previousAuthType = resolveConfiguredAuthType(previous);
         const requestedAuthType = normalizeConfiguredAuthType(updates.authType);
         const nextAuthType = requestedAuthType ?? (updates.accessToken ? 'token' : previousAuthType);
+        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(updates.authUsername) ?? previous?.authUsername : undefined;
         const nextAuth = updates.accessToken
             ? {
                 type: 'token',
                 accessToken: updates.accessToken,
             }
-            : nextAuthType === 'token' || baseUrlChanged || previous?.auth?.type === 'token'
-                ? undefined
-                : previous?.auth;
+            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
+                ? previous.auth
+                : undefined;
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
         const authTypeChanged = previousAuthType !== nextAuthType;
+        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
         return {
             ...previous,
             ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
             authType: nextAuthType,
+            authUsername: nextAuthUsername,
             auth: nextAuth,
-            runtime: baseUrlChanged || authChanged || authTypeChanged ? undefined : previous?.runtime,
+            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
         };
     }, options);
 }

package/dist/lib/cli-config.js

@@ -8,13 +8,21 @@
  */
 import { loadExactAuthConfig, saveAuthConfig } from './auth-store.js';
 import { resolveDefaultConfigScope } from './cli-home.js';
+import { CLI_LOCALE_FLAG_OPTIONS, normalizeCliLocale, resolveCliLocale } from './cli-locale.js';
 export const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
 export const DEFAULT_DOCKER_NETWORK = 'nocobase';
 export const DEFAULT_DOCKER_CONTAINER_PREFIX = 'nb';
+export const DEFAULT_DOCKER_BIN = 'docker';
+export const DEFAULT_GIT_BIN = 'git';
+export const DEFAULT_YARN_BIN = 'yarn';
 export const SUPPORTED_CLI_CONFIG_KEYS = [
+    'locale',
     'license.pkg-url',
     'docker.network',
     'docker.container-prefix',
+    'bin.docker',
+    'bin.git',
+    'bin.yarn',
 ];
 function trimValue(value) {
     const text = String(value ?? '').trim();
@@ -36,11 +44,16 @@ export function assertSupportedCliConfigKey(value) {
 }
 function cloneSettings(config) {
     return {
+        ...(config.settings?.locale ? { locale: trimValue(config.settings.locale) } : {}),
         license: config.settings?.license ? { ...config.settings.license } : undefined,
         docker: config.settings?.docker ? { ...config.settings.docker } : undefined,
+        bin: config.settings?.bin ? { ...config.settings.bin } : undefined,
     };
 }
 function pruneSettings(config) {
+    if (config.settings && !trimValue(config.settings.locale)) {
+        delete config.settings.locale;
+    }
     const license = config.settings?.license;
     if (license && !trimValue(license.pkgUrl)) {
         delete config.settings?.license;
@@ -49,34 +62,56 @@ function pruneSettings(config) {
     if (docker && !trimValue(docker.network) && !trimValue(docker.containerPrefix)) {
         delete config.settings?.docker;
     }
-    if (config.settings
-        && !config.settings.license
-        && !config.settings.docker) {
+    const bin = config.settings?.bin;
+    if (bin && !trimValue(bin.docker) && !trimValue(bin.git) && !trimValue(bin.yarn)) {
+        delete config.settings?.bin;
+    }
+    if (config.settings &&
+        !config.settings.locale &&
+        !config.settings.license &&
+        !config.settings.docker &&
+        !config.settings.bin) {
         delete config.settings;
     }
 }
 export function getExplicitCliConfigValue(config, key) {
     switch (key) {
+        case 'locale':
+            return trimValue(config.settings?.locale);
         case 'license.pkg-url':
             return trimValue(config.settings?.license?.pkgUrl);
         case 'docker.network':
             return trimValue(config.settings?.docker?.network);
         case 'docker.container-prefix':
             return trimValue(config.settings?.docker?.containerPrefix);
+        case 'bin.docker':
+            return trimValue(config.settings?.bin?.docker);
+        case 'bin.git':
+            return trimValue(config.settings?.bin?.git);
+        case 'bin.yarn':
+            return trimValue(config.settings?.bin?.yarn);
     }
 }
 export function getEffectiveCliConfigValue(config, key) {
     const explicit = getExplicitCliConfigValue(config, key);
-    if (explicit) {
+    if (explicit && key !== 'locale') {
         return explicit;
     }
     switch (key) {
+        case 'locale':
+            return resolveCliLocale(undefined, { configuredLocale: trimValue(config.settings?.locale) });
         case 'license.pkg-url':
             return DEFAULT_LICENSE_PKG_URL;
         case 'docker.network':
             return trimValue(config.name) || DEFAULT_DOCKER_NETWORK;
         case 'docker.container-prefix':
             return trimValue(config.name) || DEFAULT_DOCKER_CONTAINER_PREFIX;
+        case 'bin.docker':
+            return DEFAULT_DOCKER_BIN;
+        case 'bin.git':
+            return DEFAULT_GIT_BIN;
+        case 'bin.yarn':
+            return DEFAULT_YARN_BIN;
     }
 }
 export function normalizeCliConfigValue(key, value) {
@@ -87,6 +122,13 @@ export function normalizeCliConfigValue(key, value) {
     if (key === 'license.pkg-url') {
         return normalized.replace(/\/+$/, '') + '/';
     }
+    if (key === 'locale') {
+        const locale = normalizeCliLocale(normalized);
+        if (!locale) {
+            throw new Error(`Config key "${key}" must be one of: ${CLI_LOCALE_FLAG_OPTIONS.join(', ')}`);
+        }
+        return locale;
+    }
     return normalized;
 }
 export async function loadCliConfig(options = {}) {
@@ -113,6 +155,9 @@ export async function setCliConfigValue(key, value, options = {}) {
     const normalized = normalizeCliConfigValue(key, value);
     config.settings = cloneSettings(config);
     switch (key) {
+        case 'locale':
+            config.settings.locale = normalized;
+            break;
         case 'license.pkg-url':
             config.settings.license = {
                 ...(config.settings.license ?? {}),
@@ -131,6 +176,24 @@ export async function setCliConfigValue(key, value, options = {}) {
                 containerPrefix: normalized,
             };
             break;
+        case 'bin.docker':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                docker: normalized,
+            };
+            break;
+        case 'bin.git':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                git: normalized,
+            };
+            break;
+        case 'bin.yarn':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                yarn: normalized,
+            };
+            break;
     }
     pruneSettings(config);
     await saveAuthConfig(config, scope);
@@ -145,6 +208,9 @@ export async function deleteCliConfigValue(key, options = {}) {
     }
     config.settings = cloneSettings(config);
     switch (key) {
+        case 'locale':
+            delete config.settings.locale;
+            break;
         case 'license.pkg-url':
             if (config.settings.license) {
                 delete config.settings.license.pkgUrl;
@@ -160,6 +226,21 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.docker.containerPrefix;
             }
             break;
+        case 'bin.docker':
+            if (config.settings.bin) {
+                delete config.settings.bin.docker;
+            }
+            break;
+        case 'bin.git':
+            if (config.settings.bin) {
+                delete config.settings.bin.git;
+            }
+            break;
+        case 'bin.yarn':
+            if (config.settings.bin) {
+                delete config.settings.bin.yarn;
+            }
+            break;
     }
     pruneSettings(config);
     await saveAuthConfig(config, scope);
@@ -174,3 +255,17 @@ export async function resolveDockerContainerPrefix(options = {}) {
 export async function resolveLicensePkgUrlFromConfig(options = {}) {
     return await getCliConfigValue('license.pkg-url', options);
 }
+const CONFIGURABLE_COMMAND_KEYS = {
+    docker: 'bin.docker',
+    git: 'bin.git',
+    yarn: 'bin.yarn',
+};
+export function isConfigurableCommandName(value) {
+    return Object.prototype.hasOwnProperty.call(CONFIGURABLE_COMMAND_KEYS, value);
+}
+export async function resolveConfiguredCommandName(commandName, options = {}) {
+    if (!isConfigurableCommandName(commandName)) {
+        return commandName;
+    }
+    return await getCliConfigValue(CONFIGURABLE_COMMAND_KEYS[commandName], options);
+}

package/dist/lib/cli-locale.js

@@ -9,12 +9,13 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { resolveCliHomeDir } from './cli-home.js';
 export const SUPPORTED_CLI_LOCALES = ['en-US', 'zh-CN'];
 export const CLI_LOCALE_FLAG_OPTIONS = [...SUPPORTED_CLI_LOCALES];
 export const CLI_LOCALE_FLAG_DESCRIPTION = 'Language for CLI prompts and the local setup UI.';
 const DEFAULT_CLI_LOCALE = 'en-US';
 const localeCache = {};
-function normalizeCliLocale(value) {
+export function normalizeCliLocale(value) {
     const raw = String(value ?? '').trim();
     if (!raw) {
         return undefined;
@@ -28,6 +29,17 @@ function normalizeCliLocale(value) {
     }
     return undefined;
 }
+function readConfiguredCliLocale() {
+    try {
+        const configPath = path.join(resolveCliHomeDir(), 'config.json');
+        const content = readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(content);
+        return normalizeCliLocale(parsed.settings?.locale === undefined ? undefined : String(parsed.settings.locale));
+    }
+    catch {
+        return undefined;
+    }
+}
 function loadLocaleMessages(locale) {
     if (localeCache[locale]) {
         return localeCache[locale];
@@ -65,9 +77,11 @@ function interpolateTemplate(template, values) {
         return value === undefined || value === null ? '' : String(value);
     });
 }
-export function detectCliLocale() {
+export function detectCliLocale(configuredLocale) {
+    const resolvedConfiguredLocale = configuredLocale ?? readConfiguredCliLocale();
     const candidates = [
         process.env.NB_LOCALE,
+        resolvedConfiguredLocale,
         process.env.LC_ALL,
         process.env.LC_MESSAGES,
         process.env.LANG,
@@ -81,8 +95,8 @@ export function detectCliLocale() {
     }
     return DEFAULT_CLI_LOCALE;
 }
-export function resolveCliLocale(preferred) {
-    return normalizeCliLocale(preferred) ?? detectCliLocale();
+export function resolveCliLocale(preferred, options) {
+    return normalizeCliLocale(preferred) ?? detectCliLocale(options?.configuredLocale);
 }
 export function applyCliLocale(preferred) {
     const locale = resolveCliLocale(preferred);
@@ -111,9 +125,7 @@ export function localeText(key, values, fallback) {
     };
 }
 export function isLocalizedTextDef(value) {
-    return Boolean(value
-        && typeof value === 'object'
-        && typeof value.key === 'string');
+    return Boolean(value && typeof value === 'object' && typeof value.key === 'string');
 }
 export function resolveLocalizedText(text, options) {
     if (text === undefined) {

package/dist/lib/db-connection-check.js

@@ -10,6 +10,7 @@ import { translateCli } from "./cli-locale.js";
 import { validateTcpPort } from "./prompt-validators.js";
 const DB_CONNECTION_TIMEOUT_MS = 5_000;
 const externalDbValidationCache = new Map();
+const mysqlLowerCaseTableNamesCache = new Map();
 function trimPromptValue(value) {
     return String(value ?? '').trim();
 }
@@ -117,6 +118,36 @@ async function checkMysqlFamilyConnection(config) {
         await Promise.resolve(connection.end()).catch(() => undefined);
     }
 }
+async function readMysqlFamilyLowerCaseTableNames(config) {
+    const { default: mysql } = await import('mysql2/promise');
+    const connection = await mysql.createConnection({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectTimeout: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        const [rows] = await connection.query(`SHOW VARIABLES LIKE 'lower_case_table_names'`);
+        if (!Array.isArray(rows)) {
+            return undefined;
+        }
+        for (const row of rows) {
+            if (!row || typeof row !== 'object') {
+                continue;
+            }
+            const value = String(row.Value ?? '').trim();
+            if (value === '0' || value === '1' || value === '2') {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    finally {
+        await Promise.resolve(connection.end()).catch(() => undefined);
+    }
+}
 async function performExternalDbConnectionCheck(config) {
     try {
         switch (config.dialect) {
@@ -146,6 +177,19 @@ export async function checkExternalDbConnection(config) {
     externalDbValidationCache.set(cacheKey, pending);
     return await pending;
 }
+async function readMysqlLowerCaseTableNamesMode(config) {
+    if (config.dialect !== 'mysql' && config.dialect !== 'mariadb') {
+        return undefined;
+    }
+    const cacheKey = buildValidationCacheKey(config);
+    const cached = mysqlLowerCaseTableNamesCache.get(cacheKey);
+    if (cached) {
+        return await cached;
+    }
+    const pending = readMysqlFamilyLowerCaseTableNames(config);
+    mysqlLowerCaseTableNamesCache.set(cacheKey, pending);
+    return await pending;
+}
 export async function validateExternalDbConfig(values) {
     const config = readExternalDbConnectionConfig(values);
     if (!config) {
@@ -153,6 +197,23 @@ export async function validateExternalDbConfig(values) {
     }
     return await checkExternalDbConnection(config);
 }
+export async function validateMysqlLowerCaseTableNamesCompatibility(values) {
+    const config = readExternalDbConnectionConfig(values);
+    if (!config || (config.dialect !== 'mysql' && config.dialect !== 'mariadb')) {
+        return undefined;
+    }
+    try {
+        const mode = await readMysqlLowerCaseTableNamesMode(config);
+        if (mode === '1' && values.dbUnderscored !== true) {
+            return translateCli('validators.dbConnection.lowerCaseTableNamesRequiresUnderscored');
+        }
+        return undefined;
+    }
+    catch (error) {
+        return formatDbConnectionError(config, error);
+    }
+}
 export function clearExternalDbValidationCache() {
     externalDbValidationCache.clear();
+    mysqlLowerCaseTableNamesCache.clear();
 }

package/dist/lib/env-auth.js

@@ -34,6 +34,28 @@ export function getOauthResource(issuerOrBaseUrl) {
 export function getDefaultOauthScope() {
     return DEFAULT_OAUTH_SCOPE;
 }
+function formatApiAuthError(prefix, data, fallbackStatus) {
+    if (typeof data === 'string' && data.trim()) {
+        return `${prefix}: ${data}`;
+    }
+    const errors = Array.isArray(data?.errors) ? data.errors : [];
+    if (errors.length > 0) {
+        const details = errors
+            .map((entry) => {
+            const code = entry?.code ? `[${entry.code}] ` : '';
+            return `${code}${entry?.message ?? 'Authentication failed.'}`;
+        })
+            .join('; ');
+        return `${prefix}: ${details}`;
+    }
+    if (typeof data?.error?.message === 'string' && data.error.message.trim()) {
+        return `${prefix}: ${data.error.message}`;
+    }
+    if (typeof fallbackStatus === 'number') {
+        return `${prefix}: HTTP ${fallbackStatus}`;
+    }
+    return prefix;
+}
 export function isOauthAccessTokenExpired(auth, now = Date.now()) {
     if (!auth.expiresAt) {
         return false;
@@ -775,6 +797,63 @@ export async function resolveServerRequestTarget(options) {
     }
     return { baseUrl, token };
 }
+export async function authenticateEnvWithBasic(options) {
+    const envName = options.envName ?? (await getCurrentEnvName({ scope: options.scope }));
+    const env = await getEnv(envName, { scope: options.scope });
+    const baseUrl = env?.baseUrl;
+    if (!baseUrl) {
+        throw new Error([
+            env
+                ? `Environment "${envName}" does not have an API base URL yet.`
+                : `Environment "${envName}" has not been set up yet.`,
+            env
+                ? `Run \`nb env add ${envName} --api-base-url <url>\` to finish setting it up.`
+                : `Run \`nb env add ${envName}\` first.`,
+        ]
+            .filter(Boolean)
+            .join('\n'));
+    }
+    const loginUrl = `${normalizeBaseUrl(baseUrl)}/auth:signIn`;
+    let response;
+    try {
+        response = await fetchWithOauthRetry(loginUrl, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                'x-authenticator': 'basic',
+            },
+            body: JSON.stringify({
+                account: options.username,
+                password: options.password,
+            }),
+        }, {
+            operation: 'Signing in with basic credentials',
+            onRetry: (message) => updateTask(message),
+        });
+    }
+    catch (error) {
+        throw new Error(formatOauthFetchFailure('Failed to sign in with basic credentials.', {
+            envName,
+            baseUrl,
+            url: loginUrl,
+            rawMessage: error?.message,
+        }));
+    }
+    const data = await parseJsonResponse(response);
+    if (!response.ok) {
+        throw new Error(formatApiAuthError('Basic sign-in failed', data, response.status));
+    }
+    const token = typeof data?.data?.token === 'string' && data.data.token.trim()
+        ? data.data.token.trim()
+        : typeof data?.token === 'string' && data.token.trim()
+            ? data.token.trim()
+            : '';
+    if (!token) {
+        throw new Error('Basic sign-in succeeded but no token was returned.');
+    }
+    return token;
+}
 export async function authenticateEnvWithOauth(options) {
     const envName = options.envName ?? (await getCurrentEnvName({ scope: options.scope }));
     const env = await getEnv(envName, { scope: options.scope });

package/dist/lib/env-config.js

@@ -19,6 +19,7 @@ const STRING_ENV_CONFIG_KEYS = [
     'appPort',
     'appKey',
     'timezone',
+    'authUsername',
     'dbDialect',
     'builtinDbImage',
     'dbHost',
@@ -83,11 +84,11 @@ export function buildStoredEnvConfig(input) {
         }
     }
     const authType = trimConfigValue(input.authType);
-    if (authType === 'token' || authType === 'oauth') {
+    if (authType === 'basic' || authType === 'token' || authType === 'oauth') {
         envConfig.authType = authType;
     }
     const accessToken = trimConfigValue(input.accessToken);
-    if (authType === 'token' && accessToken) {
+    if ((authType === 'basic' || authType === 'token') && accessToken) {
         envConfig.accessToken = accessToken;
     }
     return envConfig;