@nocobase/cli 2.2.0-test.16 → 3.0.0-alpha.1

package/dist/lib/env-proxy.js

@@ -20,6 +20,9 @@ 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';
@@ -67,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);
@@ -275,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),
@@ -299,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,
@@ -491,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
         ? ''
@@ -563,6 +579,17 @@ 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;`,
@@ -640,8 +667,9 @@ function buildNginxPortalLocationBlock(context) {
 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,
@@ -692,7 +720,9 @@ 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,
@@ -811,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 = {
@@ -844,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,
@@ -861,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) {
@@ -877,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,
@@ -912,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,
@@ -925,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) {
@@ -1179,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);
@@ -1236,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',
@@ -1269,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}`,
@@ -1341,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

@@ -29,7 +29,7 @@ export function buildInitAppEnvVarsFromConfig(config, options = {}) {
     put('INIT_ROOT_PASSWORD', config?.rootPassword);
     put('INIT_ROOT_NICKNAME', config?.rootNickname);
     if (options.includePortal !== false) {
-        put('INIT_DEVELOPMENT_MODE', config?.developmentMode);
+        put('INIT_PORTAL_TYPE', config?.portalType);
         put('INIT_PORTAL_NAME', config?.portalName);
         put('INIT_PORTAL_TEMPLATE', config?.portalTemplate);
     }

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-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)}`));
+    }
+}

package/dist/lib/portal-configure.js

@@ -0,0 +1,117 @@
+/**
+ * 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 { mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { translateCli } from './cli-locale.js';
+import { resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { buildPortalConfig, buildPortalConfigFromOptions, readPortalConfig, syncPortalConfigToRemote, writePortalConfig, } from './portal-config.js';
+import { findPortalListItem } from './portal-info.js';
+import { listPortalWorkspaces } from './portal-list.js';
+const portalConfigureText = (key, values, fallback) => translateCli(`commands.portalConfigure.${key}`, values, { fallback });
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasConfigurationChange(options) {
+    return Boolean(options.sourceStorage !== undefined ||
+        trimValue(options.gitRepo) ||
+        trimValue(options.gitBranch) ||
+        trimValue(options.gitPath));
+}
+async function readExistingConfig(portalDir) {
+    try {
+        return await readPortalConfig(portalDir);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function buildConfigFromRemoteOptions(params) {
+    if (params.options && Object.keys(params.options).length > 0) {
+        return buildPortalConfigFromOptions(params.options, params.portal);
+    }
+    if (!params.sourceStorage && !params.gitRepo && !params.gitBranch && !params.gitPath) {
+        return undefined;
+    }
+    return buildPortalConfig({
+        portal: params.portal,
+        sourceStorage: params.sourceStorage,
+        gitRepo: params.gitRepo,
+        gitBranch: params.gitBranch,
+        gitPath: params.gitPath,
+    });
+}
+export async function configurePortalWorkspace(options) {
+    if (!hasConfigurationChange(options)) {
+        throw new Error(portalConfigureText('errors.noChanges', undefined, 'No portal configuration changes were provided. Pass --source-storage or a --git-* flag.'));
+    }
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    if (!(await pathExists(portalDir))) {
+        throw new Error(portalConfigureText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` or \`nb portal pull ${portal}\` first.`));
+    }
+    const list = await listPortalWorkspaces({
+        env: options.env,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const remoteItem = findPortalListItem(list.items, portal);
+    const existingConfig = (await readExistingConfig(portalDir)) ??
+        buildConfigFromRemoteOptions({
+            portal,
+            options: remoteItem?.options,
+            sourceStorage: remoteItem?.sourceStorage,
+            gitRepo: remoteItem?.gitRepo,
+            gitBranch: remoteItem?.gitBranch,
+            gitPath: remoteItem?.gitPath,
+        });
+    const config = buildPortalConfig({
+        portal,
+        sourceStorage: options.sourceStorage,
+        gitRepo: options.gitRepo,
+        gitBranch: options.gitBranch,
+        gitPath: options.gitPath,
+        existingConfig,
+    });
+    await mkdir(portalDir, { recursive: true });
+    await writePortalConfig(portalDir, config);
+    if (remoteItem) {
+        await syncPortalConfigToRemote({
+            portal,
+            config,
+            currentOptions: remoteItem.options,
+            envName: options.envName,
+            cliVersion: options.cliVersion,
+            apiRequest: options.apiRequest,
+        });
+    }
+    return {
+        app,
+        portal,
+        portalDir,
+        config,
+        remoteSynced: Boolean(remoteItem),
+    };
+}