@nocobase/cli 2.3.0-beta.6 → 2.4.0-alpha.1

package/dist/lib/env-auth.js

@@ -27,40 +27,6 @@ const DEFAULT_DEVICE_POLL_INTERVAL_SECONDS = 5;
 function normalizeBaseUrl(baseUrl) {
     return baseUrl.replace(/\/+$/, '');
 }
-function buildDeviceVerificationPathFromApiBaseUrl(apiBaseUrl) {
-    const url = new URL(apiBaseUrl);
-    const subappMatch = url.pathname.match(/^(.*)\/api\/__app\/([^/]+)\/?$/);
-    if (subappMatch) {
-        const publicPath = (subappMatch[1] || '').replace(/\/+$/, '');
-        return `${publicPath}/apps/${subappMatch[2]}/idpOAuth/device`;
-    }
-    const appMatch = url.pathname.match(/^(.*)\/api\/?$/);
-    if (appMatch) {
-        const publicPath = (appMatch[1] || '').replace(/\/+$/, '');
-        return `${publicPath}/idpOAuth/device`;
-    }
-    return undefined;
-}
-export function resolveDeviceVerificationUrlForApiBaseUrl(verificationUrl, apiBaseUrl) {
-    try {
-        const devicePath = buildDeviceVerificationPathFromApiBaseUrl(apiBaseUrl);
-        if (!devicePath) {
-            return verificationUrl;
-        }
-        const originalUrl = new URL(verificationUrl);
-        if (!originalUrl.pathname.endsWith('/idpOAuth/device')) {
-            return verificationUrl;
-        }
-        const publicUrl = new URL(apiBaseUrl);
-        publicUrl.pathname = devicePath;
-        publicUrl.search = originalUrl.search;
-        publicUrl.hash = originalUrl.hash;
-        return publicUrl.toString();
-    }
-    catch {
-        return verificationUrl;
-    }
-}
 export function getOauthMetadataUrl(baseUrl) {
     return `${normalizeBaseUrl(baseUrl)}/.well-known/oauth-authorization-server`;
 }
@@ -973,7 +939,7 @@ export async function resolveServerRequestTarget(options) {
                 : `Use --api-base-url or run \`nb init --ui --env ${envName}\` first.`,
         ].join('\n'));
     }
-    return { baseUrl, token };
+    return { baseUrl, token, envName };
 }
 export async function authenticateEnvWithBasic(options) {
     const envName = options.envName ?? (await getCurrentEnvName({ scope: options.scope }));
@@ -1051,7 +1017,7 @@ async function authenticateEnvWithOauthDevice(options) {
             baseUrl: options.baseUrl,
         });
         stopTask();
-        const verificationUrl = resolveDeviceVerificationUrlForApiBaseUrl(deviceAuthorization.verification_uri_complete || deviceAuthorization.verification_uri, options.baseUrl);
+        const verificationUrl = deviceAuthorization.verification_uri_complete || deviceAuthorization.verification_uri;
         const browser = await browserOpener(verificationUrl);
         cleanupBrowserOpenTarget = browser.cleanup;
         if (!browser.opened) {

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

@@ -19,6 +19,7 @@ export const ENV_STRING_CONFIG_FLAG_MAP = {
     'app-public-path': 'appPublicPath',
     'cdn-base-url': 'cdnBaseUrl',
     'env-file': 'envFile',
+    'app-client-entry-mode': 'appClientEntryMode',
     'app-port': 'appPort',
     'app-key': 'appKey',
     timezone: 'timezone',

package/dist/lib/env-config.js

@@ -6,8 +6,10 @@
  * 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 { normalizeAppClientEntryMode } from './app-client-entry-mode.js';
 import { normalizeEnvProxyConfig } from './env-proxy-config.js';
 import { resolveAppPublicPath } from './app-public-path.js';
+import { normalizeEnvPortalsConfig } from './env-portal-config.js';
 const STRING_ENV_CONFIG_KEYS = [
     'source',
     'downloadVersion',
@@ -36,6 +38,7 @@ const STRING_ENV_CONFIG_KEYS = [
     'dbSchema',
     'dbTablePrefix',
     'lang',
+    'portalTemplate',
     'rootUsername',
     'rootEmail',
     'rootPassword',
@@ -83,6 +86,10 @@ export function buildStoredEnvConfig(input) {
             envConfig[key] = key === 'appPublicPath' ? resolveAppPublicPath(value) : value;
         }
     }
+    const appClientEntryMode = normalizeAppClientEntryMode(input.appClientEntryMode);
+    if (appClientEntryMode) {
+        envConfig.appClientEntryMode = appClientEntryMode;
+    }
     const setupState = resolveSetupState(input.setupState);
     if (setupState) {
         envConfig.setupState = setupState;
@@ -115,5 +122,9 @@ export function buildStoredEnvConfig(input) {
     if (proxy) {
         envConfig.proxy = proxy;
     }
+    const portals = normalizeEnvPortalsConfig(input.portals);
+    if (portals) {
+        envConfig.portals = portals;
+    }
     return envConfig;
 }

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

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function readRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+export function normalizeEnvPortalsConfig(value) {
+    const input = readRecord(value);
+    const portals = {};
+    for (const [portal, rawEntry] of Object.entries(input)) {
+        const portalName = trimValue(portal);
+        if (!portalName) {
+            continue;
+        }
+        const entry = readRecord(rawEntry);
+        const portalPath = trimValue(entry.path);
+        if (portalPath) {
+            portals[portalName] = { path: portalPath };
+        }
+    }
+    return Object.keys(portals).length > 0 ? portals : undefined;
+}

package/dist/lib/env-proxy.js

@@ -20,9 +20,13 @@ const DEFAULT_API_BASE_PATH = '/api/';
 const DEFAULT_WS_PATH = '/ws';
 const DEFAULT_PLUGIN_STATICS_PATH = '/static/plugins/';
 const DEFAULT_MODERN_CLIENT_PREFIX = 'v';
+const SETTINGS_CLIENT_PREFIX = 'settings';
+const DEFAULT_APP_CLIENT_ENTRY_MODE = 'legacy-default';
+const APP_CLIENT_ENTRY_MODES = new Set(['legacy-default', 'modern-default', 'modern-only', 'settings-default']);
 const DEFAULT_API_CLIENT_STORAGE_PREFIX = 'NOCOBASE_';
 const DEFAULT_API_CLIENT_STORAGE_TYPE = 'localStorage';
 const DEFAULT_ESM_CDN_BASE_URL = 'https://esm.sh';
+const PORTAL_CLIENT_PREFIX = 'x';
 const LOCAL_APP_PACKAGE_JSON_PATH = 'node_modules/@nocobase/app/package.json';
 const MANAGED_PROXY_BLOCK_BEGIN = '# BEGIN NocoBase proxy';
 const MANAGED_PROXY_BLOCK_END = '# END NocoBase proxy';
@@ -66,7 +70,15 @@ function normalizeModernClientPrefix(value) {
     const segment = String(value || '')
         .trim()
         .replace(/^\/+|\/+$/g, '');
-    return segment || DEFAULT_MODERN_CLIENT_PREFIX;
+    const normalized = segment || DEFAULT_MODERN_CLIENT_PREFIX;
+    if (normalized === SETTINGS_CLIENT_PREFIX) {
+        throw new Error('APP_MODERN_CLIENT_PREFIX "settings" is reserved for the standalone Settings application.');
+    }
+    return normalized;
+}
+function normalizeAppClientEntryMode(value) {
+    const normalized = String(value || '').trim();
+    return APP_CLIENT_ENTRY_MODES.has(normalized) ? normalized : DEFAULT_APP_CLIENT_ENTRY_MODE;
 }
 function normalizeApiBasePath(value = DEFAULT_API_BASE_PATH) {
     return resolveAppPublicPath(value);
@@ -274,6 +286,7 @@ export async function loadEnvProxySettings(runtime, options) {
             wsPath: prefixRuntimePath(appPublicPath, envValues.WS_PATH || DEFAULT_WS_PATH),
             pluginStaticsPath: prefixRuntimePath(appPublicPath, envValues.PLUGIN_STATICS_PATH || DEFAULT_PLUGIN_STATICS_PATH, { trailingSlash: true }),
             modernClientPrefix: normalizeModernClientPrefix(envValues.APP_MODERN_CLIENT_PREFIX),
+            appClientEntryMode: normalizeAppClientEntryMode(envValues.APP_CLIENT_ENTRY_MODE),
             cdnBaseUrl: trimValue(options?.cdnBaseUrl) ??
                 trimValue(runtime.env.envVars?.CDN_BASE_URL) ??
                 trimValue(envValues.CDN_BASE_URL),
@@ -298,7 +311,8 @@ function createManualProxyEnvSettings(input) {
         pluginStaticsPath: prefixRuntimePath(appPublicPath, DEFAULT_PLUGIN_STATICS_PATH, {
             trailingSlash: true,
         }),
-        modernClientPrefix: DEFAULT_MODERN_CLIENT_PREFIX,
+        modernClientPrefix: normalizeModernClientPrefix(process.env.APP_MODERN_CLIENT_PREFIX),
+        appClientEntryMode: normalizeAppClientEntryMode(process.env.APP_CLIENT_ENTRY_MODE),
         cdnBaseUrl: trimValue(input.cdnBaseUrl),
         apiClientStoragePrefix: DEFAULT_API_CLIENT_STORAGE_PREFIX,
         apiClientStorageType: DEFAULT_API_CLIENT_STORAGE_TYPE,
@@ -490,6 +504,9 @@ function buildNginxManagedConfigBlock(context) {
     const apiBasePathNoTrailingSlash = trimTrailingSlash(context.apiBasePath);
     const appPublicPathNoTrailingSlash = trimTrailingSlash(context.appPublicPath);
     const fileAccessPath = `${context.appPublicPath}files/`;
+    const settingsAssetsPath = `${context.appPublicPath}settings/assets/`;
+    const settingsAssetsRoot = joinRuntimePath(context.distRootDir, `${context.activeVersion}/settings/assets`);
+    const settingsRoutePattern = `^${escapeRegExp(context.appPublicPath)}settings(?:/|$)`;
     const isRootMounted = context.appPublicPath === '/';
     const appPublicPathRedirectBlock = isRootMounted
         ? ''
@@ -541,6 +558,8 @@ function buildNginxManagedConfigBlock(context) {
             ]
             : []),
         '',
+        buildNginxPortalLocationBlock(context),
+        '',
         `    location = ${apiBasePathNoTrailingSlash} {`,
         `        return 308 ${context.apiBasePath}$is_args$args;`,
         '    }',
@@ -560,13 +579,24 @@ function buildNginxManagedConfigBlock(context) {
         `        return 302 ${context.v2PublicPath}$is_args$args;`,
         '    }',
         '',
+        `    location ^~ ${settingsAssetsPath} {`,
+        `        alias ${settingsAssetsRoot}/;`,
+        `        include ${context.snippetsDir}/dist-location.conf;`,
+        '    }',
+        '',
+        `    location ~ ${settingsRoutePattern} {`,
+        `        root ${context.publicDir};`,
+        `        try_files $uri /index-settings.html =404;`,
+        `        include ${context.snippetsDir}/spa-location.conf;`,
+        '    }',
+        '',
         `    location ^~ ${context.v2PublicPath} {`,
         `        alias ${context.publicDir}/;`,
         `        try_files $uri /index-v2.html =404;`,
         `        include ${context.snippetsDir}/spa-location.conf;`,
         '    }',
         '',
-        `    location ^~ ${context.appPublicPath} {`,
+        `    location ${context.appPublicPath} {`,
         `        alias ${context.publicDir}/;`,
         `        try_files $uri /index-v1.html =404;`,
         `        include ${context.snippetsDir}/spa-location.conf;`,
@@ -575,11 +605,83 @@ function buildNginxManagedConfigBlock(context) {
         `    ${MANAGED_NGINX_CONFIG_BLOCK_END}`,
     ].join('\n');
 }
+function buildPortalRootPublicPath(appPublicPath) {
+    return appPublicPath === DEFAULT_APP_PUBLIC_PATH
+        ? `/${PORTAL_CLIENT_PREFIX}/`
+        : `${trimTrailingSlash(appPublicPath)}/${PORTAL_CLIENT_PREFIX}/`;
+}
+function buildNginxPortalLocationBlock(context) {
+    const portalBasePath = trimTrailingSlash(buildPortalRootPublicPath(context.appPublicPath));
+    const portalBasePathPattern = escapeRegExp(portalBasePath);
+    return [
+        `    location = ${portalBasePath} {`,
+        '        absolute_redirect off;',
+        `        return 302 ${context.v2PublicPath}$is_args$args;`,
+        '    }',
+        '',
+        `    location = ${portalBasePath}/ {`,
+        '        absolute_redirect off;',
+        `        return 302 ${context.v2PublicPath}$is_args$args;`,
+        '    }',
+        '',
+        `    location ^~ ${portalBasePath}/apps/ {`,
+        '        absolute_redirect off;',
+        `        if ($uri ~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/?$) {`,
+        `            return 302 ${context.v2PublicPath}apps/$subapp/$is_args$args;`,
+        '        }',
+        '',
+        `        if ($uri ~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)$) {`,
+        `            return 308 ${portalBasePath}/apps/$subapp/$portal/$is_args$args;`,
+        '        }',
+        '',
+        `        if ($uri !~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)/(?<portal_path>.*)$) {`,
+        '            return 404;',
+        '        }',
+        '',
+        `        root ${context.storageDir};`,
+        '',
+        '        if ($portal_path = "") {',
+        '            rewrite ^ /portals/$subapp/$portal/dist/index.html break;',
+        '        }',
+        '',
+        '        try_files',
+        '            /portals/$subapp/$portal/dist/$portal_path',
+        '            /portals/$subapp/$portal/dist/$portal_path/',
+        '            /portals/$subapp/$portal/dist/index.html',
+        '            =404;',
+        '    }',
+        '',
+        `    location ^~ ${portalBasePath}/ {`,
+        '        absolute_redirect off;',
+        `        if ($uri ~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)$) {`,
+        `            return 308 ${portalBasePath}/$portal/$is_args$args;`,
+        '        }',
+        '',
+        `        if ($uri !~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)/(?<portal_path>.*)$) {`,
+        '            return 404;',
+        '        }',
+        '',
+        `        root ${context.storageDir};`,
+        '',
+        '        if ($portal_path = "") {',
+        '            rewrite ^ /portals/main/$portal/dist/index.html break;',
+        '        }',
+        '',
+        '        try_files',
+        '            /portals/main/$portal/dist/$portal_path',
+        '            /portals/main/$portal/dist/$portal_path/',
+        '            /portals/main/$portal/dist/index.html',
+        '            =404;',
+        '    }',
+        '',
+    ].join('\n');
+}
 function buildNginxRuntimeConfig(context, variant) {
     return {
         __webpack_public_path__: context.cdnBaseUrl,
-        __nocobase_public_path__: variant === 'v1' ? context.appPublicPath : context.v2PublicPath,
-        ...(variant === 'v2' ? { __nocobase_modern_client_prefix__: context.modernClientPrefix } : {}),
+        __nocobase_public_path__: variant === 'v2' ? context.v2PublicPath : context.appPublicPath,
+        ...(variant !== 'v1' ? { __nocobase_modern_client_prefix__: context.modernClientPrefix } : {}),
+        __nocobase_app_client_entry_mode__: context.appClientEntryMode,
         __nocobase_api_base_url__: context.apiBasePath,
         __nocobase_api_client_storage_prefix__: context.apiClientStoragePrefix,
         __nocobase_api_client_storage_type__: context.apiClientStorageType,
@@ -608,6 +710,7 @@ async function buildEnvProxyNginxRenderContext(source, options) {
     const mappedPublicDir = await mapProxyPathFromCliRoot(publicDir, options);
     const mappedSnippetsDir = await mapProxyPathFromCliRoot(snippetsDir, options);
     const mappedDistRootDir = await mapProxyPathFromCliRoot(distRootDir, options);
+    const mappedStorageDir = await mapProxyPathFromCliRoot(source.storagePath, options);
     const mappedUploadsDir = await mapProxyPathFromCliRoot(uploadsDir, options);
     const v2PublicPath = `${source.settings.appPublicPath.replace(/\/$/, '')}/${source.settings.modernClientPrefix}/`;
     return {
@@ -629,9 +732,12 @@ async function buildEnvProxyNginxRenderContext(source, options) {
         esmCdnSuffix: source.settings.esmCdnSuffix,
         indexV1Path: await mapProxyPathFromCliRoot(resolveEnvProxyNginxIndexOutputPath(source.envName, 'v1', { scope: options?.scope }), options),
         indexV2Path: await mapProxyPathFromCliRoot(resolveEnvProxyNginxIndexOutputPath(source.envName, 'v2', { scope: options?.scope }), options),
+        indexSettingsPath: await mapProxyPathFromCliRoot(resolveEnvProxyNginxIndexOutputPath(source.envName, 'settings', { scope: options?.scope }), options),
         modernClientPrefix: source.settings.modernClientPrefix,
+        appClientEntryMode: source.settings.appClientEntryMode,
         proxyHost,
         snippetsDir: mappedSnippetsDir,
+        storageDir: mappedStorageDir,
         uploadsDir: mappedUploadsDir,
         v2PublicPath,
         wsPath: source.settings.wsPath,
@@ -747,16 +853,20 @@ async function buildNginxBundleFromSource(source, options) {
     const mainTemplate = await readEnvProxyNginxAssetText('nocobase.conf.tpl');
     const sourceIndexV1Path = path.join(source.distRootPath, context.activeVersion, 'index.html');
     const sourceIndexV2Path = path.join(source.distRootPath, context.activeVersion, DEFAULT_MODERN_CLIENT_PREFIX, 'index.html');
-    const [sourceIndexV1Content, sourceIndexV2Content] = await Promise.all([
+    const sourceIndexSettingsPath = path.join(source.distRootPath, context.activeVersion, 'settings', 'index.html');
+    const [sourceIndexV1Content, sourceIndexV2Content, sourceIndexSettingsContent] = await Promise.all([
         readFile(sourceIndexV1Path, 'utf8'),
         readFile(sourceIndexV2Path, 'utf8'),
+        readFile(sourceIndexSettingsPath, 'utf8'),
     ]);
     const v1RuntimeScript = buildRuntimeConfigScriptTag(buildNginxRuntimeConfig(context, 'v1'));
     const v2RuntimeScript = buildRuntimeConfigScriptTag(buildNginxRuntimeConfig(context, 'v2'));
+    const settingsRuntimeScript = buildRuntimeConfigScriptTag(buildNginxRuntimeConfig(context, 'settings'));
     const sourceV1PublicPath = extractRuntimePublicPath(sourceIndexV1Content);
     const sourceV2PublicPath = extractRuntimePublicPath(sourceIndexV2Content);
     const indexV1AssetPublicPath = context.cdnBaseUrl;
     const indexV2AssetPublicPath = `${trimTrailingSlash(context.cdnBaseUrl)}/${DEFAULT_MODERN_CLIENT_PREFIX}/`;
+    const indexSettingsAssetPublicPath = `${trimTrailingSlash(context.cdnBaseUrl)}/settings/`;
     const appConfigIncludePath = await mapProxyPathFromCliRoot(path.join(resolveEnvProxyProviderRootDir('nginx', { scope: options?.scope }), '*', resolveEnvProxyFileSpec('nginx').appFilename), options);
     const managedConfigBlock = buildNginxManagedConfigBlock(context);
     const templateValues = {
@@ -780,6 +890,7 @@ async function buildNginxBundleFromSource(source, options) {
         appConfigPath: resolveEnvProxyAppOutputPath(source.envName, { scope: options?.scope, provider: 'nginx' }),
         indexV1Path: resolveEnvProxyNginxIndexOutputPath(source.envName, 'v1', { scope: options?.scope }),
         indexV2Path: resolveEnvProxyNginxIndexOutputPath(source.envName, 'v2', { scope: options?.scope }),
+        indexSettingsPath: resolveEnvProxyNginxIndexOutputPath(source.envName, 'settings', { scope: options?.scope }),
         mainConfigPath: resolveEnvProxyMainOutputPath({ scope: options?.scope, provider: 'nginx' }),
         snippetsDir: resolveEnvProxyNginxSnippetsOutputDir({ scope: options?.scope }),
         appPublicPath: context.appPublicPath,
@@ -797,6 +908,7 @@ async function buildNginxBundleFromSource(source, options) {
         }),
         indexV1Content: injectRuntimeScriptIntoHtml(rewriteHtmlAssetPublicPath(sourceIndexV1Content, sourceV1PublicPath, indexV1AssetPublicPath), v1RuntimeScript),
         indexV2Content: injectRuntimeScriptIntoHtml(rewriteHtmlAssetPublicPath(sourceIndexV2Content, sourceV2PublicPath, indexV2AssetPublicPath), v2RuntimeScript),
+        indexSettingsContent: injectRuntimeScriptIntoHtml(rewriteHtmlAssetPublicPath(sourceIndexSettingsContent, '/settings/', indexSettingsAssetPublicPath), settingsRuntimeScript),
     };
 }
 export async function buildEnvProxyCaddyBundle(runtime, options) {
@@ -813,21 +925,26 @@ async function buildCaddyBundleFromSource(source, options) {
     const context = await buildEnvProxyCaddyRenderContextFromSource(source, options);
     const sourceIndexV1Path = path.join(source.distRootPath, context.activeVersion, 'index.html');
     const sourceIndexV2Path = path.join(source.distRootPath, context.activeVersion, DEFAULT_MODERN_CLIENT_PREFIX, 'index.html');
-    const [sourceIndexV1Content, sourceIndexV2Content] = await Promise.all([
+    const sourceIndexSettingsPath = path.join(source.distRootPath, context.activeVersion, 'settings', 'index.html');
+    const [sourceIndexV1Content, sourceIndexV2Content, sourceIndexSettingsContent] = await Promise.all([
         readFile(sourceIndexV1Path, 'utf8'),
         readFile(sourceIndexV2Path, 'utf8'),
+        readFile(sourceIndexSettingsPath, 'utf8'),
     ]);
     const v1RuntimeScript = buildRuntimeConfigScriptTag(buildCaddyRuntimeConfig(context, 'v1'));
     const v2RuntimeScript = buildRuntimeConfigScriptTag(buildCaddyRuntimeConfig(context, 'v2'));
+    const settingsRuntimeScript = buildRuntimeConfigScriptTag(buildCaddyRuntimeConfig(context, 'settings'));
     const sourceV1PublicPath = extractRuntimePublicPath(sourceIndexV1Content);
     const sourceV2PublicPath = extractRuntimePublicPath(sourceIndexV2Content);
     const indexV1AssetPublicPath = context.cdnBaseUrl;
     const indexV2AssetPublicPath = `${trimTrailingSlash(context.cdnBaseUrl)}/${DEFAULT_MODERN_CLIENT_PREFIX}/`;
+    const indexSettingsAssetPublicPath = `${trimTrailingSlash(context.cdnBaseUrl)}/settings/`;
     const appConfigPath = resolveEnvProxyAppOutputPath(source.envName, { scope: options?.scope, provider: 'caddy' });
     const entryDir = resolveEnvProxyEntryDir(source.envName, { scope: options?.scope, provider: 'caddy' });
     const publicDir = resolveEnvProxyCaddyPublicOutputDir(source.envName, { scope: options?.scope });
     const renderedPublicDir = await mapProxyPathFromCliRoot(publicDir, { ...options, provider: 'caddy' });
     const appConfigContent = renderCaddyAppTemplate(buildCaddySiteAddress(), {
+        activeVersion: context.activeVersion,
         appPublicPath: context.appPublicPath,
         apiBasePath: context.apiBasePath,
         apiPort: context.apiPort,
@@ -848,6 +965,7 @@ async function buildCaddyBundleFromSource(source, options) {
         appConfigPath,
         indexV1Path: resolveEnvProxyCaddyIndexOutputPath(source.envName, 'v1', { scope: options?.scope }),
         indexV2Path: resolveEnvProxyCaddyIndexOutputPath(source.envName, 'v2', { scope: options?.scope }),
+        indexSettingsPath: resolveEnvProxyCaddyIndexOutputPath(source.envName, 'settings', { scope: options?.scope }),
         mainConfigPath: resolveEnvProxyMainOutputPath({ scope: options?.scope, provider: 'caddy' }),
         appPublicPath: context.appPublicPath,
         apiBasePath: context.apiBasePath,
@@ -861,6 +979,7 @@ async function buildCaddyBundleFromSource(source, options) {
         mainConfigContent: await buildEnvProxyMainConfig({ provider: 'caddy', scope: options?.scope }),
         indexV1Content: injectRuntimeScriptIntoHtml(rewriteHtmlAssetPublicPath(sourceIndexV1Content, sourceV1PublicPath, indexV1AssetPublicPath), v1RuntimeScript),
         indexV2Content: injectRuntimeScriptIntoHtml(rewriteHtmlAssetPublicPath(sourceIndexV2Content, sourceV2PublicPath, indexV2AssetPublicPath), v2RuntimeScript),
+        indexSettingsContent: injectRuntimeScriptIntoHtml(rewriteHtmlAssetPublicPath(sourceIndexSettingsContent, '/settings/', indexSettingsAssetPublicPath), settingsRuntimeScript),
     };
 }
 async function pathExists(candidate) {
@@ -1115,10 +1234,14 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
     const uploadsPath = `${context.appPublicPath}storage/uploads/`;
     const fileAccessPathMatcher = toCaddyPathMatcher(`${context.appPublicPath}files/`);
     const distPathMatcher = toCaddyPathMatcher(context.distPath);
+    const settingsAssetsPathMatcher = toCaddyPathMatcher(`${context.appPublicPath}settings/assets/`);
+    const settingsAssetsRoot = joinRuntimePath(context.distClientRoot, `${context.activeVersion}/settings/assets`);
+    const settingsRoutePattern = `^${escapeRegExp(context.appPublicPath)}settings(?:/.*)?$`;
     const uploadsPathMatcher = toCaddyPathMatcher(uploadsPath);
     const apiPathMatcher = toCaddyPathMatcher(context.apiBasePath);
     const appPublicPathNoTrailingSlash = trimTrailingSlash(context.appPublicPath);
     const v2PublicPathNoTrailingSlash = trimTrailingSlash(context.v2PublicPath);
+    const portalBasePath = trimTrailingSlash(buildPortalRootPublicPath(context.appPublicPath));
     const rootRedirectBlock = context.appPublicPath === DEFAULT_APP_PUBLIC_PATH
         ? ''
         : `
@@ -1172,6 +1295,12 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
         '        file_server',
         '    }',
         '',
+        `    handle_path ${settingsAssetsPathMatcher} {`,
+        `        root * ${settingsAssetsRoot}`,
+        '        header Cache-Control "public, max-age=31536000, immutable"',
+        '        file_server',
+        '    }',
+        '',
         '    @oauth path_regexp oauth ^/\\.well-known/oauth-authorization-server/(.+)$',
         '    handle @oauth {',
         '        rewrite * /{re.oauth.1}/.well-known/oauth-authorization-server',
@@ -1205,6 +1334,23 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
         `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
         '    }',
         '',
+        `    handle ${portalBasePath} {`,
+        `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
+        '    }',
+        '',
+        `    handle ${portalBasePath}/* {`,
+        `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
+        '    }',
+        '',
+        `    @settingsRoute path_regexp settingsRoute ${settingsRoutePattern}`,
+        '    handle @settingsRoute {',
+        `        root * ${publicDir}`,
+        '        header Cache-Control "no-store, no-cache, must-revalidate"',
+        '        header X-Robots-Tag "noindex, nofollow"',
+        '        try_files {path} /index-settings.html',
+        '        file_server',
+        '    }',
+        '',
         '    # Keep the v2 SPA route above the fallback SPA route.',
         `    handle_path ${toCaddyPathMatcher(context.v2PublicPath)} {`,
         `        root * ${publicDir}`,
@@ -1277,6 +1423,7 @@ async function buildEnvProxyRenderState(runtime, options) {
         : await mapProxyPathFromCliRoot(distClientRoot, options);
     const provider = resolveProxyProviderName(options?.provider);
     const templateContext = {
+        activeVersion: runtimeVersion,
         appPublicPath: settings.appPublicPath,
         apiBasePath: settings.apiBasePath,
         apiPort,

package/dist/lib/managed-env-file.js

@@ -6,18 +6,30 @@
  * 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 { readFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { normalizeAppClientEntryMode } from './app-client-entry-mode.js';
+import { resolveEnvKind } from './auth-store.js';
 import { resolveConfiguredEnvPath } from './cli-home.js';
-import { resolveDockerEnvFileArg } from "./docker-env-file.js";
+import { resolveDockerEnvFileArg, resolveDockerEnvFilePath } from "./docker-env-file.js";
 import { resolveConfiguredAppPath } from './env-paths.js';
+export const DEFAULT_MANAGED_ENV_FILE_VALUES = {
+    APP_DISCOVERY_ADAPTER: 'local',
+    APP_PROCESS_ADAPTER: 'local',
+    APP_CLIENT_ENTRY_MODE: 'modern-only',
+};
+function buildManagedEnvFileDefaults(config, defaults = DEFAULT_MANAGED_ENV_FILE_VALUES) {
+    return {
+        ...defaults,
+        APP_CLIENT_ENTRY_MODE: normalizeAppClientEntryMode(config?.appClientEntryMode) ??
+            trimValue(defaults.APP_CLIENT_ENTRY_MODE) ??
+            DEFAULT_MANAGED_ENV_FILE_VALUES.APP_CLIENT_ENTRY_MODE,
+    };
+}
 function trimValue(value) {
     const text = String(value ?? '').trim();
     return text || undefined;
 }
-function normalizeEnvFilePath(value) {
-    return value.replace(/\\/g, '/');
-}
 function stripWrappingQuotes(value) {
     if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
         return value
@@ -33,6 +45,29 @@ function stripWrappingQuotes(value) {
     }
     return value;
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function upsertSimpleEnvContent(content, values) {
+    let nextContent = content;
+    const missingEntries = new Map(Object.entries(values).filter(([, value]) => trimValue(value)));
+    for (const key of Array.from(missingEntries.keys())) {
+        const pattern = new RegExp(`^\\s*(?:export\\s+)?${escapeRegExp(key)}\\s*=.*$`, 'gm');
+        if (!pattern.test(nextContent)) {
+            continue;
+        }
+        nextContent = nextContent.replace(pattern, `${key}=${values[key]}`);
+        missingEntries.delete(key);
+    }
+    if (missingEntries.size === 0) {
+        return nextContent;
+    }
+    const separator = nextContent && !nextContent.endsWith('\n') ? '\n' : '';
+    const appended = Array.from(missingEntries.entries())
+        .map(([key, value]) => `${key}=${value}`)
+        .join('\n');
+    return `${nextContent}${separator}${appended}\n`;
+}
 export function parseSimpleEnvFile(content) {
     const values = {};
     for (const rawLine of content.split(/\r?\n/)) {
@@ -57,16 +92,91 @@ export function resolveManagedLocalEnvFilePath(runtime) {
     const config = runtime.env.config ?? {};
     const explicitEnvFile = trimValue(config.envFile);
     if (explicitEnvFile) {
-        return normalizeEnvFilePath(resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile);
+        return resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile;
     }
     const configuredAppPath = resolveConfiguredAppPath(config);
     if (configuredAppPath) {
-        return normalizeEnvFilePath(path.join(configuredAppPath, '.env'));
+        return path.join(configuredAppPath, '.env');
     }
     if (path.basename(runtime.projectRoot) === 'source') {
-        return normalizeEnvFilePath(path.resolve(runtime.projectRoot, '..', '.env'));
+        return path.resolve(runtime.projectRoot, '..', '.env');
+    }
+    return path.join(runtime.projectRoot, '.env');
+}
+export function resolveManagedEnvFilePathFromConfig(envName, config) {
+    const kind = config?.kind ?? resolveEnvKind(config);
+    if (kind === 'docker') {
+        return resolveDockerEnvFilePath(envName, config);
+    }
+    if (kind !== 'local') {
+        return undefined;
+    }
+    const explicitEnvFile = trimValue(config?.envFile);
+    if (explicitEnvFile) {
+        return resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile;
+    }
+    const configuredAppPath = resolveConfiguredAppPath(config);
+    if (configuredAppPath) {
+        return path.join(configuredAppPath, '.env');
+    }
+    const configuredAppRootPath = trimValue(config?.appRootPath);
+    if (configuredAppRootPath) {
+        const appRootPath = resolveConfiguredEnvPath(configuredAppRootPath) ?? configuredAppRootPath;
+        return path.basename(appRootPath) === 'source'
+            ? path.resolve(appRootPath, '..', '.env')
+            : path.join(appRootPath, '.env');
+    }
+    return undefined;
+}
+export async function ensureManagedEnvFileDefaults(envName, config, defaults = DEFAULT_MANAGED_ENV_FILE_VALUES) {
+    const envFilePath = resolveManagedEnvFilePathFromConfig(envName, config);
+    if (!envFilePath) {
+        return undefined;
+    }
+    let content = '';
+    try {
+        content = await readFile(envFilePath, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const existing = parseSimpleEnvFile(content);
+    const resolvedDefaults = buildManagedEnvFileDefaults(config, defaults);
+    const missingEntries = Object.entries(resolvedDefaults).filter(([key, value]) => trimValue(value) && !existing[key]);
+    if (missingEntries.length === 0) {
+        return envFilePath;
+    }
+    const separator = content && !content.endsWith('\n') ? '\n' : '';
+    const nextContent = `${content}${separator}${missingEntries.map(([key, value]) => `${key}=${value}`).join('\n')}\n`;
+    await mkdir(path.dirname(envFilePath), { recursive: true });
+    await writeFile(envFilePath, nextContent, 'utf8');
+    return envFilePath;
+}
+export async function upsertManagedEnvFileValues(envName, config, values) {
+    const envFilePath = resolveManagedEnvFilePathFromConfig(envName, config);
+    if (!envFilePath) {
+        return undefined;
+    }
+    let content = '';
+    try {
+        content = await readFile(envFilePath, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const nextContent = upsertSimpleEnvContent(content, values);
+    if (nextContent === content) {
+        return envFilePath;
     }
-    return normalizeEnvFilePath(path.join(runtime.projectRoot, '.env'));
+    await mkdir(path.dirname(envFilePath), { recursive: true });
+    await writeFile(envFilePath, nextContent, 'utf8');
+    return envFilePath;
 }
 export async function resolveManagedRuntimeEnvFilePath(runtime) {
     if (runtime.kind === 'local') {

package/dist/lib/managed-init-env.js

@@ -15,7 +15,7 @@ export function resolveManagedSetupState(value) {
 export function isPreparedSetupState(value) {
     return resolveManagedSetupState(value) === 'prepared';
 }
-export function buildInitAppEnvVarsFromConfig(config) {
+export function buildInitAppEnvVarsFromConfig(config, options = {}) {
     const out = {};
     const put = (key, value) => {
         const text = trimValue(value);
@@ -28,5 +28,8 @@ export function buildInitAppEnvVarsFromConfig(config) {
     put('INIT_ROOT_EMAIL', config?.rootEmail);
     put('INIT_ROOT_PASSWORD', config?.rootPassword);
     put('INIT_ROOT_NICKNAME', config?.rootNickname);
+    if (options.includePortal !== false) {
+        put('INIT_PORTAL_TEMPLATE', config?.portalTemplate);
+    }
     return out;
 }