@nocobase/cli 3.0.0-alpha.5 → 3.0.0-alpha.7

package/dist/commands/portal/pull.js

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Args, Command, Flags } from '@oclif/core';
-import { getCurrentEnvName, getEnv } from '../../lib/auth-store.js';
+import { getCurrentEnvName, getEnv, setEnvPortalPath } from '../../lib/auth-store.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
 import { translateCli } from '../../lib/cli-locale.js';
 import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
@@ -19,6 +19,8 @@ export default class PortalPull extends Command {
     static examples = [
         '<%= config.bin %> <%= command.id %> customer',
         '<%= config.bin %> <%= command.id %> customer --env prod --yes',
+        '<%= config.bin %> <%= command.id %> customer --path ./portals/customer',
+        '<%= config.bin %> <%= command.id %> customer --git-repo git@github.com:nocobase/customer.git',
         '<%= config.bin %> <%= command.id %> customer --force',
         '<%= config.bin %> <%= command.id %> customer --no-install',
     ];
@@ -42,6 +44,18 @@ export default class PortalPull extends Command {
             description: 'Delete the existing local files and pull them again',
             default: false,
         }),
+        path: Flags.string({
+            description: 'Portal workspace directory; defaults to the saved path, then ./<portal>',
+        }),
+        'git-repo': Flags.string({
+            description: 'Temporarily pull source from this Git repository without updating the portal source configuration',
+        }),
+        'git-branch': Flags.string({
+            description: 'Git branch for the temporary --git-repo pull; defaults to main',
+        }),
+        'git-path': Flags.string({
+            description: 'Directory inside the temporary Git repository; defaults to the repository root',
+        }),
         install: Flags.boolean({
             description: 'Run pnpm install after pulling the portal source',
             default: true,
@@ -50,6 +64,12 @@ export default class PortalPull extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(PortalPull);
+        if ((flags['git-branch'] || flags['git-path']) && !flags['git-repo']) {
+            this.error(portalPullText('errors.gitRepoRequiredForTemporaryPull', undefined, [
+                '--git-branch and --git-path require --git-repo for a temporary Git pull.',
+                'To update the portal configuration, use `nb portal config`.',
+            ].join(' ')));
+        }
         const requestedEnv = hasExplicitEnvSelection(this.argv) ? flags.env : undefined;
         const confirmed = await ensureCrossEnvConfirmed({
             command: this,
@@ -74,12 +94,18 @@ export default class PortalPull extends Command {
             cliVersion: String(this.config.pjson.version ?? '').trim(),
             force: flags.force,
             installDependencies: flags.install,
+            sourcePath: flags.path,
+            defaultSourcePath: true,
+            gitRepo: flags['git-repo'],
+            gitBranch: flags['git-branch'],
+            gitPath: flags['git-path'],
         });
         if (!result.changed) {
             printInfo(result.noopReason ?? portalPullText('messages.noop', undefined, 'No pull is needed.'));
             return;
         }
-        printSuccess(portalPullText('messages.pulled', { portal: result.portal, portalDir: result.portalDir }, `Pulled portal source "${result.portal}" into ${result.portalDir}.`));
+        await setEnvPortalPath(envName, result.portal, result.portalDir, { scope });
+        printSuccess(portalPullText('messages.pulled', { portal: result.portal, portalDir: result.portalDir }, `Pulled portal source "${result.portal}" into ${result.portalDir}`));
         if (result.installFailed) {
             printWarning(portalPullText('messages.installFailed', { portalDir: result.portalDir }, `Dependency installation did not finish successfully. Run \`pnpm install\` manually in ${result.portalDir}.`));
         }

package/dist/lib/api-client.js

@@ -19,6 +19,7 @@ import { promises as fs } from 'node:fs';
 import { basename, dirname } from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
+import { translateCli } from './cli-locale.js';
 import { resolveServerRequestTarget } from './env-auth.js';
 import { fetchWithPreservedAuthRedirect } from './http-request.js';
 const CLI_REQUEST_SOURCE_HEADER = 'x-request-source';
@@ -40,7 +41,32 @@ function parseJsonInput(raw, flagName) {
 function normalizeBaseUrl(baseUrl) {
     return baseUrl.replace(/\/+$/, '');
 }
-async function parseResponse(response) {
+function buildAuthFailureCommand(envName) {
+    const normalizedEnvName = String(envName ?? '').trim();
+    return normalizedEnvName ? `nb env auth ${normalizedEnvName}` : 'nb env auth';
+}
+function decorateAuthFailureResponse(data, status, envName) {
+    if (status !== 401) {
+        return data;
+    }
+    const cliCommand = buildAuthFailureCommand(envName);
+    const cliHint = translateCli('apiClient.authRequiredHint', { command: cliCommand }, {
+        fallback: 'Authentication failed or the saved session has expired. Run `{{command}}` to sign in again.',
+    });
+    if (data && typeof data === 'object' && !Array.isArray(data)) {
+        return {
+            ...data,
+            cliHint,
+            cliCommand,
+        };
+    }
+    return {
+        error: data,
+        cliHint,
+        cliCommand,
+    };
+}
+async function parseResponse(response, envName) {
     const text = await response.text();
     let data = text;
     if (text) {
@@ -54,10 +80,10 @@ async function parseResponse(response) {
     return {
         ok: response.ok,
         status: response.status,
-        data,
+        data: decorateAuthFailureResponse(data, response.status, envName),
     };
 }
-async function parseBinaryResponse(response, outputPath) {
+async function parseBinaryResponse(response, outputPath, envName) {
     if (response.ok && response.body) {
         await fs.mkdir(dirname(outputPath), { recursive: true }).catch(() => undefined);
         await pipeline(Readable.fromWeb(response.body), createWriteStream(outputPath));
@@ -69,7 +95,7 @@ async function parseBinaryResponse(response, outputPath) {
             },
         };
     }
-    return parseResponse(response);
+    return parseResponse(response, envName);
 }
 function parseScalarValue(value, type) {
     if (value === undefined) {
@@ -215,7 +241,7 @@ async function createMultipartBody(flags, operation) {
     return hasValues ? formData : undefined;
 }
 export async function executeApiRequest(options) {
-    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const { baseUrl, token, envName } = await resolveServerRequestTarget(options);
     const headers = new Headers();
     headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
     headers.set(CLI_VERSION_HEADER, options.cliVersion);
@@ -283,12 +309,12 @@ export async function executeApiRequest(options) {
         if (!outputPath) {
             throw new Error('Missing required output path --output');
         }
-        return parseBinaryResponse(response, outputPath);
+        return parseBinaryResponse(response, outputPath, envName);
     }
-    return parseResponse(response);
+    return parseResponse(response, envName);
 }
 export async function executeRawApiRequest(options) {
-    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const { baseUrl, token, envName } = await resolveServerRequestTarget(options);
     const headers = new Headers();
     headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
     if (token) {
@@ -332,7 +358,7 @@ export async function executeRawApiRequest(options) {
             body: options.body === undefined ? undefined : JSON.stringify(options.body),
             signal: controller?.signal,
         });
-        return parseResponse(response);
+        return parseResponse(response, envName);
     }
     finally {
         if (timeout) {

package/dist/lib/app-client-entry-mode.js

@@ -0,0 +1,28 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export const APP_CLIENT_ENTRY_MODES = [
+    'legacy-default',
+    'modern-default',
+    'modern-only',
+    'settings-default',
+];
+export const PUBLIC_APP_CLIENT_ENTRY_MODES = ['legacy-default', 'modern-default', 'modern-only'];
+export function normalizeAppClientEntryMode(value) {
+    const text = String(value ?? '').trim();
+    return APP_CLIENT_ENTRY_MODES.includes(text) ? text : undefined;
+}
+export function normalizePublicAppClientEntryMode(value) {
+    const text = String(value ?? '').trim();
+    return PUBLIC_APP_CLIENT_ENTRY_MODES.includes(text)
+        ? text
+        : undefined;
+}
+export function defaultAppClientEntryModeForDownloadVersion(version) {
+    return String(version ?? '').trim() === 'latest' ? 'legacy-default' : 'modern-only';
+}

package/dist/lib/app-managed-resources.js

@@ -186,6 +186,7 @@ export async function buildSavedDockerRunArgs(runtime, options) {
     const dbTablePrefix = trimValue(config.dbTablePrefix);
     const dbUnderscored = typeof config.dbUnderscored === 'boolean' ? config.dbUnderscored : undefined;
     const extractClientAssets = resolveDockerClientAssetsExtractEnabled(process.env.NOCOBASE_EXTRACT_CLIENT_ASSETS);
+    const appClientEntryMode = trimValue(config.appClientEntryMode);
     const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
     const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
     const imageRef = resolveDockerImageRef(dockerRegistry, version, {
@@ -245,6 +246,7 @@ export async function buildSavedDockerRunArgs(runtime, options) {
     const lifecycleEnvVars = managedAppLifecycleEnvVars();
     args.push('-e', `APP_ENV=${lifecycleEnvVars.APP_ENV}`, '-e', `NODE_ENV=${lifecycleEnvVars.NODE_ENV}`, '-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`);
     pushOptionalEnvArg(args, 'APP_PUBLIC_PATH', appPublicPath ? resolveAppPublicPath(appPublicPath) : undefined);
+    pushOptionalEnvArg(args, 'APP_CLIENT_ENTRY_MODE', appClientEntryMode);
     pushOptionalEnvArg(args, 'DB_SCHEMA', dbSchema || undefined);
     pushOptionalEnvArg(args, 'DB_TABLE_PREFIX', dbTablePrefix || undefined);
     pushOptionalEnvArg(args, 'DB_UNDERSCORED', dbUnderscored);

package/dist/lib/auth-store.js

@@ -14,6 +14,7 @@ import { normalizeCliLocale } from './cli-locale.js';
 import { normalizeEnvProxyConfig, normalizeEnvProxyProviderConfig, } from './env-proxy-config.js';
 import { inferConfiguredAppPathFromLegacyConfig, resolveConfiguredAppPath, resolveConfiguredSourcePath, resolveConfiguredStoragePath, } from './env-paths.js';
 import { ENV_CONFIG_SCHEMA_VERSION, normalizeEnvConfigSchemaVersion } from './env-config.js';
+import { normalizeEnvPortalsConfig, } from './env-portal-config.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
@@ -78,11 +79,12 @@ function normalizeEnvConfigEntry(entry) {
     if (!entry) {
         return entry;
     }
-    const { kind: _kind, apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, schemaVersion: _schemaVersion, ...rest } = entry;
+    const { kind: _kind, apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, schemaVersion: _schemaVersion, portals: _portals, ...rest } = entry;
     const normalizedKind = resolveEnvKind(entry);
     const apiBaseUrl = readEnvApiBaseUrl(entry);
     const schemaVersion = normalizeEnvConfigSchemaVersion(entry.schemaVersion);
     const proxy = normalizeEnvProxyConfig(entry.proxy);
+    const portals = normalizeEnvPortalsConfig(entry.portals);
     return {
         ...rest,
         ...(schemaVersion ? { schemaVersion } : {}),
@@ -90,6 +92,7 @@ function normalizeEnvConfigEntry(entry) {
         ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
         ...(normalizeOptionalString(entry.appPublicPath) ? { appPublicPath: resolveAppPublicPath(entry.appPublicPath) } : {}),
         ...(proxy ? { proxy } : {}),
+        ...(portals ? { portals } : {}),
     };
 }
 function normalizeAuthConfig(config) {
@@ -332,6 +335,7 @@ export class Env {
         put('APP_PORT', this.appPort);
         put('APP_PUBLIC_PATH', this.config.appPublicPath ? resolveAppPublicPath(this.config.appPublicPath) : undefined);
         put('CDN_BASE_URL', this.config.cdnBaseUrl);
+        put('APP_CLIENT_ENTRY_MODE', this.config.appClientEntryMode);
         put('APP_KEY', this.config.appKey);
         put('TZ', this.config.timezone);
         put('DB_DIALECT', this.config.dbDialect);
@@ -521,6 +525,53 @@ export async function setEnvRuntime(envName, runtime, options = {}) {
     };
     await saveAuthConfig(config, options);
 }
+export function resolveEnvPortalPath(config, portal) {
+    const portalName = normalizeOptionalString(portal);
+    if (!portalName) {
+        return undefined;
+    }
+    return normalizeOptionalString(config?.portals?.[portalName]?.path);
+}
+export async function setEnvPortalPath(envName, portal, portalPath, options = {}) {
+    const portalName = normalizeOptionalString(portal);
+    const normalizedPath = normalizeOptionalString(portalPath);
+    if (!portalName || !normalizedPath) {
+        return;
+    }
+    await writeEnv(envName, (previous) => {
+        if (!previous) {
+            throw new Error(`Env "${envName}" is not configured`);
+        }
+        const portals = normalizeEnvPortalsConfig(previous.portals) ?? {};
+        return {
+            ...previous,
+            portals: {
+                ...portals,
+                [portalName]: {
+                    ...(portals[portalName] ?? {}),
+                    path: normalizedPath,
+                },
+            },
+        };
+    }, options);
+}
+export async function unsetEnvPortalPath(envName, portal, options = {}) {
+    const portalName = normalizeOptionalString(portal);
+    if (!portalName) {
+        return;
+    }
+    await writeEnv(envName, (previous) => {
+        if (!previous) {
+            throw new Error(`Env "${envName}" is not configured`);
+        }
+        const portals = normalizeEnvPortalsConfig(previous.portals) ?? {};
+        delete portals[portalName];
+        return {
+            ...previous,
+            ...(Object.keys(portals).length > 0 ? { portals } : { portals: undefined }),
+        };
+    }, options);
+}
 export function resolveEnvProxyEntry(config, provider) {
     const proxy = normalizeEnvProxyConfig(config?.proxy);
     const resolved = {

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}/settings/apps/${subappMatch[2]}/idpOAuth/device`;
-    }
-    const appMatch = url.pathname.match(/^(.*)\/api\/?$/);
-    if (appMatch) {
-        const publicPath = (appMatch[1] || '').replace(/\/+$/, '');
-        return `${publicPath}/settings/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,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';

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,6 +18,14 @@ 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;
@@ -36,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/)) {
@@ -112,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;
     }
@@ -122,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/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';
@@ -99,22 +98,6 @@ 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({