@nocobase/cli 3.0.0-alpha.1 → 3.0.0-alpha.12

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,8 +38,6 @@ const STRING_ENV_CONFIG_KEYS = [
     'dbSchema',
     'dbTablePrefix',
     'lang',
-    'portalType',
-    'portalName',
     'portalTemplate',
     'rootUsername',
     'rootEmail',
@@ -86,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;
@@ -118,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

@@ -22,7 +22,7 @@ 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 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';
@@ -605,17 +605,30 @@ function buildNginxManagedConfigBlock(context) {
         `    ${MANAGED_NGINX_CONFIG_BLOCK_END}`,
     ].join('\n');
 }
-function buildNginxPortalRootPublicPath(appPublicPath) {
+function buildPortalRootPublicPath(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 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;`,
@@ -640,7 +653,6 @@ function buildNginxPortalLocationBlock(context) {
         '',
         `    location ^~ ${portalBasePath}/ {`,
         '        absolute_redirect off;',
-        '',
         `        if ($uri ~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)$) {`,
         `            return 308 ${portalBasePath}/$portal/$is_args$args;`,
         '        }',
@@ -1229,6 +1241,7 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
     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
         ? ''
         : `
@@ -1321,6 +1334,14 @@ 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}`,

package/dist/lib/generated-command.js

@@ -15,12 +15,20 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv } from './auth-store.js';
 import { executeApiRequest } from './api-client.js';
+import { resolveAppUrlFromApiBaseUrl } from '../commands/env/shared.js';
 import { findApiCommandCompatViolation, formatApiCommandCompatViolation } from './api-command-compat.js';
+import { openUrlInDefaultBrowser } from './browser.js';
 import { ensureCrossEnvConfirmed } from './env-guard.js';
 import { applyPostProcessor } from './post-processors.js';
 import { readInstalledManagedSkillsVersion } from './skills-manager.js';
 import { registerPostProcessors } from '../post-processors/index.js';
+const UI_OPERATION_QUERY_KEY = '_operation_';
+const UI_OPERATION_VERSION = 1;
+function encodeUIOperation(operation) {
+    return Buffer.from(JSON.stringify(operation), 'utf8').toString('base64url');
+}
 function buildParameterFlag(parameter, options) {
     const hints = [parameter.in];
     if (parameter.isFile) {
@@ -104,6 +112,13 @@ export function createGeneratedFlags(operation) {
             required: true,
         });
     }
+    if (operation.ui) {
+        flags.ui = Flags.boolean({
+            description: 'Open the corresponding page in the NocoBase UI',
+            default: false,
+            helpGroup: 'Global',
+        });
+    }
     flags['api-base-url'] = Flags.string({
         description: 'NocoBase API base URL, for example http://localhost:13000/api',
         helpGroup: 'Global',
@@ -142,6 +157,68 @@ export function createGeneratedFlags(operation) {
     });
     return flags;
 }
+function hasFlagValue(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+function listProvidedBodyFlags(flags, operation) {
+    const rawBodyFlags = ['body', 'body-file'].filter((flagName) => hasFlagValue(flags[flagName])).map((flagName) => `--${flagName}`);
+    const uiParameterNames = new Set(operation.ui?.parameters ?? []);
+    const bodyFieldFlags = operation.parameters
+        .filter((parameter) => parameter.in === 'body' && !uiParameterNames.has(parameter.name) && hasFlagValue(flags[parameter.flagName]))
+        .map((parameter) => `--${parameter.flagName}`);
+    return [...rawBodyFlags, ...bodyFieldFlags];
+}
+async function resolveUiAppUrl(flags) {
+    const apiBaseUrl = typeof flags['api-base-url'] === 'string' ? flags['api-base-url'] : undefined;
+    if (apiBaseUrl) {
+        return resolveAppUrlFromApiBaseUrl(apiBaseUrl);
+    }
+    const requestedEnv = typeof flags.env === 'string' ? flags.env : undefined;
+    const envName = requestedEnv ?? (await getCurrentEnvName());
+    const env = await getEnv(envName);
+    if (!env?.baseUrl) {
+        throw new Error(env
+            ? `Env "${envName}" is missing a base URL. Use --api-base-url or update env "${envName}" with \`nb env update ${envName} --api-base-url <url>\` first.`
+            : `Env "${envName}" is not configured. Use --api-base-url or run \`nb init --ui --env ${envName}\` first.`);
+    }
+    return resolveAppUrlFromApiBaseUrl(env.baseUrl);
+}
+function buildUiOperationUrl(appUrl, path, encodedOperation) {
+    const url = new URL(appUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/, '')}/${path}`;
+    url.searchParams.set(UI_OPERATION_QUERY_KEY, encodedOperation);
+    return url.toString();
+}
+async function openUiOperation(command, operation, flags) {
+    const { operationId, ui } = operation;
+    if (!ui || !operationId) {
+        command.error('This API operation does not support --ui.');
+    }
+    const bodyFlags = listProvidedBodyFlags(flags, operation);
+    if (bodyFlags.length) {
+        command.error('--ui cannot be combined with API request body flags. Remove --ui to submit through the API, or remove the body flags to open the UI.');
+    }
+    const uiParameterNames = new Set(ui.parameters ?? []);
+    const params = Object.fromEntries(operation.parameters
+        .filter((parameter) => uiParameterNames.has(parameter.name) && hasFlagValue(flags[parameter.flagName]))
+        .map((parameter) => [parameter.name, flags[parameter.flagName]]));
+    const uiOperation = {
+        v: UI_OPERATION_VERSION,
+        operationId,
+        ...(Object.keys(params).length ? { params } : {}),
+    };
+    const encodedOperation = encodeUIOperation(uiOperation);
+    const appUrl = await resolveUiAppUrl(flags);
+    const targetUrl = buildUiOperationUrl(appUrl, ui.path, encodedOperation);
+    const opened = await openUrlInDefaultBrowser(targetUrl);
+    command.log(targetUrl);
+    if (!opened) {
+        command.warn('Could not open the default browser. Copy the URL above to continue.');
+    }
+}
 export class GeneratedApiCommand extends Command {
     static operation;
     static runtimeVersion;
@@ -169,6 +246,10 @@ export class GeneratedApiCommand extends Command {
         if (compatViolation) {
             this.error(formatApiCommandCompatViolation(compatViolation));
         }
+        if (flags.ui) {
+            await openUiOperation(this, ctor.operation, flags);
+            return;
+        }
         const response = await executeApiRequest({
             cliVersion,
             skillsVersion,

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

@@ -8,6 +8,7 @@
  */
 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, resolveDockerEnvFilePath } from "./docker-env-file.js";
@@ -17,13 +18,18 @@ export const DEFAULT_MANAGED_ENV_FILE_VALUES = {
     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
@@ -39,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/)) {
@@ -63,38 +92,39 @@ 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 normalizeEnvFilePath(path.join(runtime.projectRoot, '.env'));
+    return 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;
+        return resolveDockerEnvFilePath(envName, config);
     }
     if (kind !== 'local') {
         return undefined;
     }
     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');
     }
     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 path.basename(appRootPath) === 'source'
+            ? path.resolve(appRootPath, '..', '.env')
+            : path.join(appRootPath, '.env');
     }
     return undefined;
 }
@@ -114,7 +144,8 @@ export async function ensureManagedEnvFileDefaults(envName, config, defaults = D
         }
     }
     const existing = parseSimpleEnvFile(content);
-    const missingEntries = Object.entries(defaults).filter(([key, value]) => trimValue(value) && !existing[key]);
+    const resolvedDefaults = buildManagedEnvFileDefaults(config, defaults);
+    const missingEntries = Object.entries(resolvedDefaults).filter(([key, value]) => trimValue(value) && !existing[key]);
     if (missingEntries.length === 0) {
         return envFilePath;
     }
@@ -124,6 +155,29 @@ export async function ensureManagedEnvFileDefaults(envName, config, defaults = D
     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;
+    }
+    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,8 +29,6 @@ export function buildInitAppEnvVarsFromConfig(config, options = {}) {
     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/plugin-import.js

@@ -207,6 +207,29 @@ async function openPluginSource(source, npmRegistry, runFn = run) {
     }
     return await packNpmPluginSource(source, npmRegistry, runFn);
 }
+/**
+ * Locate the directory holding the plugin's `package.json` inside a freshly extracted archive.
+ *
+ * Archives reach us in two shapes: npm-style tarballs (`npm pack`, registry downloads) wrap everything in a single
+ * top-level directory — conventionally `package/` — while NocoBase's own `yarn build <plugin> --tar` writes entries at
+ * the archive root. Extracting with a fixed `strip: 1` would silently discard the root-level files of the latter, so we
+ * extract verbatim and pick the package root here instead. When neither shape matches, return the extract root and let
+ * `readPluginMetadata` report the missing `package.json`.
+ */
+async function resolveArchivePackageRoot(extractRoot) {
+    if (await pathExists(path.join(extractRoot, 'package.json'))) {
+        return extractRoot;
+    }
+    const entries = await fsp.readdir(extractRoot, { withFileTypes: true });
+    const directories = entries.filter((entry) => entry.isDirectory());
+    if (directories.length === 1) {
+        const nestedRoot = path.join(extractRoot, directories[0].name);
+        if (await pathExists(path.join(nestedRoot, 'package.json'))) {
+            return nestedRoot;
+        }
+    }
+    return extractRoot;
+}
 async function readPluginMetadata(extractRoot, sourceLabel) {
     const packageJsonPath = path.join(extractRoot, 'package.json');
     let content;
@@ -241,22 +264,21 @@ export async function importPluginSource(source, options = {}) {
     await fsp.mkdir(storagePluginsPath, { recursive: true });
     const archive = await openPluginSource(normalizedSource, options.npmRegistry, options.runFn);
     const stageDir = await fsp.mkdtemp(path.join(storagePluginsPath, '.nb-plugin-import-'));
-    let stageMoved = false;
     try {
         try {
-            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir, strip: 1 }));
+            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir }));
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Failed to extract plugin archive from ${archive.source}: ${message}`);
         }
-        const { packageName, packageVersion } = await readPluginMetadata(stageDir, archive.source);
+        const packageRoot = await resolveArchivePackageRoot(stageDir);
+        const { packageName, packageVersion } = await readPluginMetadata(packageRoot, archive.source);
         const outputDir = resolvePluginOutputDir(storagePluginsPath, packageName);
         const action = (await pathExists(outputDir)) ? 'updated' : 'installed';
         await fsp.mkdir(path.dirname(outputDir), { recursive: true });
         await fsp.rm(outputDir, { recursive: true, force: true });
-        await fsp.rename(stageDir, outputDir);
-        stageMoved = true;
+        await fsp.rename(packageRoot, outputDir);
         return {
             action,
             packageName,
@@ -268,9 +290,9 @@ export async function importPluginSource(source, options = {}) {
         };
     }
     finally {
-        if (!stageMoved) {
-            await fsp.rm(stageDir, { recursive: true, force: true });
-        }
+        // Always removes the staging directory: it is either untouched (failure), or an empty wrapper left behind after the
+        // nested package root was renamed out of it.
+        await fsp.rm(stageDir, { recursive: true, force: true });
         await archive.cleanup();
     }
 }

package/dist/lib/portal-build-html.js

@@ -0,0 +1,27 @@
+/**
+ * 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';
+const BUILD_HTML_SCRIPT_PATH = path.join('scripts', 'build-html.mjs');
+const BUILD_HTML_ENV_FILES_PATTERN = /return\s+\[\s*["']\.env["']\s*,\s*["']\.env\.local["']\s*,\s*`\.env\.\$\{mode\}`\s*,\s*`\.env\.\$\{mode\}\.local`\s*\]\.map\(\s*\(?file\)?\s*=>\s*path\.join\(rootDir,\s*file\)\s*\);/m;
+const BUILD_HTML_ENV_ONLY_REPLACEMENT = 'return [".env"].map((file) => path.join(rootDir, file));';
+export async function ensurePortalBuildHtmlReadsEnvOnly(portalDir) {
+    const scriptPath = path.join(portalDir, BUILD_HTML_SCRIPT_PATH);
+    let content;
+    try {
+        content = await readFile(scriptPath, 'utf-8');
+    }
+    catch {
+        return;
+    }
+    const nextContent = content.replace(BUILD_HTML_ENV_FILES_PATTERN, BUILD_HTML_ENV_ONLY_REPLACEMENT);
+    if (nextContent !== content) {
+        await writeFile(scriptPath, nextContent, 'utf-8');
+    }
+}

package/dist/lib/portal-config.js

@@ -6,7 +6,6 @@
  * 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';
@@ -19,9 +18,10 @@ const UPDATE_PORTAL_OPERATION = {
     bodyRequired: true,
     parameters: [
         {
-            name: 'filterByTk',
-            flagName: 'filterByTk',
+            name: 'filter',
+            flagName: 'filter',
             in: 'query',
+            type: 'object',
             required: true,
         },
     ],
@@ -98,29 +98,15 @@ export function mergePortalConfigIntoOptions(config, currentOptions) {
     }
     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,
+            filter: {
+                portalName: options.portal,
+            },
             body: JSON.stringify({
                 options: mergePortalConfigIntoOptions(options.config, options.currentOptions),
             }),