@nocobase/cli 2.2.0-alpha.3 → 2.2.0-alpha.5

package/dist/lib/env-proxy.js

@@ -259,7 +259,7 @@ export function applyEnvProxyAppEntryOptions(content, provider, options) {
 function toCaddyPathMatcher(prefixPath) {
     return `${prefixPath}*`;
 }
-export async function loadEnvProxySettings(runtime) {
+export async function loadEnvProxySettings(runtime, options) {
     const { envFilePath, envValues } = await readManagedRuntimeEnvValues(runtime);
     const appPublicPath = resolveAppPublicPath(runtime.env.config.appPublicPath || envValues.APP_PUBLIC_PATH || DEFAULT_APP_PUBLIC_PATH);
     const apiClientShareToken = /^true$/i.test(String(envValues.API_CLIENT_SHARE_TOKEN ?? '').trim());
@@ -274,7 +274,9 @@ export async function loadEnvProxySettings(runtime) {
             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),
-            cdnBaseUrl: trimValue(runtime.env.envVars?.CDN_BASE_URL) ?? trimValue(envValues.CDN_BASE_URL),
+            cdnBaseUrl: trimValue(options?.cdnBaseUrl) ??
+                trimValue(runtime.env.envVars?.CDN_BASE_URL) ??
+                trimValue(envValues.CDN_BASE_URL),
             apiClientStoragePrefix: trimValue(envValues.API_CLIENT_STORAGE_PREFIX) ?? DEFAULT_API_CLIENT_STORAGE_PREFIX,
             apiClientStorageType: trimValue(envValues.API_CLIENT_STORAGE_TYPE) ?? DEFAULT_API_CLIENT_STORAGE_TYPE,
             apiClientShareToken,
@@ -284,6 +286,53 @@ export async function loadEnvProxySettings(runtime) {
         },
     };
 }
+function createManualProxyEnvSettings(input) {
+    const appPublicPath = resolveAppPublicPath(input.appPublicPath || DEFAULT_APP_PUBLIC_PATH);
+    return {
+        appPublicPath,
+        apiBasePath: prefixRuntimePath(appPublicPath, DEFAULT_API_BASE_PATH, {
+            trailingSlash: true,
+        }),
+        distPath: resolveDistPublicPath(appPublicPath),
+        wsPath: prefixRuntimePath(appPublicPath, DEFAULT_WS_PATH),
+        pluginStaticsPath: prefixRuntimePath(appPublicPath, DEFAULT_PLUGIN_STATICS_PATH, {
+            trailingSlash: true,
+        }),
+        modernClientPrefix: DEFAULT_MODERN_CLIENT_PREFIX,
+        cdnBaseUrl: trimValue(input.cdnBaseUrl),
+        apiClientStoragePrefix: DEFAULT_API_CLIENT_STORAGE_PREFIX,
+        apiClientStorageType: DEFAULT_API_CLIENT_STORAGE_TYPE,
+        apiClientShareToken: false,
+        wsUrl: '',
+        esmCdnBaseUrl: DEFAULT_ESM_CDN_BASE_URL,
+        esmCdnSuffix: '',
+    };
+}
+function normalizeManualNginxInput(input) {
+    const upstreamPort = trimValue(input.upstreamPort) ?? trimValue(input.appPort);
+    return {
+        name: String(input.name).trim(),
+        storagePath: String(input.storagePath).trim(),
+        distRootPath: String(input.distRootPath).trim(),
+        runtimeVersion: String(input.runtimeVersion).trim(),
+        appPublicPath: trimValue(input.appPublicPath),
+        upstreamHost: trimValue(input.upstreamHost),
+        upstreamPort,
+        appPort: trimValue(input.appPort),
+        cdnBaseUrl: trimValue(input.cdnBaseUrl),
+    };
+}
+function normalizeProxyPort(value) {
+    const normalized = trimValue(value);
+    if (!normalized || !/^\d+$/.test(normalized)) {
+        return undefined;
+    }
+    const port = Number(normalized);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return undefined;
+    }
+    return normalized;
+}
 async function parseVersionFromPackageJson(content, sourceLabel) {
     let parsed;
     try {
@@ -525,65 +574,92 @@ function buildNginxRuntimeConfig(context, variant) {
 function buildCaddyRuntimeConfig(context, variant) {
     return buildNginxRuntimeConfig(context, variant);
 }
-async function buildEnvProxyNginxRenderContext(runtime, options) {
-    const apiPort = trimValue(runtime.env.appPort ?? runtime.env.config.appPort);
-    if (!apiPort) {
-        throw new Error(translateCli('commands.envProxy.errors.missingAppPort', { envName: runtime.envName }, {
-            fallback: `Missing appPort for env "${runtime.envName}". Save or update the app port before generating proxy config.`,
-        }));
-    }
-    const activeVersion = trimValue(await readDistClientActiveVersion(runtime.env.storagePath));
-    if (!activeVersion) {
-        throw new Error(translateCli('commands.envProxy.errors.missingVersion', { envName: runtime.envName }, {
-            fallback: `Couldn't determine the app version for env "${runtime.envName}". Run \`nb env update ${runtime.envName}\` and try again.`,
-        }));
-    }
-    const { envFilePath, settings } = await loadEnvProxySettings(runtime);
+async function buildEnvProxyNginxRenderContext(source, options) {
     const proxyHost = await resolveProxyUpstreamHost(options);
-    const backendUrl = `http://${proxyHost}:${apiPort}`;
-    const cdnBaseUrl = settings.cdnBaseUrl ?? buildDefaultCdnBaseUrl(settings.appPublicPath, activeVersion);
-    const entryDir = resolveEnvProxyEntryDir(runtime.envName, { scope: options?.scope });
-    const publicDir = resolveEnvProxyNginxPublicOutputDir(runtime.envName, { scope: options?.scope });
+    const upstreamPort = normalizeProxyPort(options?.upstreamPort) ?? source.apiPort;
+    const backendUrl = `http://${proxyHost}:${upstreamPort}`;
+    const cdnBaseUrl = source.settings.cdnBaseUrl ?? buildDefaultCdnBaseUrl(source.settings.appPublicPath, source.activeVersion);
+    const entryDir = resolveEnvProxyEntryDir(source.envName, { scope: options?.scope });
+    const publicDir = resolveEnvProxyNginxPublicOutputDir(source.envName, { scope: options?.scope });
     const snippetsDir = resolveEnvProxyNginxSnippetsOutputDir({ scope: options?.scope });
-    const distRootDir = resolveDistClientRoot(runtime.env.storagePath);
-    const uploadsDir = path.join(runtime.env.storagePath, 'uploads');
+    const distRootDir = source.distRootPath;
+    const uploadsDir = path.join(source.storagePath, 'uploads');
     const mappedEntryDir = await mapProxyPathFromCliRoot(entryDir, options);
     const mappedPublicDir = await mapProxyPathFromCliRoot(publicDir, options);
     const mappedSnippetsDir = await mapProxyPathFromCliRoot(snippetsDir, options);
     const mappedDistRootDir = await mapProxyPathFromCliRoot(distRootDir, options);
     const mappedUploadsDir = await mapProxyPathFromCliRoot(uploadsDir, options);
-    const v2PublicPath = `${settings.appPublicPath.replace(/\/$/, '')}/${settings.modernClientPrefix}/`;
+    const v2PublicPath = `${source.settings.appPublicPath.replace(/\/$/, '')}/${source.settings.modernClientPrefix}/`;
     return {
-        envName: runtime.envName,
-        envFilePath,
-        apiBasePath: settings.apiBasePath,
-        apiClientShareToken: settings.apiClientShareToken,
-        apiClientStoragePrefix: settings.apiClientStoragePrefix,
-        apiClientStorageType: settings.apiClientStorageType,
-        apiPort,
-        appPublicPath: settings.appPublicPath,
+        envName: source.envName,
+        envFilePath: source.envFilePath,
+        apiBasePath: source.settings.apiBasePath,
+        apiClientShareToken: source.settings.apiClientShareToken,
+        apiClientStoragePrefix: source.settings.apiClientStoragePrefix,
+        apiClientStorageType: source.settings.apiClientStorageType,
+        apiPort: source.apiPort,
+        appPublicPath: source.settings.appPublicPath,
         backendUrl,
         cdnBaseUrl: ensureTrailingSlash(cdnBaseUrl),
-        distPath: settings.distPath,
+        distPath: source.settings.distPath,
         distRootDir: mappedDistRootDir,
         entryDir: mappedEntryDir,
         publicDir: mappedPublicDir,
-        esmCdnBaseUrl: settings.esmCdnBaseUrl,
-        esmCdnSuffix: settings.esmCdnSuffix,
-        indexV1Path: await mapProxyPathFromCliRoot(resolveEnvProxyNginxIndexOutputPath(runtime.envName, 'v1', { scope: options?.scope }), options),
-        indexV2Path: await mapProxyPathFromCliRoot(resolveEnvProxyNginxIndexOutputPath(runtime.envName, 'v2', { scope: options?.scope }), options),
-        modernClientPrefix: settings.modernClientPrefix,
+        esmCdnBaseUrl: source.settings.esmCdnBaseUrl,
+        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),
+        modernClientPrefix: source.settings.modernClientPrefix,
         proxyHost,
         snippetsDir: mappedSnippetsDir,
         uploadsDir: mappedUploadsDir,
         v2PublicPath,
-        wsPath: settings.wsPath,
-        wsUrl: settings.wsUrl,
+        wsPath: source.settings.wsPath,
+        wsUrl: source.settings.wsUrl,
+        activeVersion: source.activeVersion,
+    };
+}
+async function resolveRuntimeNginxBundleSource(runtime, options) {
+    const apiPort = trimValue(runtime.env.appPort ?? runtime.env.config.appPort);
+    if (!apiPort) {
+        throw new Error(translateCli('commands.envProxy.errors.missingAppPort', { envName: runtime.envName }, {
+            fallback: `Missing appPort for env "${runtime.envName}". Save or update the app port before generating proxy config.`,
+        }));
+    }
+    const activeVersion = trimValue(await readDistClientActiveVersion(runtime.env.storagePath));
+    if (!activeVersion) {
+        throw new Error(translateCli('commands.envProxy.errors.missingVersion', { envName: runtime.envName }, {
+            fallback: `Couldn't determine the app version for env "${runtime.envName}". Run \`nb env update ${runtime.envName}\` and try again.`,
+        }));
+    }
+    const { envFilePath, settings } = await loadEnvProxySettings(runtime, options);
+    return {
+        envName: runtime.envName,
+        envFilePath,
+        storagePath: runtime.env.storagePath,
+        distRootPath: resolveDistClientRoot(runtime.env.storagePath),
+        settings,
+        apiPort,
         activeVersion,
     };
 }
+async function resolveManualNginxBundleSource(input) {
+    const normalized = normalizeManualNginxInput(input);
+    return {
+        envName: normalized.name,
+        envFilePath: undefined,
+        storagePath: normalized.storagePath,
+        distRootPath: normalized.distRootPath,
+        settings: createManualProxyEnvSettings(normalized),
+        apiPort: normalized.upstreamPort,
+        activeVersion: normalized.runtimeVersion,
+    };
+}
 async function buildEnvProxyCaddyRenderContext(runtime, options) {
-    return await buildEnvProxyNginxRenderContext(runtime, {
+    return await buildEnvProxyCaddyRenderContextFromSource(await resolveRuntimeNginxBundleSource(runtime), options);
+}
+async function buildEnvProxyCaddyRenderContextFromSource(source, options) {
+    return await buildEnvProxyNginxRenderContext(source, {
         ...options,
         provider: 'caddy',
     });
@@ -636,11 +712,21 @@ export function resolveEnvProxyCaddyIndexOutputPath(envName, variant, options) {
     return path.join(resolveEnvProxyCaddyPublicOutputDir(envName, { scope: options?.scope }), `index-${variant}.html`);
 }
 export async function buildEnvProxyNginxBundle(runtime, options) {
-    const context = await buildEnvProxyNginxRenderContext(runtime, options);
+    return await buildNginxBundleFromSource(await resolveRuntimeNginxBundleSource(runtime, options), options);
+}
+export async function buildManualEnvProxyNginxBundle(input, options) {
+    return await buildNginxBundleFromSource(await resolveManualNginxBundleSource(input), {
+        ...options,
+        upstreamHost: trimValue(input.upstreamHost) ?? options?.upstreamHost,
+        upstreamPort: normalizeProxyPort(input.upstreamPort) ?? options?.upstreamPort,
+    });
+}
+async function buildNginxBundleFromSource(source, options) {
+    const context = await buildEnvProxyNginxRenderContext(source, options);
     const appTemplate = await readEnvProxyNginxAssetText('app.conf.tpl');
     const mainTemplate = await readEnvProxyNginxAssetText('nocobase.conf.tpl');
-    const sourceIndexV1Path = path.join(runtime.env.storagePath, 'dist-client', context.activeVersion, 'index.html');
-    const sourceIndexV2Path = path.join(runtime.env.storagePath, 'dist-client', context.activeVersion, DEFAULT_MODERN_CLIENT_PREFIX, 'index.html');
+    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([
         readFile(sourceIndexV1Path, 'utf8'),
         readFile(sourceIndexV2Path, 'utf8'),
@@ -667,13 +753,13 @@ export async function buildEnvProxyNginxBundle(runtime, options) {
         wsPath: context.wsPath,
     };
     return {
-        envName: runtime.envName,
+        envName: source.envName,
         envFilePath: context.envFilePath,
-        entryDir: resolveEnvProxyEntryDir(runtime.envName, { scope: options?.scope, provider: 'nginx' }),
-        publicDir: resolveEnvProxyNginxPublicOutputDir(runtime.envName, { scope: options?.scope }),
-        appConfigPath: resolveEnvProxyAppOutputPath(runtime.envName, { scope: options?.scope, provider: 'nginx' }),
-        indexV1Path: resolveEnvProxyNginxIndexOutputPath(runtime.envName, 'v1', { scope: options?.scope }),
-        indexV2Path: resolveEnvProxyNginxIndexOutputPath(runtime.envName, 'v2', { scope: options?.scope }),
+        entryDir: resolveEnvProxyEntryDir(source.envName, { scope: options?.scope, provider: 'nginx' }),
+        publicDir: resolveEnvProxyNginxPublicOutputDir(source.envName, { scope: options?.scope }),
+        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 }),
         mainConfigPath: resolveEnvProxyMainOutputPath({ scope: options?.scope, provider: 'nginx' }),
         snippetsDir: resolveEnvProxyNginxSnippetsOutputDir({ scope: options?.scope }),
         appPublicPath: context.appPublicPath,
@@ -694,9 +780,19 @@ export async function buildEnvProxyNginxBundle(runtime, options) {
     };
 }
 export async function buildEnvProxyCaddyBundle(runtime, options) {
-    const context = await buildEnvProxyCaddyRenderContext(runtime, options);
-    const sourceIndexV1Path = path.join(runtime.env.storagePath, 'dist-client', context.activeVersion, 'index.html');
-    const sourceIndexV2Path = path.join(runtime.env.storagePath, 'dist-client', context.activeVersion, DEFAULT_MODERN_CLIENT_PREFIX, 'index.html');
+    return await buildCaddyBundleFromSource(await resolveRuntimeNginxBundleSource(runtime), options);
+}
+export async function buildManualEnvProxyCaddyBundle(input, options) {
+    return await buildCaddyBundleFromSource(await resolveManualNginxBundleSource(input), {
+        ...options,
+        upstreamHost: trimValue(input.upstreamHost) ?? options?.upstreamHost,
+        upstreamPort: normalizeProxyPort(input.upstreamPort) ?? options?.upstreamPort,
+    });
+}
+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([
         readFile(sourceIndexV1Path, 'utf8'),
         readFile(sourceIndexV2Path, 'utf8'),
@@ -707,9 +803,9 @@ export async function buildEnvProxyCaddyBundle(runtime, options) {
     const sourceV2PublicPath = extractRuntimePublicPath(sourceIndexV2Content);
     const indexV1AssetPublicPath = context.cdnBaseUrl;
     const indexV2AssetPublicPath = `${trimTrailingSlash(context.cdnBaseUrl)}/${DEFAULT_MODERN_CLIENT_PREFIX}/`;
-    const appConfigPath = resolveEnvProxyAppOutputPath(runtime.envName, { scope: options?.scope, provider: 'caddy' });
-    const entryDir = resolveEnvProxyEntryDir(runtime.envName, { scope: options?.scope, provider: 'caddy' });
-    const publicDir = resolveEnvProxyCaddyPublicOutputDir(runtime.envName, { scope: options?.scope });
+    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(), {
         appPublicPath: context.appPublicPath,
@@ -725,13 +821,13 @@ export async function buildEnvProxyCaddyBundle(runtime, options) {
         wsPath: context.wsPath,
     }, renderedPublicDir);
     return {
-        envName: runtime.envName,
+        envName: source.envName,
         envFilePath: context.envFilePath,
         entryDir,
         publicDir,
         appConfigPath,
-        indexV1Path: resolveEnvProxyCaddyIndexOutputPath(runtime.envName, 'v1', { scope: options?.scope }),
-        indexV2Path: resolveEnvProxyCaddyIndexOutputPath(runtime.envName, 'v2', { scope: options?.scope }),
+        indexV1Path: resolveEnvProxyCaddyIndexOutputPath(source.envName, 'v1', { scope: options?.scope }),
+        indexV2Path: resolveEnvProxyCaddyIndexOutputPath(source.envName, 'v2', { scope: options?.scope }),
         mainConfigPath: resolveEnvProxyMainOutputPath({ scope: options?.scope, provider: 'caddy' }),
         appPublicPath: context.appPublicPath,
         apiBasePath: context.apiBasePath,

package/dist/lib/proxy-caddy.js

@@ -11,7 +11,7 @@ import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
 import { CADDY_PROXY_DRIVER_OPTIONS, DEFAULT_CADDY_PROXY_DRIVER, getCliConfigValue, normalizeCaddyProxyDriver, resolveDockerContainerPrefix, setCliConfigValue, } from './cli-config.js';
 import { resolveCliHomeRoot } from './cli-home.js';
-import { applyEnvProxyAppEntryOptions, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
+import { applyEnvProxyAppEntryOptions, buildManualEnvProxyCaddyBundle, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
 import { run } from './run-npm.js';
 const DOCKER_CADDY_PROXY_CONTAINER_SUFFIX = 'caddy-proxy';
 const DOCKER_CADDY_PROXY_IMAGE = 'caddy:latest';
@@ -62,8 +62,9 @@ export async function resolveCaddyProxyRuntimeContext(options) {
         upstreamHost: resolveCaddyProxyUpstreamHost(driver),
     };
 }
-export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext) {
+export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext, options) {
     const bundle = await buildEnvProxyCaddyBundle(runtime, {
+        cdnBaseUrl: options?.cdnBaseUrl,
         runtimeCliRoot: runtimeContext.runtimeCliRoot,
         upstreamHost: runtimeContext.upstreamHost,
     });
@@ -82,6 +83,27 @@ export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeCon
         status,
     };
 }
+export async function writeManualCaddyProxyBundle(input, appEntryOptions, runtimeContext, options) {
+    const bundle = await buildManualEnvProxyCaddyBundle(input, {
+        cdnBaseUrl: options?.cdnBaseUrl,
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: input.upstreamHost || runtimeContext.upstreamHost,
+    });
+    const currentAppConfigContent = await readOptionalTextFile(bundle.appConfigPath);
+    const nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'caddy', appEntryOptions);
+    const status = currentAppConfigContent ? 'updated' : 'created';
+    await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);
+    await Promise.all([
+        writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
+        writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
+        writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
+    ]);
+    return {
+        bundle,
+        status,
+    };
+}
 function resolveLocalCaddyPidFilePath() {
     return path.join(path.dirname(resolveEnvProxyMainOutputPath({ provider: 'caddy' })), 'caddy.pid');
 }

package/dist/lib/proxy-nginx.js

@@ -11,7 +11,7 @@ import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
 import { DEFAULT_NGINX_PROXY_DRIVER, getCliConfigValue, NGINX_PROXY_DRIVER_OPTIONS, normalizeNginxProxyDriver, resolveDockerContainerPrefix, setCliConfigValue, } from './cli-config.js';
 import { resolveCliHomeRoot } from './cli-home.js';
-import { applyEnvProxyAppEntryOptions, appConfigHasManagedNginxBlock, buildEnvProxyMainConfig, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, mapProxyPathFromCliRoot, reloadEnvProxyProvider, resolveEnvProxyMainOutputPath, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from './env-proxy.js';
+import { applyEnvProxyAppEntryOptions, appConfigHasManagedNginxBlock, buildManualEnvProxyNginxBundle, buildEnvProxyMainConfig, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, mapProxyPathFromCliRoot, reloadEnvProxyProvider, resolveEnvProxyMainOutputPath, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from './env-proxy.js';
 import { run } from './run-npm.js';
 const DOCKER_NGINX_PROXY_CONTAINER_SUFFIX = 'nginx-proxy';
 const DOCKER_NGINX_PROXY_IMAGE = 'nginx:latest';
@@ -66,11 +66,23 @@ function buildNginxManagedBlockMissingMessage(appConfigPath) {
     return (`The editable nginx app entry config at ${appConfigPath} does not contain the NocoBase managed block. ` +
         'Restore the managed block or delete the file and regenerate the proxy config.');
 }
-export async function writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext) {
+export async function writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext, options) {
     const bundle = await buildEnvProxyNginxBundle(runtime, {
+        cdnBaseUrl: options?.cdnBaseUrl,
         runtimeCliRoot: runtimeContext.runtimeCliRoot,
         upstreamHost: runtimeContext.upstreamHost,
     });
+    return await writeResolvedNginxProxyBundle(bundle, appEntryOptions, options);
+}
+export async function writeManualNginxProxyBundle(input, appEntryOptions, runtimeContext, options) {
+    const bundle = await buildManualEnvProxyNginxBundle(input, {
+        cdnBaseUrl: options?.cdnBaseUrl,
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: runtimeContext.upstreamHost,
+    });
+    return await writeResolvedNginxProxyBundle(bundle, appEntryOptions, options);
+}
+async function writeResolvedNginxProxyBundle(bundle, appEntryOptions, options) {
     const managedConfigBlock = extractManagedNginxConfigBlock(bundle.appConfigContent);
     if (!managedConfigBlock) {
         throw new Error('Failed to render the managed nginx config block.');
@@ -79,10 +91,12 @@ export async function writeNginxProxyBundle(runtime, appEntryOptions, runtimeCon
     let nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'nginx', appEntryOptions);
     let status = 'created';
     if (currentAppConfigContent) {
-        if (!appConfigHasManagedNginxBlock(currentAppConfigContent)) {
+        if (!appConfigHasManagedNginxBlock(currentAppConfigContent) && !options?.force) {
             throw new Error(buildNginxManagedBlockMissingMessage(bundle.appConfigPath));
         }
-        nextAppConfigContent = applyEnvProxyAppEntryOptions(replaceManagedNginxConfigBlock(currentAppConfigContent, managedConfigBlock), 'nginx', appEntryOptions);
+        nextAppConfigContent = appConfigHasManagedNginxBlock(currentAppConfigContent)
+            ? applyEnvProxyAppEntryOptions(replaceManagedNginxConfigBlock(currentAppConfigContent, managedConfigBlock), 'nginx', appEntryOptions)
+            : applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'nginx', appEntryOptions);
         status = 'updated';
     }
     await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);

package/dist/locale/en-US.json

@@ -263,7 +263,7 @@
         "version": {
           "message": "Which version would you like to use?",
           "latestLabel": "latest",
-          "latestHint": "Stable release. Best for production use and the most predictable experience. Currently unavailable.",
+          "latestHint": "Stable release. Best for production use and the most predictable experience.",
           "betaLabel": "beta",
           "betaHint": "Preview release. Good for trying upcoming features before general release.",
           "alphaLabel": "alpha",

package/dist/locale/zh-CN.json

@@ -263,7 +263,7 @@
         "version": {
           "message": "你想使用哪个版本？",
           "latestLabel": "latest",
-          "latestHint": "稳定版。适合生产环境和希望获得稳定体验的场景。当前暂不可用。",
+          "latestHint": "稳定版。适合生产环境和希望获得稳定体验的场景。",
           "betaLabel": "beta",
           "betaHint": "测试版。包含即将发布的新功能，适合提前体验和反馈。",
           "alphaLabel": "alpha",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.2.0-alpha.3",
+  "version": "2.2.0-alpha.5",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -13,6 +13,7 @@
   "author": "",
   "license": "Apache-2.0",
   "files": [
+    "assets",
     "bin",
     "dist",
     "nocobase-ctl.config.json"
@@ -143,5 +144,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "e3ec19361fd7981af9fe2a7f24ad335025cbefcd"
+  "gitHead": "814ff497dd1233ca7218c9f7f2a016c2ead6516d"
 }