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

package/dist/commands/stop.js

@@ -50,13 +50,20 @@ export default class Stop extends Command {
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
         }
-        if (runtime.kind === 'remote') {
+        if (runtime.kind === 'http') {
             this.error([
                 `Can't stop "${runtime.envName}" from this machine.`,
                 'This env only has an API connection, so there is no saved local app or Docker runtime to stop here.',
                 'If the app is running on a server, stop it there or reconnect this env to a local runtime first.',
             ].join('\n'));
         }
+        if (runtime.kind === 'ssh') {
+            this.error([
+                `Can't stop "${runtime.envName}" yet.`,
+                'SSH env support is reserved but not implemented yet.',
+                'Use a local or Docker env if you need CLI-managed stop right now.',
+            ].join('\n'));
+        }
         if (runtime.kind === 'docker') {
             startTask(`Stopping NocoBase for "${runtime.envName}"...`);
             try {

package/dist/commands/upgrade.js

@@ -8,6 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, stopDockerContainer, } from '../lib/app-runtime.js';
+import { resolveConfiguredEnvPath } from '../lib/cli-home.js';
 import { commandOutput, commandSucceeds, run } from '../lib/run-npm.js';
 import { failTask, printInfo, startTask, stopTask, succeedTask, updateTask } from '../lib/ui.js';
 const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
@@ -123,6 +124,9 @@ function normalizeDockerPlatform(value) {
     return undefined;
 }
 function readEnvValue(env, key) {
+    if (key === 'appRootPath' || key === 'storagePath') {
+        return trimValue(resolveConfiguredEnvPath(env.config[key]));
+    }
     return trimValue(env.config[key]);
 }
 async function sleep(ms) {
@@ -560,13 +564,20 @@ export default class Upgrade extends Command {
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
         }
-        if (runtime.kind === 'remote') {
+        if (runtime.kind === 'http') {
             this.error([
                 `Can't upgrade "${runtime.envName}" from this machine.`,
                 'This env only has an API connection, so there is no saved local app or Docker runtime to upgrade here.',
                 'If you want a local NocoBase AI environment that the CLI can upgrade, run `nb init` first.',
             ].join('\n'));
         }
+        if (runtime.kind === 'ssh') {
+            this.error([
+                `Can't upgrade "${runtime.envName}" yet.`,
+                'SSH env support is reserved but not implemented yet.',
+                'Use a local or Docker env if you need CLI-managed upgrades right now.',
+            ].join('\n'));
+        }
         try {
             const runCommand = this.config.runCommand.bind(this.config);
             if (runtime.kind === 'docker') {

package/dist/lib/api-client.js

@@ -8,6 +8,7 @@
  */
 import { promises as fs } from 'node:fs';
 import { resolveServerRequestTarget } from './env-auth.js';
+import { fetchWithPreservedAuthRedirect } from './http-request.js';
 const CLI_REQUEST_SOURCE_HEADER = 'x-request-source';
 const CLI_REQUEST_SOURCE_VALUE = 'cli';
 function stripUtf8Bom(text) {
@@ -195,7 +196,7 @@ export async function executeApiRequest(options) {
     }
     const url = new URL(`${normalizeBaseUrl(baseUrl)}${requestPath}`);
     query.forEach((value, key) => url.searchParams.append(key, value));
-    const response = await fetch(url, {
+    const response = await fetchWithPreservedAuthRedirect(url.toString(), {
         method: options.operation.method.toUpperCase(),
         headers,
         body: body === undefined ? undefined : JSON.stringify(body),
@@ -234,7 +235,7 @@ export async function executeRawApiRequest(options) {
         }
         url.searchParams.set(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
     }
-    const response = await fetch(url, {
+    const response = await fetchWithPreservedAuthRedirect(url.toString(), {
         method: options.method.toUpperCase(),
         headers,
         body: options.body === undefined ? undefined : JSON.stringify(options.body),

package/dist/lib/app-runtime.js

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import path from 'node:path';
+import { resolveEnvKind } from './auth-store.js';
 import { getEnv, loadAuthConfig } from './auth-store.js';
 import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
 const DOCKER_APP_WORKDIR = '/app/nocobase';
@@ -36,7 +37,8 @@ function normalizeEnvSource(env) {
     if (source === 'docker' || source === 'npm' || source === 'git') {
         return source;
     }
-    if (env.config.appRootPath) {
+    const kind = resolveEnvKind(env.config);
+    if (kind === 'local') {
         return 'local';
     }
     return undefined;
@@ -50,17 +52,18 @@ export async function resolveManagedAppRuntime(envName) {
     const resolvedName = env.name || envName?.trim() || config.currentEnv || 'default';
     const source = normalizeEnvSource(env);
     const workspaceName = config.name?.trim() || defaultWorkspaceName();
-    if (source === 'docker') {
+    const kind = env.kind ?? resolveEnvKind(env.config);
+    if (kind === 'docker') {
         return {
             kind: 'docker',
             env,
             envName: resolvedName,
-            source,
+            source: 'docker',
             workspaceName,
             containerName: buildDockerAppContainerName(resolvedName, workspaceName),
         };
     }
-    if (env.config.appRootPath) {
+    if (kind === 'local') {
         return {
             kind: 'local',
             env,
@@ -70,8 +73,16 @@ export async function resolveManagedAppRuntime(envName) {
             workspaceName,
         };
     }
+    if (kind === 'ssh') {
+        return {
+            kind: 'ssh',
+            env,
+            envName: resolvedName,
+            source,
+        };
+    }
     return {
-        kind: 'remote',
+        kind: 'http',
         env,
         envName: resolvedName,
         source,

package/dist/lib/auth-store.js

@@ -7,33 +7,126 @@
  * 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 { 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();
+    return requestedScope === 'global';
+}
+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 +140,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 +168,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 +179,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 +231,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 +266,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 +290,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 +299,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 +313,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 +327,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 +348,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,28 @@
+/**
+ * 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_ENV_ROOT_ENV = 'NB_ENV_ROOT';
+export function resolveDefaultConfigScope() {
+    const raw = String(process.env[NB_CONFIG_SCOPE_ENV] ?? '').trim().toLowerCase();
+    return raw === 'project' ? 'project' : 'global';
+}
 function resolveGlobalCliHomeRoot() {
     if (process.env.NOCOBASE_CTL_HOME) {
         return process.env.NOCOBASE_CTL_HOME;
     }
     return os.homedir();
 }
-export function resolveCliHomeRoot(scope = 'auto') {
+export function resolveCliHomeRoot(scope = resolveDefaultConfigScope()) {
     const cwdRoot = process.cwd();
     if (scope === 'project') {
         return cwdRoot;
@@ -22,9 +36,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 = String(process.env[NB_ENV_ROOT_ENV] ?? '').trim();
+    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/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)