@nocobase/cli 2.1.0-beta.20 → 2.1.0-beta.22

package/dist/lib/auth-store.js

@@ -7,33 +7,129 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { promises as fs } from 'node:fs';
-import path, { isAbsolute } from 'node:path';
-import { resolveCliHomeDir } from './cli-home.js';
-const DEFAULT_CONFIG = {
-    currentEnv: 'default',
-    envs: {},
-};
+import path from 'node:path';
+import { NB_CLI_ROOT_ENV, resolveCliHomeDir, resolveConfiguredEnvPath, resolveDefaultConfigScope, resolveEnvRelativePath, } from './cli-home.js';
+function normalizeStoredEnvKind(value) {
+    const kind = String(value ?? '').trim();
+    if (kind === 'remote') {
+        return 'http';
+    }
+    if (kind === 'local' || kind === 'http' || kind === 'docker' || kind === 'ssh') {
+        return kind;
+    }
+    return undefined;
+}
+function normalizeOptionalString(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized || undefined;
+}
+export function readEnvApiBaseUrl(config) {
+    if (!config) {
+        return undefined;
+    }
+    return (normalizeOptionalString(config.apiBaseUrl)
+        ?? normalizeOptionalString(config.baseUrl)
+        ?? normalizeOptionalString(config.apibaseUrl));
+}
+export function resolveEnvKind(config) {
+    if (!config) {
+        return undefined;
+    }
+    const explicitKind = normalizeStoredEnvKind(config.kind);
+    if (explicitKind) {
+        return explicitKind;
+    }
+    const source = String(config.source ?? '').trim();
+    if (source === 'docker') {
+        return 'docker';
+    }
+    if (source === 'npm' || source === 'git' || source === 'local') {
+        return 'local';
+    }
+    if (String(config.appRootPath ?? '').trim()) {
+        return 'local';
+    }
+    if (readEnvApiBaseUrl(config) || config.auth) {
+        return 'http';
+    }
+    return undefined;
+}
+function normalizeEnvConfigEntry(entry) {
+    if (!entry) {
+        return entry;
+    }
+    const { kind: _kind, apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, ...rest } = entry;
+    const normalizedKind = resolveEnvKind(entry);
+    const apiBaseUrl = readEnvApiBaseUrl(entry);
+    return {
+        ...rest,
+        ...(normalizedKind ? { kind: normalizedKind } : {}),
+        ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
+    };
+}
+function normalizeAuthConfig(config) {
+    return {
+        name: config.name || config.dockerResourcePrefix,
+        currentEnv: config.currentEnv || 'default',
+        envs: Object.fromEntries(Object.entries(config.envs || {}).map(([envName, entry]) => [envName, normalizeEnvConfigEntry(entry) ?? {}])),
+    };
+}
 function getConfigFile(options = {}) {
     return path.join(resolveCliHomeDir(options.scope), 'config.json');
 }
-export async function loadAuthConfig(options = {}) {
+function createDefaultConfig() {
+    return {
+        currentEnv: 'default',
+        envs: {},
+    };
+}
+function hasConfiguredEnvs(config) {
+    return Object.keys(config.envs).length > 0;
+}
+function shouldFallbackToLegacyProjectScope(options = {}) {
+    const requestedScope = options.scope ?? resolveDefaultConfigScope();
+    if (requestedScope !== 'global') {
+        return false;
+    }
+    return !process.env[NB_CLI_ROOT_ENV];
+}
+async function loadExactAuthConfig(options = {}) {
     try {
         const content = await fs.readFile(getConfigFile(options), 'utf8');
         const parsed = JSON.parse(content);
-        return {
-            name: parsed.name || parsed.dockerResourcePrefix,
-            currentEnv: parsed.currentEnv || 'default',
-            envs: parsed.envs || {},
-        };
+        return normalizeAuthConfig(parsed);
     }
     catch (_error) {
-        return DEFAULT_CONFIG;
+        return createDefaultConfig();
+    }
+}
+async function resolveEnvStorageScope(envName, options = {}) {
+    const requestedScope = options.scope ?? resolveDefaultConfigScope();
+    if (requestedScope !== 'global') {
+        return { ...options, scope: requestedScope };
+    }
+    const globalConfig = await loadExactAuthConfig({ scope: 'global' });
+    if (globalConfig.envs[envName]) {
+        return { ...options, scope: 'global' };
     }
+    const projectConfig = await loadExactAuthConfig({ scope: 'project' });
+    if (projectConfig.envs[envName]) {
+        return { ...options, scope: 'project' };
+    }
+    return { ...options, scope: 'global' };
+}
+export async function loadAuthConfig(options = {}) {
+    const config = await loadExactAuthConfig(options);
+    if (!shouldFallbackToLegacyProjectScope(options) || hasConfiguredEnvs(config)) {
+        return config;
+    }
+    const legacyProjectConfig = await loadExactAuthConfig({ scope: 'project' });
+    return hasConfiguredEnvs(legacyProjectConfig) ? legacyProjectConfig : config;
 }
 export async function saveAuthConfig(config, options = {}) {
     const filePath = getConfigFile(options);
     await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+    await fs.writeFile(filePath, JSON.stringify(normalizeAuthConfig(config), null, 2));
 }
 export async function listEnvs(options = {}) {
     const config = await loadAuthConfig(options);
@@ -47,15 +143,16 @@ export async function getCurrentEnvName(options = {}) {
     return config.currentEnv || 'default';
 }
 export async function setCurrentEnv(envName, options = {}) {
-    const config = await loadAuthConfig(options);
+    const writeOptions = await resolveEnvStorageScope(envName, options);
+    const config = await loadExactAuthConfig(writeOptions);
     if (!config.envs[envName]) {
         throw new Error(`Env "${envName}" is not configured`);
     }
     config.currentEnv = envName;
-    await saveAuthConfig(config, options);
+    await saveAuthConfig(config, writeOptions);
 }
 export async function ensureWorkspaceName(defaultName, options = {}) {
-    const config = await loadAuthConfig(options);
+    const config = await loadExactAuthConfig(options);
     const existing = config.name?.trim();
     if (existing) {
         return existing;
@@ -74,7 +171,10 @@ export class Env {
         return this.config.name;
     }
     get baseUrl() {
-        return this.config.baseUrl;
+        return readEnvApiBaseUrl(this.config);
+    }
+    get apiBaseUrl() {
+        return readEnvApiBaseUrl(this.config);
     }
     get auth() {
         return this.config.auth;
@@ -82,22 +182,26 @@ export class Env {
     get runtime() {
         return this.config.runtime;
     }
+    get kind() {
+        return resolveEnvKind(this.config);
+    }
     get appRootPath() {
-        const appRootPath = this.config.appRootPath;
-        if (!appRootPath) {
-            return process.cwd();
-        }
-        if (isAbsolute(appRootPath)) {
-            return appRootPath;
+        if (this.kind === 'ssh') {
+            const configuredPath = String(this.config.appRootPath ?? '').trim();
+            if (configuredPath) {
+                return configuredPath;
+            }
         }
-        return path.resolve(process.cwd(), appRootPath);
+        return resolveConfiguredEnvPath(this.config.appRootPath) ?? resolveEnvRelativePath('.');
     }
     get storagePath() {
-        const storagePath = this.config.storagePath;
-        if (isAbsolute(storagePath)) {
-            return storagePath;
+        if (this.kind === 'ssh') {
+            const configuredPath = String(this.config.storagePath ?? '').trim();
+            if (configuredPath) {
+                return configuredPath;
+            }
         }
-        return path.resolve(process.cwd(), storagePath);
+        return resolveConfiguredEnvPath(this.config.storagePath) ?? resolveEnvRelativePath('.');
     }
     get appPort() {
         return this.config.appPort;
@@ -130,9 +234,18 @@ export async function getEnv(envName, options = {}) {
     const resolved = envName?.trim() || config.currentEnv || 'default';
     const envConfig = config.envs[resolved];
     if (!envConfig) {
-        return undefined;
+        if (!shouldFallbackToLegacyProjectScope(loadOptions)) {
+            return undefined;
+        }
+        const legacyProjectConfig = await loadExactAuthConfig({ scope: 'project' });
+        const legacyResolved = envName?.trim() || legacyProjectConfig.currentEnv || 'default';
+        const legacyEnvConfig = legacyProjectConfig.envs[legacyResolved];
+        if (!legacyEnvConfig) {
+            return undefined;
+        }
+        return new Env({ ...(normalizeEnvConfigEntry(legacyEnvConfig) ?? {}), name: legacyResolved });
     }
-    return new Env({ ...envConfig, name: resolved });
+    return new Env({ ...(normalizeEnvConfigEntry(envConfig) ?? {}), name: resolved });
 }
 function areAuthConfigsEquivalent(left, right) {
     if (!left && !right) {
@@ -156,16 +269,19 @@ function areAuthConfigsEquivalent(left, right) {
     return false;
 }
 async function writeEnv(envName, updater, options = {}) {
-    const config = await loadAuthConfig(options);
+    const writeOptions = await resolveEnvStorageScope(envName, options);
+    const config = await loadExactAuthConfig(writeOptions);
     const previous = config.envs[envName];
     config.envs[envName] = updater(previous);
     config.currentEnv = envName;
-    await saveAuthConfig(config, options);
+    await saveAuthConfig(config, writeOptions);
 }
 export async function upsertEnv(envName, config, options = {}) {
     await writeEnv(envName, (previous) => {
-        const { baseUrl, accessToken, ...rest } = config;
-        const baseUrlChanged = previous?.baseUrl !== baseUrl;
+        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, ...rest } = config;
+        const nextApiBaseUrl = readEnvApiBaseUrl(config);
+        const previousApiBaseUrl = readEnvApiBaseUrl(previous);
+        const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
         const nextAuth = accessToken
             ? {
                 type: 'token',
@@ -177,7 +293,7 @@ export async function upsertEnv(envName, config, options = {}) {
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
         return {
             ...previous,
-            baseUrl,
+            apiBaseUrl: nextApiBaseUrl,
             auth: nextAuth,
             ...rest,
             runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
@@ -186,8 +302,9 @@ export async function upsertEnv(envName, config, options = {}) {
 }
 export async function updateEnvConnection(envName, updates, options = {}) {
     await writeEnv(envName, (previous) => {
-        const nextBaseUrl = updates.baseUrl ?? previous?.baseUrl;
-        const baseUrlChanged = previous?.baseUrl !== nextBaseUrl;
+        const nextApiBaseUrl = readEnvApiBaseUrl(updates) ?? readEnvApiBaseUrl(previous);
+        const previousApiBaseUrl = readEnvApiBaseUrl(previous);
+        const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
         const nextAuth = updates.accessToken
             ? {
                 type: 'token',
@@ -199,7 +316,7 @@ export async function updateEnvConnection(envName, updates, options = {}) {
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
         return {
             ...previous,
-            ...(nextBaseUrl !== undefined ? { baseUrl: nextBaseUrl } : {}),
+            ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
             auth: nextAuth,
             runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
         };
@@ -213,17 +330,19 @@ export async function setEnvOauthSession(envName, auth, options = {}) {
     }), options);
 }
 export async function setEnvRuntime(envName, runtime, options = {}) {
-    const config = await loadAuthConfig(options);
+    const writeOptions = await resolveEnvStorageScope(envName, options);
+    const config = await loadExactAuthConfig(writeOptions);
     const current = config.envs[envName] ?? {};
     config.envs[envName] = {
         ...current,
         runtime,
     };
     config.currentEnv = envName;
-    await saveAuthConfig(config, options);
+    await saveAuthConfig(config, writeOptions);
 }
 export async function removeEnv(envName, options = {}) {
-    const config = await loadAuthConfig(options);
+    const writeOptions = await resolveEnvStorageScope(envName, options);
+    const config = await loadExactAuthConfig(writeOptions);
     if (!config.envs[envName]) {
         throw new Error(`Env "${envName}" is not configured`);
     }
@@ -232,7 +351,7 @@ export async function removeEnv(envName, options = {}) {
         const nextEnv = Object.keys(config.envs).sort()[0];
         config.currentEnv = nextEnv ?? 'default';
     }
-    await saveAuthConfig(config, options);
+    await saveAuthConfig(config, writeOptions);
     return {
         removed: envName,
         currentEnv: config.currentEnv || 'default',

package/dist/lib/bootstrap.js

@@ -8,6 +8,7 @@
  */
 import { getCurrentEnvName, getEnv, setEnvRuntime, updateEnvConnection } from './auth-store.js';
 import { resolveAccessToken } from './env-auth.js';
+import { fetchWithPreservedAuthRedirect } from './http-request.js';
 import { generateRuntime } from './runtime-generator.js';
 import { hasRuntimeSync, saveRuntime } from './runtime-store.js';
 import { confirmAction, printInfo, printVerbose, printWarningBlock, setVerboseMode, stopTask, updateTask } from './ui.js';
@@ -92,7 +93,7 @@ async function requestJson(url, options) {
     }
     let response;
     try {
-        response = await fetch(url, {
+        response = await fetchWithPreservedAuthRedirect(url, {
             method: options.method ?? 'GET',
             headers,
         });
@@ -144,7 +145,7 @@ async function waitForServiceReady(baseUrl, token, role) {
     const startedAt = Date.now();
     let notified = false;
     while (Date.now() - startedAt < APP_RETRY_TIMEOUT) {
-        const response = await fetch(healthCheckUrl, {
+        const response = await fetchWithPreservedAuthRedirect(healthCheckUrl, {
             method: 'GET',
             headers: token || role
                 ? {
@@ -228,14 +229,14 @@ function collectErrorEntries(data) {
     }
     return [];
 }
-function hasInvalidTokenError(data) {
-    return collectErrorEntries(data).some((entry) => entry?.code === 'INVALID_TOKEN');
+function hasAuthenticationError(data) {
+    return collectErrorEntries(data).some((entry) => entry?.code === 'INVALID_TOKEN' || entry?.code === 'EMPTY_TOKEN');
 }
 function isNetworkFetchFailure(response) {
     return response.status === 0;
 }
 export function formatSwaggerSchemaError(response, context) {
-    if (hasInvalidTokenError(response.data)) {
+    if (hasAuthenticationError(response.data)) {
         const entries = collectErrorEntries(response.data);
         const details = entries
             .map((entry) => {
@@ -251,7 +252,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> --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 --token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--token <api-key>`.',
             commandHint,
         ].join('\n');
     }
@@ -262,7 +263,7 @@ export function formatSwaggerSchemaError(response, context) {
             `Base URL: ${context.baseUrl}`,
             `Network error: ${rawMessage}`,
             'Check that the NocoBase app is running, the base URL is correct, and the server is reachable from this machine.',
-            'If you recently changed the server address, update it with `nb env add <name> --base-url <url>` and retry `nb env update`.',
+            'If you recently changed the server address, update it with `nb env add <name> --api-base-url <url>` and retry `nb env update`.',
             'Use `nb env list` to inspect the current env configuration.',
         ].join('\n');
     }
@@ -272,7 +273,7 @@ export function formatMissingRuntimeEnvError(commandToken) {
     if (!commandToken) {
         return [
             'No env is configured for runtime commands.',
-            'Run `nb env add <name> --base-url <url>` first.',
+            'Run `nb env add <name> --api-base-url <url>` first.',
             'If you configure multiple environments later, switch with `nb env use <name>`.',
         ].join('\n');
     }
@@ -280,7 +281,7 @@ export function formatMissingRuntimeEnvError(commandToken) {
         `Unable to resolve runtime command \`${commandToken}\`.`,
         'No env is configured, so the CLI cannot load runtime commands from `swagger:get`.',
         'If this is a built-in command or a typo, run `nb --help` to inspect available commands.',
-        'If this should be an application runtime command, run `nb env add <name> --base-url <url>` and then `nb env update`.',
+        'If this should be an application runtime command, run `nb env add <name> --api-base-url <url>` and then `nb env update`.',
     ].join('\n');
 }
 export async function ensureRuntimeFromArgv(argv, options) {
@@ -294,7 +295,7 @@ export async function ensureRuntimeFromArgv(argv, options) {
     try {
         const envName = readFlag(argv, 'env') ?? (await getCurrentEnvName());
         const env = await getEnv(envName);
-        const baseUrl = readFlag(argv, 'base-url') ?? env?.baseUrl;
+        const baseUrl = readFlag(argv, 'api-base-url') ?? env?.baseUrl;
         const role = readFlag(argv, 'role');
         const token = await resolveAccessToken({
             envName,
@@ -357,7 +358,7 @@ export async function updateEnvRuntime(options) {
             env
                 ? `Env "${envName}" is missing a base URL.`
                 : `Env "${envName}" is not configured. Run \`nb env add ${envName}\` first.`,
-            env ? 'Update it with `nb env add <name> --base-url <url>` first.' : '',
+            env ? 'Update it with `nb env add <name> --api-base-url <url>` first.' : '',
         ]
             .filter(Boolean)
             .join('\n'));
@@ -370,7 +371,7 @@ export async function updateEnvRuntime(options) {
         await saveRuntime(runtime, { scope: options.scope });
         if (options.baseUrl !== undefined || options.token !== undefined) {
             await updateEnvConnection(envName, {
-                baseUrl: options.baseUrl,
+                apiBaseUrl: options.baseUrl,
                 accessToken: options.token,
             }, { scope: options.scope });
         }

package/dist/lib/cli-home.js

@@ -1,14 +1,29 @@
+/**
+ * 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 fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 export const CLI_HOME_DIRNAME = '.nocobase';
+export const NB_CONFIG_SCOPE_ENV = 'NB_CONFIG_SCOPE';
+export const NB_CLI_ROOT_ENV = 'NB_CLI_ROOT';
+export function resolveDefaultConfigScope() {
+    const raw = String(process.env[NB_CONFIG_SCOPE_ENV] ?? '').trim().toLowerCase();
+    return raw === 'project' ? 'project' : 'global';
+}
+function readConfiguredPath(name) {
+    const value = String(process.env[name] ?? '').trim();
+    return value || undefined;
+}
 function resolveGlobalCliHomeRoot() {
-    if (process.env.NOCOBASE_CTL_HOME) {
-        return process.env.NOCOBASE_CTL_HOME;
-    }
-    return os.homedir();
+    return readConfiguredPath(NB_CLI_ROOT_ENV) ?? os.homedir();
 }
-export function resolveCliHomeRoot(scope = 'auto') {
+export function resolveCliHomeRoot(scope = resolveDefaultConfigScope()) {
     const cwdRoot = process.cwd();
     if (scope === 'project') {
         return cwdRoot;
@@ -22,9 +37,26 @@ export function resolveCliHomeRoot(scope = 'auto') {
     }
     return resolveGlobalCliHomeRoot();
 }
-export function resolveCliHomeDir(scope = 'auto') {
+export function resolveCliHomeDir(scope = resolveDefaultConfigScope()) {
     return path.join(resolveCliHomeRoot(scope), CLI_HOME_DIRNAME);
 }
+export function resolveEnvRoot(scope = resolveDefaultConfigScope()) {
+    const envRoot = readConfiguredPath(NB_CLI_ROOT_ENV);
+    if (envRoot) {
+        return path.resolve(envRoot);
+    }
+    return resolveCliHomeRoot(scope);
+}
+export function resolveEnvRelativePath(relativePath, scope = resolveDefaultConfigScope()) {
+    return path.resolve(resolveEnvRoot(scope), relativePath);
+}
+export function resolveConfiguredEnvPath(value, scope = resolveDefaultConfigScope()) {
+    const text = String(value ?? '').trim();
+    if (!text) {
+        return undefined;
+    }
+    return path.isAbsolute(text) ? text : resolveEnvRelativePath(text, scope);
+}
 export function formatCliHomeScope(scope) {
     return scope === 'project' ? 'project' : 'global';
 }

package/dist/lib/cli-locale.js

@@ -7,6 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 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.';
@@ -30,8 +32,20 @@ function loadLocaleMessages(locale) {
     if (localeCache[locale]) {
         return localeCache[locale];
     }
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const fallbackPath = path.resolve(moduleDir, '..', 'locale', `${locale}.json`);
     const fileUrl = new URL(`../locale/${locale}.json`, import.meta.url);
-    const parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        parsed = JSON.parse(readFileSync(fallbackPath, 'utf8'));
+    }
     localeCache[locale] = parsed;
     return parsed;
 }

package/dist/lib/env-auth.js

@@ -750,7 +750,7 @@ export async function resolveAccessToken(options) {
     }
     const baseUrl = options.baseUrl ?? env.baseUrl;
     if (!baseUrl) {
-        throw new Error(`Env "${envName}" is missing a base URL. Run \`nb env add ${envName} --base-url <url>\`.`);
+        throw new Error(`Env "${envName}" is missing a base URL. Run \`nb env add ${envName} --api-base-url <url>\`.`);
     }
     printVerbose(`Refreshing OAuth session for env "${envName}"`);
     return refreshOauthAccessToken({
@@ -771,7 +771,7 @@ export async function resolveServerRequestTarget(options) {
         scope: options.scope,
     });
     if (!baseUrl) {
-        throw new Error('Missing base URL. Use --base-url or configure one with `nb env add`.');
+        throw new Error('Missing base URL. Use --api-base-url or configure one with `nb env add`.');
     }
     return { baseUrl, token };
 }
@@ -785,7 +785,7 @@ export async function authenticateEnvWithOauth(options) {
                 ? `Environment "${envName}" does not have an API base URL yet.`
                 : `Environment "${envName}" has not been set up yet.`,
             env
-                ? `Run \`nb env add ${envName} --base-url <url>\` to finish setting it up.`
+                ? `Run \`nb env add ${envName} --api-base-url <url>\` to finish setting it up.`
                 : `Run \`nb env add ${envName}\` first.`,
         ]
             .filter(Boolean)

package/dist/lib/env-config.js

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ */
+const STRING_ENV_CONFIG_KEYS = [
+    'source',
+    'downloadVersion',
+    'dockerRegistry',
+    'dockerPlatform',
+    'gitUrl',
+    'npmRegistry',
+    'appRootPath',
+    'storagePath',
+    'appPort',
+    'appKey',
+    'timezone',
+    'dbDialect',
+    'builtinDbImage',
+    'dbHost',
+    'dbPort',
+    'dbDatabase',
+    'dbUser',
+    'dbPassword',
+    'rootUsername',
+    'rootEmail',
+    'rootPassword',
+    'rootNickname',
+];
+const BOOLEAN_ENV_CONFIG_KEYS = [
+    'builtinDb',
+    'devDependencies',
+    'build',
+    'buildDts',
+];
+function trimConfigValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function resolveEnvKind(input) {
+    const source = trimConfigValue(input.source);
+    const appRootPath = trimConfigValue(input.appRootPath);
+    if (source === 'docker') {
+        return 'docker';
+    }
+    if (source === 'npm' || source === 'git' || source === 'local' || appRootPath) {
+        return 'local';
+    }
+    return 'http';
+}
+export function buildStoredEnvConfig(input) {
+    const envConfig = {
+        kind: resolveEnvKind(input),
+        apiBaseUrl: trimConfigValue(input.apiBaseUrl) ?? '',
+    };
+    for (const key of STRING_ENV_CONFIG_KEYS) {
+        const value = trimConfigValue(input[key]);
+        if (value) {
+            envConfig[key] = value;
+        }
+    }
+    for (const key of BOOLEAN_ENV_CONFIG_KEYS) {
+        const value = input[key];
+        if (typeof value === 'boolean') {
+            envConfig[key] = value;
+        }
+    }
+    if (input.builtinDb === false) {
+        envConfig.builtinDbImage = undefined;
+    }
+    const authType = trimConfigValue(input.authType);
+    const accessToken = trimConfigValue(input.accessToken);
+    if (authType === 'token' && accessToken) {
+        envConfig.accessToken = accessToken;
+    }
+    return envConfig;
+}

package/dist/lib/generated-command.js

@@ -1,3 +1,11 @@
+/**
+ * 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, Flags } from '@oclif/core';
 import { executeApiRequest } from './api-client.js';
 import { applyPostProcessor } from './post-processors.js';
@@ -74,7 +82,7 @@ export function createGeneratedFlags(operation) {
             exclusive: ['body'],
         });
     }
-    flags['base-url'] = Flags.string({
+    flags['api-base-url'] = Flags.string({
         description: 'NocoBase API base URL, for example http://localhost:13000/api',
         helpGroup: 'Global',
     });
@@ -114,7 +122,7 @@ export class GeneratedApiCommand extends Command {
         const { flags } = await this.parse(ctor);
         const response = await executeApiRequest({
             envName: flags.env,
-            baseUrl: flags['base-url'],
+            baseUrl: flags['api-base-url'],
             role: flags.role,
             token: flags.token,
             flags,