@nocobase/cli 2.1.0-alpha.45 → 2.1.0-alpha.47

package/dist/lib/auth-store.js

@@ -8,8 +8,10 @@
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { resolveAppPublicPath } from './app-public-path.js';
 import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
 import { normalizeCliLocale } from './cli-locale.js';
+import { inferConfiguredAppPathFromLegacyConfig, resolveConfiguredAppPath, resolveConfiguredSourcePath, resolveConfiguredStoragePath, } from './env-paths.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
@@ -32,6 +34,13 @@ function normalizeOptionalCliLocale(value) {
     }
     return normalizeCliLocale(normalized);
 }
+function normalizeOptionalCliUpdatePolicy(value) {
+    const normalized = normalizeOptionalString(value);
+    if (normalized === 'prompt' || normalized === 'auto' || normalized === 'off') {
+        return normalized;
+    }
+    return undefined;
+}
 export function readEnvApiBaseUrl(config) {
     if (!config) {
         return undefined;
@@ -55,7 +64,7 @@ export function resolveEnvKind(config) {
     if (source === 'npm' || source === 'git' || source === 'local') {
         return 'local';
     }
-    if (String(config.appRootPath ?? '').trim()) {
+    if (String(config.appPath ?? '').trim() || String(config.appRootPath ?? '').trim()) {
         return 'local';
     }
     if (readEnvApiBaseUrl(config) || config.auth) {
@@ -74,15 +83,32 @@ function normalizeEnvConfigEntry(entry) {
         ...rest,
         ...(normalizedKind ? { kind: normalizedKind } : {}),
         ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
+        ...(normalizeOptionalString(entry.appPublicPath) ? { appPublicPath: resolveAppPublicPath(entry.appPublicPath) } : {}),
     };
 }
 function normalizeAuthConfig(config) {
     const settings = config.settings ?? {};
     const locale = normalizeOptionalCliLocale(settings.locale);
+    const defaultUiHost = normalizeOptionalString(settings.init?.defaultUiHost);
+    const defaultApiHost = normalizeOptionalString(settings.init?.defaultApiHost);
+    const updatePolicy = normalizeOptionalCliUpdatePolicy(settings.update?.policy);
+    const logRetentionDays = typeof settings.log?.retentionDays === 'number' && Number.isInteger(settings.log.retentionDays)
+        ? settings.log.retentionDays
+        : undefined;
+    const logEnabled = typeof settings.log?.enabled === 'boolean' ? settings.log.enabled : undefined;
     return {
         name: config.name || config.dockerResourcePrefix,
         settings: {
             ...(locale ? { locale } : {}),
+            ...(defaultUiHost || defaultApiHost
+                ? {
+                    init: {
+                        ...(defaultUiHost ? { defaultUiHost } : {}),
+                        ...(defaultApiHost ? { defaultApiHost } : {}),
+                    },
+                }
+                : {}),
+            ...(updatePolicy ? { update: { policy: updatePolicy } } : {}),
             ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
             ...(settings.docker?.network || settings.docker?.containerPrefix
                 ? {
@@ -94,15 +120,39 @@ function normalizeAuthConfig(config) {
                     },
                 }
                 : {}),
-            ...(settings.bin?.docker || settings.bin?.git || settings.bin?.yarn
+            ...(settings.bin?.docker || settings.bin?.caddy || settings.bin?.git || settings.bin?.nginx || settings.bin?.yarn
                 ? {
                     bin: {
                         ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
+                        ...(settings.bin?.caddy ? { caddy: normalizeOptionalString(settings.bin.caddy) } : {}),
                         ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
+                        ...(settings.bin?.nginx ? { nginx: normalizeOptionalString(settings.bin.nginx) } : {}),
                         ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
                     },
                 }
                 : {}),
+            ...(settings.proxy?.nbCliRoot ||
+                settings.proxy?.upstreamHost ||
+                settings.proxy?.host
+                ? {
+                    proxy: {
+                        ...(settings.proxy?.nbCliRoot ? { nbCliRoot: normalizeOptionalString(settings.proxy.nbCliRoot) } : {}),
+                        ...(settings.proxy?.upstreamHost || settings.proxy?.host
+                            ? {
+                                upstreamHost: normalizeOptionalString(settings.proxy?.upstreamHost ?? settings.proxy.host),
+                            }
+                            : {}),
+                    },
+                }
+                : {}),
+            ...(logEnabled !== undefined || logRetentionDays !== undefined
+                ? {
+                    log: {
+                        ...(logEnabled !== undefined ? { enabled: logEnabled } : {}),
+                        ...(logRetentionDays !== undefined ? { retentionDays: logRetentionDays } : {}),
+                    },
+                }
+                : {}),
         },
         lastEnv: config.lastEnv ||
             config.currentEnv ||
@@ -196,7 +246,29 @@ export class Env {
                 return configuredPath;
             }
         }
-        return resolveConfiguredEnvPath(this.config.appRootPath) ?? resolveEnvRelativePath('.');
+        const legacyPath = resolveConfiguredEnvPath(this.config.appRootPath);
+        if (legacyPath) {
+            return legacyPath;
+        }
+        return this.kind === 'local' ? this.sourcePath : resolveEnvRelativePath('.');
+    }
+    get appPath() {
+        if (this.kind === 'ssh') {
+            const configuredPath = String(this.config.appPath ?? inferConfiguredAppPathFromLegacyConfig(this.config) ?? '').trim();
+            if (configuredPath) {
+                return configuredPath;
+            }
+        }
+        return resolveConfiguredAppPath(this.config) ?? resolveEnvRelativePath('.');
+    }
+    get sourcePath() {
+        if (this.kind === 'ssh') {
+            const configuredPath = String(this.config.appRootPath ?? '').trim();
+            if (configuredPath) {
+                return configuredPath;
+            }
+        }
+        return resolveConfiguredSourcePath(this.config) ?? path.join(this.appPath, 'source');
     }
     get storagePath() {
         if (this.kind === 'ssh') {
@@ -205,7 +277,13 @@ export class Env {
                 return configuredPath;
             }
         }
-        return resolveConfiguredEnvPath(this.config.storagePath) ?? resolveEnvRelativePath('.');
+        const resolvedStoragePath = resolveConfiguredStoragePath(this.config);
+        if (resolvedStoragePath) {
+            return resolvedStoragePath;
+        }
+        return this.kind === 'local' || this.kind === 'docker'
+            ? path.join(this.appPath, 'storage')
+            : resolveEnvRelativePath('.');
     }
     get appPort() {
         return this.config.appPort;
@@ -221,6 +299,8 @@ export class Env {
             out[key] = String(value);
         };
         put('APP_PORT', this.appPort);
+        put('APP_PUBLIC_PATH', this.config.appPublicPath ? resolveAppPublicPath(this.config.appPublicPath) : undefined);
+        put('CDN_BASE_URL', this.config.cdnBaseUrl);
         put('APP_KEY', this.config.appKey);
         put('TZ', this.config.timezone);
         put('DB_DIALECT', this.config.dbDialect);
@@ -349,6 +429,39 @@ export async function updateEnvConnection(envName, updates, options = {}) {
         };
     }, options);
 }
+export async function replaceEnvConfig(envName, config, options = {}) {
+    await writeEnv(envName, (previous) => {
+        if (!previous) {
+            throw new Error(`Env "${envName}" is not configured`);
+        }
+        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 nextAuthType = normalizeConfiguredAuthType(authType) ?? (accessToken ? 'token' : undefined);
+        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) : undefined;
+        const nextAuth = accessToken
+            ? {
+                type: 'token',
+                accessToken,
+            }
+            : 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 {
+            ...rest,
+            ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
+            ...(nextAuthType ? { authType: nextAuthType } : {}),
+            ...(nextAuthUsername ? { authUsername: nextAuthUsername } : {}),
+            ...(nextAuth ? { auth: nextAuth } : {}),
+            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
+        };
+    }, options);
+}
 export async function setEnvOauthSession(envName, auth, options = {}) {
     await writeEnv(envName, (previous) => ({
         ...previous,
@@ -366,6 +479,17 @@ export async function setEnvRuntime(envName, runtime, options = {}) {
     };
     await saveAuthConfig(config, options);
 }
+export async function clearEnvRootSetup(envName, options = {}) {
+    const config = await loadExactAuthConfig(options);
+    const current = config.envs[envName];
+    if (!current) {
+        return false;
+    }
+    const { rootUsername: _rootUsername, rootEmail: _rootEmail, rootPassword: _rootPassword, rootNickname: _rootNickname, ...rest } = current;
+    config.envs[envName] = rest;
+    await saveAuthConfig(config, options);
+    return true;
+}
 export async function removeEnv(envName, options = {}) {
     const config = await loadExactAuthConfig(options);
     if (!config.envs[envName]) {

package/dist/lib/backup.js

@@ -62,14 +62,14 @@ export async function resolveBackupTargetEnv(requestedEnv) {
     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.');
+        throw new Error('No env is configured. Run `nb init --ui` 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(`Env "${envName}" is not configured. Run \`nb init --ui --env ${envName}\` 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>`.',
+        `Switch to an existing env with \`nb env use <name>\`, or run \`nb init --ui --env ${envName}\` to create or connect it.`,
     ].join('\n'));
 }
 export async function ensureBackupRuntimeCommands(params) {

package/dist/lib/bootstrap.js

@@ -254,25 +254,31 @@ export function formatSwaggerSchemaError(response, context) {
         })
             .join('\n');
         const envLabel = context.envName ? ` for env "${context.envName}"` : '';
+        const tokenHint = context.envName
+            ? `Update the API key with \`nb env update ${context.envName} --token <api-key>\`, log in with \`nb env auth ${context.envName}\`, or rerun the command with \`--access-token <api-key>\`.`
+            : 'Update the API key with `nb env update <name> --token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--access-token <api-key>`.';
         const commandHint = context.commandToken
-            ? `If \`${context.commandToken}\` is a runtime command, refresh the runtime after updating the token with \`nb env update\`. If it is a typo, run \`nb --help\` to inspect available commands.`
-            : 'Run `nb --help` to inspect built-in commands, then refresh runtime commands with `nb env update` after updating the token.';
+            ? `If \`${context.commandToken}\` is a runtime command, retry it after updating the token. If it is a typo, run \`nb --help\` to inspect available commands.`
+            : 'Run `nb --help` to inspect built-in commands, then retry the original command after updating the token.';
         return [
             `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 --access-token <api-key>`, log in with `nb env auth <name>`, or rerun the command with `--access-token <api-key>`.',
+            tokenHint,
             commandHint,
         ].join('\n');
     }
     if (isNetworkFetchFailure(response)) {
         const rawMessage = response.data?.error?.message || 'fetch failed';
+        const updateConnectionHint = context.envName
+            ? `If you recently changed the server address, update env "${context.envName}" with \`nb env update ${context.envName} --api-base-url <url>\` and retry the original command.`
+            : 'If you recently changed the server address, update the saved env connection with `nb env update <name> --api-base-url <url>` and retry the original command.';
         return [
             'Failed to reach the NocoBase server while loading the command runtime from `swagger:get`.',
             `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> --api-base-url <url>` and retry `nb env update`.',
+            updateConnectionHint,
             'Use `nb env list` to inspect the current env configuration.',
         ].join('\n');
     }
@@ -282,7 +288,7 @@ export function formatMissingRuntimeEnvError(commandToken) {
     if (!commandToken) {
         return [
             'No env is configured for runtime commands.',
-            'Run `nb env add <name> --api-base-url <url>` first.',
+            'Run `nb init --ui` first.',
             'If you configure multiple environments later, switch with `nb env use <name>`.',
         ].join('\n');
     }
@@ -290,7 +296,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> --api-base-url <url>` and then `nb env update`.',
+        'If this should be an application runtime command, run `nb init --ui` to create or connect a NocoBase app first.',
     ].join('\n');
 }
 export async function ensureRuntimeFromArgv(argv, options) {
@@ -366,8 +372,8 @@ export async function updateEnvRuntime(options) {
         throw new Error([
             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> --api-base-url <url>` first.' : '',
+                : `Env "${envName}" is not configured. Run \`nb init --ui --env ${envName}\` first.`,
+            env ? `Update env "${envName}" with \`nb env update ${envName} --api-base-url <url>\` first.` : '',
         ]
             .filter(Boolean)
             .join('\n'));