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

package/dist/lib/env-auth.js

@@ -34,6 +34,9 @@ export function getOauthResource(issuerOrBaseUrl) {
 export function getDefaultOauthScope() {
     return DEFAULT_OAUTH_SCOPE;
 }
+export function getOauthLoopbackRedirectUri(port) {
+    return `http://${LOOPBACK_HOST}:${port}/callback`;
+}
 function formatApiAuthError(prefix, data, fallbackStatus) {
     if (typeof data === 'string' && data.trim()) {
         return `${prefix}: ${data}`;
@@ -655,7 +658,7 @@ async function createLoopbackServer(state) {
                 return;
             }
             resolve({
-                redirectUri: `http://${LOOPBACK_HOST}:${address.port}/callback`,
+                redirectUri: getOauthLoopbackRedirectUri(address.port),
                 waitForCode,
                 close,
             });

package/dist/lib/env-command-config.js

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+export const ENV_STRING_CONFIG_FLAG_MAP = {
+    source: 'source',
+    'download-version': 'downloadVersion',
+    'docker-registry': 'dockerRegistry',
+    'docker-platform': 'dockerPlatform',
+    'git-url': 'gitUrl',
+    'npm-registry': 'npmRegistry',
+    'app-path': 'appPath',
+    'app-root-path': 'appRootPath',
+    'storage-path': 'storagePath',
+    'app-public-path': 'appPublicPath',
+    'cdn-base-url': 'cdnBaseUrl',
+    'env-file': 'envFile',
+    'app-port': 'appPort',
+    'app-key': 'appKey',
+    timezone: 'timezone',
+    'db-dialect': 'dbDialect',
+    'builtin-db-image': 'builtinDbImage',
+    'db-host': 'dbHost',
+    'db-port': 'dbPort',
+    'db-database': 'dbDatabase',
+    'db-user': 'dbUser',
+    'db-password': 'dbPassword',
+    'db-schema': 'dbSchema',
+    'db-table-prefix': 'dbTablePrefix',
+    'root-username': 'rootUsername',
+    'root-email': 'rootEmail',
+    'root-password': 'rootPassword',
+    'root-nickname': 'rootNickname',
+};
+export const ENV_BOOLEAN_CONFIG_FLAG_MAP = {
+    'builtin-db': 'builtinDb',
+    'dev-dependencies': 'devDependencies',
+    build: 'build',
+    'build-dts': 'buildDts',
+    'db-underscored': 'dbUnderscored',
+};

package/dist/lib/env-config.js

@@ -6,6 +6,7 @@
  * 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 { resolveAppPublicPath } from './app-public-path.js';
 const STRING_ENV_CONFIG_KEYS = [
     'source',
     'downloadVersion',
@@ -13,8 +14,11 @@ const STRING_ENV_CONFIG_KEYS = [
     'dockerPlatform',
     'gitUrl',
     'npmRegistry',
+    'appPath',
     'appRootPath',
     'storagePath',
+    'appPublicPath',
+    'cdnBaseUrl',
     'envFile',
     'appPort',
     'appKey',
@@ -47,11 +51,12 @@ function trimConfigValue(value) {
 }
 function resolveEnvKind(input) {
     const source = trimConfigValue(input.source);
+    const appPath = trimConfigValue(input.appPath);
     const appRootPath = trimConfigValue(input.appRootPath);
     if (source === 'docker') {
         return 'docker';
     }
-    if (source === 'npm' || source === 'git' || source === 'local' || appRootPath) {
+    if (source === 'npm' || source === 'git' || source === 'local' || appPath || appRootPath) {
         return 'local';
     }
     return 'http';
@@ -64,7 +69,7 @@ export function buildStoredEnvConfig(input) {
     for (const key of STRING_ENV_CONFIG_KEYS) {
         const value = trimConfigValue(input[key]);
         if (value) {
-            envConfig[key] = value;
+            envConfig[key] = key === 'appPublicPath' ? resolveAppPublicPath(value) : value;
         }
     }
     for (const key of BOOLEAN_ENV_CONFIG_KEYS) {

package/dist/lib/env-guard.js

@@ -8,6 +8,7 @@
  */
 import { stdin as input, stdout as output } from 'node:process';
 import { getCurrentEnvName } from './auth-store.js';
+import { translateCli } from './cli-locale.js';
 import { confirm } from "./inquirer.js";
 function normalizeEnvName(value) {
     const text = String(value ?? '').trim();
@@ -23,18 +24,16 @@ function isInteractiveTerminal() {
     return Boolean(input.isTTY && output.isTTY);
 }
 function formatCrossEnvPromptMessage(currentEnv, requestedEnv) {
-    return `Current env is "${currentEnv}", but this command targets "${requestedEnv}" via --env. Continue without switching the current env?`;
+    return translateCli('commands.shared.crossEnv.prompt', {
+        currentEnv,
+        requestedEnv,
+    });
 }
 export function formatCrossEnvRefusalMessage(currentEnv, requestedEnv) {
-    return [
-        `Refusing to run against env "${requestedEnv}" because the current env is "${currentEnv}" and interactive confirmation is unavailable in the current agent session.`,
-        '',
-        'For safety, the agent will not switch envs automatically and will not add --yes on your behalf.',
-        '',
-        'To continue:',
-        `- run \`nb env use ${requestedEnv}\` yourself and then re-run the command, or`,
-        `- re-run the same command with \`--env ${requestedEnv} --yes\` to confirm this one-off cross-env operation.`,
-    ].join('\n');
+    return translateCli('commands.shared.crossEnv.refusal', {
+        currentEnv,
+        requestedEnv,
+    });
 }
 export async function ensureCrossEnvConfirmed(options) {
     const requestedEnv = normalizeEnvName(options.requestedEnv);

package/dist/lib/env-paths.js

@@ -0,0 +1,101 @@
+/**
+ * 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 path from 'node:path';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+function trimPathValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function normalizePathForComparison(value) {
+    return value.replace(/[\\/]+/g, '/').replace(/\/+$/, '');
+}
+export function areConfiguredPathsEquivalent(left, right) {
+    const leftValue = trimPathValue(left);
+    const rightValue = trimPathValue(right);
+    if (!leftValue || !rightValue) {
+        return leftValue === rightValue;
+    }
+    return normalizePathForComparison(leftValue) === normalizePathForComparison(rightValue);
+}
+function trimTrailingSeparators(value) {
+    return value.replace(/[\\/]+$/, '');
+}
+function hasTerminalPathSegment(value, segment) {
+    const normalized = normalizePathForComparison(value);
+    return normalized.endsWith(`/${segment}`) || normalized === segment;
+}
+function dirnameWithTrailingSeparator(value) {
+    const trimmed = trimTrailingSeparators(value);
+    if (!trimmed) {
+        return undefined;
+    }
+    const separatorIndex = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    if (separatorIndex < 0) {
+        return undefined;
+    }
+    return trimmed.slice(0, separatorIndex + 1);
+}
+function inferAppPathFromLegacyConfigValue(value, leaf) {
+    if (!value || !hasTerminalPathSegment(value, leaf)) {
+        return undefined;
+    }
+    return dirnameWithTrailingSeparator(value);
+}
+export function deriveConfiguredSourcePath(appPath) {
+    const base = trimPathValue(appPath);
+    if (!base) {
+        return 'source/';
+    }
+    return `${base.replace(/[\\/]+$/, '')}/source/`;
+}
+export function deriveConfiguredStoragePath(appPath) {
+    const base = trimPathValue(appPath);
+    if (!base) {
+        return 'storage/';
+    }
+    return `${base.replace(/[\\/]+$/, '')}/storage/`;
+}
+export function inferConfiguredAppPathFromLegacyConfig(config) {
+    const explicitAppPath = trimPathValue(config.appPath);
+    if (explicitAppPath) {
+        return explicitAppPath;
+    }
+    const candidates = [
+        inferAppPathFromLegacyConfigValue(trimPathValue(config.appRootPath), 'source'),
+        inferAppPathFromLegacyConfigValue(trimPathValue(config.storagePath), 'storage'),
+    ].filter((value) => Boolean(value));
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const [first] = candidates;
+    if (!first) {
+        return undefined;
+    }
+    return candidates.every((candidate) => areConfiguredPathsEquivalent(candidate, first)) ? first : undefined;
+}
+export function resolveConfiguredAppPath(config, scope) {
+    const configuredAppPath = inferConfiguredAppPathFromLegacyConfig(config);
+    return configuredAppPath ? resolveConfiguredEnvPath(configuredAppPath, scope) : undefined;
+}
+export function resolveConfiguredSourcePath(config, scope) {
+    const legacySourcePath = trimPathValue(config.appRootPath);
+    if (legacySourcePath) {
+        return resolveConfiguredEnvPath(legacySourcePath, scope);
+    }
+    const appPath = resolveConfiguredAppPath(config, scope);
+    return appPath ? path.join(appPath, 'source') : undefined;
+}
+export function resolveConfiguredStoragePath(config, scope) {
+    const legacyStoragePath = trimPathValue(config.storagePath);
+    if (legacyStoragePath) {
+        return resolveConfiguredEnvPath(legacyStoragePath, scope);
+    }
+    const appPath = resolveConfiguredAppPath(config, scope);
+    return appPath ? path.join(appPath, 'storage') : undefined;
+}