@nocobase/cli 2.3.0-alpha.1 → 3.0.0-alpha.2

package/dist/lib/env-config.js

@@ -36,6 +36,9 @@ const STRING_ENV_CONFIG_KEYS = [
     'dbSchema',
     'dbTablePrefix',
     'lang',
+    'portalType',
+    'portalName',
+    'portalTemplate',
     'rootUsername',
     'rootEmail',
     'rootPassword',

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']);
 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,71 @@ function buildNginxManagedConfigBlock(context) {
         `    ${MANAGED_NGINX_CONFIG_BLOCK_END}`,
     ].join('\n');
 }
+function buildNginxPortalRootPublicPath(appPublicPath) {
+    return appPublicPath === DEFAULT_APP_PUBLIC_PATH
+        ? `/${PORTAL_CLIENT_PREFIX}/`
+        : `${trimTrailingSlash(appPublicPath)}/${PORTAL_CLIENT_PREFIX}/`;
+}
+function buildNginxPortalLocationBlock(context) {
+    const portalBasePath = trimTrailingSlash(buildNginxPortalRootPublicPath(context.appPublicPath));
+    const portalBasePathPattern = escapeRegExp(portalBasePath);
+    return [
+        `    location ^~ ${portalBasePath}/apps/ {`,
+        '        absolute_redirect off;',
+        '',
+        `        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 +698,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 +720,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 +841,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 +878,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 +896,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 +913,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 +953,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 +967,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) {
@@ -1015,15 +1122,17 @@ function renderNginxLocationTemplate(context) {
         default_type text/markdown;
         add_header Cache-Control "public";
         add_header Content-Disposition "inline";
+        add_header Content-Security-Policy "sandbox" always;
         add_header X-Content-Type-Options "nosniff" always;
         access_log off;
         autoindex off;
     }
 
-    location ~* ^${context.appPublicPath}storage/uploads/(.*\\.(?:htm|html|svg|svgz|xhtml|pdf))$ {
+    location ~* ^${context.appPublicPath}storage/uploads/(.*\\.(?:htm|html|pdf|svg|svgz|xht|xhtml|xml|xsl|xslt))$ {
         alias ${context.uploadsPath}/$1;
         add_header Cache-Control "public";
         add_header Content-Disposition "attachment" always;
+        add_header Content-Security-Policy "sandbox" always;
         add_header X-Content-Type-Options "nosniff" always;
         access_log off;
         autoindex off;
@@ -1032,6 +1141,7 @@ function renderNginxLocationTemplate(context) {
     location ${context.appPublicPath}storage/uploads/ {
         alias ${context.uploadsPath}/;
         add_header Cache-Control "public";
+        add_header Content-Security-Policy "sandbox" always;
         add_header X-Content-Type-Options "nosniff" always;
         access_log off;
         autoindex off;
@@ -1112,6 +1222,9 @@ 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);
@@ -1152,10 +1265,14 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
         `${siteAddress} {`,
         `    encode zstd gzip${rootRedirectBlock}${appPublicPathRedirectBlock}${modernClientRedirectBlock}${shorthandModernClientRedirectBlock}`,
         '',
+        '    @activeUploadedContent path_regexp activeUploadedContent (?i)\\.(?:htm|html|pdf|svg|svgz|xht|xhtml|xml|xsl|xslt)$',
+        '',
         `    handle_path ${uploadsPathMatcher} {`,
         `        root * ${context.uploadsPath}`,
         '        header Cache-Control public',
+        '        header Content-Security-Policy sandbox',
         '        header X-Content-Type-Options nosniff',
+        '        header @activeUploadedContent Content-Disposition attachment',
         '        file_server',
         '    }',
         '',
@@ -1165,6 +1282,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',
@@ -1198,6 +1321,15 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
         `        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}`,
@@ -1270,6 +1402,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,11 +6,17 @@
  * 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 { 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 trimValue(value) {
     const text = String(value ?? '').trim();
     return text || undefined;
@@ -68,6 +74,56 @@ export function resolveManagedLocalEnvFilePath(runtime) {
     }
     return normalizeEnvFilePath(path.join(runtime.projectRoot, '.env'));
 }
+export function resolveManagedEnvFilePathFromConfig(envName, config) {
+    const kind = config?.kind ?? resolveEnvKind(config);
+    if (kind === 'docker') {
+        const filePath = resolveDockerEnvFilePath(envName, config);
+        return filePath ? normalizeEnvFilePath(filePath) : undefined;
+    }
+    if (kind !== 'local') {
+        return undefined;
+    }
+    const explicitEnvFile = trimValue(config?.envFile);
+    if (explicitEnvFile) {
+        return normalizeEnvFilePath(resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile);
+    }
+    const configuredAppPath = resolveConfiguredAppPath(config);
+    if (configuredAppPath) {
+        return normalizeEnvFilePath(path.join(configuredAppPath, '.env'));
+    }
+    const configuredAppRootPath = trimValue(config?.appRootPath);
+    if (configuredAppRootPath) {
+        const appRootPath = resolveConfiguredEnvPath(configuredAppRootPath) ?? configuredAppRootPath;
+        return normalizeEnvFilePath(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 missingEntries = Object.entries(defaults).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 resolveManagedRuntimeEnvFilePath(runtime) {
     if (runtime.kind === 'local') {
         return resolveManagedLocalEnvFilePath(runtime);

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,10 @@ 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_TYPE', config?.portalType);
+        put('INIT_PORTAL_NAME', config?.portalName);
+        put('INIT_PORTAL_TEMPLATE', config?.portalTemplate);
+    }
     return out;
 }

package/dist/lib/naming.js

@@ -1,6 +1,15 @@
+/**
+ * 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';
 export function toKebabCase(value) {
     return value
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
         .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
         .replace(/[^a-zA-Z0-9]+/g, '-')
         .replace(/-+/g, '-')

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

@@ -0,0 +1,31 @@
+/**
+ * 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 PORTAL_COMMAND_BASE_ENV_KEYS = [
+    'PATH',
+    'Path',
+    'PATHEXT',
+    'SystemRoot',
+    'WINDIR',
+    'ComSpec',
+    'HOME',
+    'USERPROFILE',
+    'TMPDIR',
+    'TEMP',
+    'TMP',
+];
+export function buildPortalCommandEnv(env = {}) {
+    const out = {};
+    for (const key of PORTAL_COMMAND_BASE_ENV_KEYS) {
+        const value = process.env[key];
+        if (value) {
+            out[key] = value;
+        }
+    }
+    return { ...out, ...env };
+}

package/dist/lib/portal-config.js

@@ -0,0 +1,133 @@
+/**
+ * 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 { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+export const DEFAULT_PORTAL_GIT_PATH = '.';
+const portalConfigText = (key, values, fallback) => translateCli(`commands.portalConfig.${key}`, values, { fallback });
+const UPDATE_PORTAL_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:update',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'filterByTk',
+            flagName: 'filterByTk',
+            in: 'query',
+            required: true,
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function readObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function validatePortalSourceStorage(value) {
+    const sourceStorage = trimValue(value) || 'nocobase';
+    if (sourceStorage === 'nocobase' || sourceStorage === 'git') {
+        return sourceStorage;
+    }
+    throw new Error(portalConfigText('errors.invalidSourceStorage', { value: sourceStorage }, `Invalid source storage "${sourceStorage}". Use "nocobase" or "git".`));
+}
+function isFullGitRemoteUrl(value) {
+    return /^(?:https?:\/\/|ssh:\/\/|file:\/\/|git@[^:]+:).+/.test(value);
+}
+function validateGitPath(value) {
+    const gitPath = trimValue(value);
+    if (!gitPath || path.isAbsolute(gitPath) || gitPath.split(/[\\/]+/).includes('..')) {
+        throw new Error(portalConfigText('errors.invalidGitPath', { value }, '--git-path must be a relative path inside the Git repository.'));
+    }
+    return gitPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+}
+export function buildPortalConfig(options) {
+    const sourceStorage = validatePortalSourceStorage(options.sourceStorage ?? options.existingConfig?.sourceStorage);
+    const hasGitOption = Boolean(trimValue(options.gitRepo) || trimValue(options.gitBranch) || trimValue(options.gitPath));
+    if (sourceStorage === 'nocobase') {
+        if (hasGitOption) {
+            throw new Error(portalConfigText('errors.gitOptionsForNocobaseStorage', undefined, '--git-repo, --git-branch, and --git-path can only be used with --source-storage git.'));
+        }
+        return { sourceStorage };
+    }
+    const repo = trimValue(options.gitRepo) || options.existingConfig?.git?.repo || '';
+    if (!repo) {
+        throw new Error(portalConfigText('errors.gitRepoRequired', undefined, '--git-repo is required when --source-storage is git.'));
+    }
+    if (!isFullGitRemoteUrl(repo)) {
+        throw new Error(portalConfigText('errors.gitRepoInvalid', undefined, '--git-repo must be a full Git remote URL.'));
+    }
+    return {
+        sourceStorage,
+        git: {
+            repo,
+            branch: trimValue(options.gitBranch) || options.existingConfig?.git?.branch || 'main',
+            path: validateGitPath(trimValue(options.gitPath) || options.existingConfig?.git?.path || DEFAULT_PORTAL_GIT_PATH),
+        },
+    };
+}
+export function buildPortalConfigFromOptions(options, portal) {
+    const sourceOptions = readObject(options);
+    const git = readObject(sourceOptions.git);
+    return buildPortalConfig({
+        portal,
+        sourceStorage: trimValue(sourceOptions.sourceStorage) || 'nocobase',
+        gitRepo: trimValue(git.repo),
+        gitBranch: trimValue(git.branch),
+        gitPath: trimValue(git.path),
+    });
+}
+export function mergePortalConfigIntoOptions(config, currentOptions) {
+    const nextOptions = {
+        ...(currentOptions ?? {}),
+        sourceStorage: config.sourceStorage,
+    };
+    if (config.sourceStorage === 'git') {
+        nextOptions.git = config.git;
+    }
+    else {
+        delete nextOptions.git;
+    }
+    return nextOptions;
+}
+export async function readPortalConfig(portalDir) {
+    const configPath = path.join(portalDir, 'portal.config.json');
+    const data = JSON.parse(await readFile(configPath, 'utf-8'));
+    const config = readObject(data);
+    const git = readObject(config.git);
+    return buildPortalConfig({
+        portal: path.basename(portalDir),
+        sourceStorage: trimValue(config.sourceStorage),
+        gitRepo: trimValue(git.repo),
+        gitBranch: trimValue(git.branch),
+        gitPath: trimValue(git.path),
+    });
+}
+export async function writePortalConfig(portalDir, config) {
+    await writeFile(path.join(portalDir, 'portal.config.json'), `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+}
+export async function syncPortalConfigToRemote(options) {
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: options.cliVersion ?? '',
+        envName: options.envName,
+        flags: {
+            filterByTk: options.portal,
+            body: JSON.stringify({
+                options: mergePortalConfigIntoOptions(options.config, options.currentOptions),
+            }),
+        },
+        operation: UPDATE_PORTAL_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalConfigText('errors.updateFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal config update failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+}