@nocobase/cli 2.2.0-beta.7 → 2.2.0-beta.9

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 {
@@ -438,6 +487,7 @@ function rewriteHtmlAssetPublicPath(html, currentPublicPath, nextPublicPath) {
 }
 function buildNginxManagedConfigBlock(context) {
     const v2PublicPathNoTrailingSlash = trimTrailingSlash(context.v2PublicPath);
+    const apiBasePathNoTrailingSlash = trimTrailingSlash(context.apiBasePath);
     const appPublicPathNoTrailingSlash = trimTrailingSlash(context.appPublicPath);
     const isRootMounted = context.appPublicPath === '/';
     const appPublicPathRedirectBlock = isRootMounted
@@ -476,6 +526,10 @@ function buildNginxManagedConfigBlock(context) {
         `        include ${context.snippetsDir}/proxy-location.conf;`,
         '    }',
         '',
+        `    location = ${apiBasePathNoTrailingSlash} {`,
+        `        return 308 ${context.apiBasePath}$is_args$args;`,
+        '    }',
+        '',
         `    location ^~ ${context.apiBasePath} {`,
         `        proxy_pass ${context.backendUrl};`,
         `        include ${context.snippetsDir}/proxy-location.conf;`,
@@ -525,65 +579,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 +717,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 +758,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 +785,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 +808,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 +826,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,
@@ -893,6 +994,7 @@ function buildNginxOtherLocation(appPublicPath, v2PublicPath, modernClientPrefix
 function renderNginxLocationTemplate(context) {
     const proxyPassBlock = buildNginxProxyPassBlock(context.proxyHost, context.apiPort);
     const wsProxyPassTarget = `http://${context.proxyHost}:${context.apiPort}${context.wsPath}`;
+    const apiBasePathNoTrailingSlash = trimTrailingSlash(context.apiBasePath);
     return `    location ~* ^${context.appPublicPath}storage/uploads/(.*\\.md)$ {
         alias ${context.uploadsPath}/$1;
         default_type text/markdown;
@@ -938,6 +1040,10 @@ function renderNginxLocationTemplate(context) {
         ${proxyPassBlock}
     }${context.otherLocation}
 
+    location = ${apiBasePathNoTrailingSlash} {
+        return 308 ${context.apiBasePath}$is_args$args;
+    }
+
     location ^~ ${context.apiBasePath} {
         ${proxyPassBlock}
     }

package/dist/lib/prompt-validators.js

@@ -10,7 +10,7 @@ import { spawn } from 'node:child_process';
 import net from 'node:net';
 import { translateCli } from "./cli-locale.js";
 const API_BASE_URL_EXAMPLE = 'http://localhost:13000/api';
-const ENV_KEY_PATTERN = /^[A-Za-z0-9]+$/;
+const ENV_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
 const APP_PUBLIC_PATH_PATTERN = /^\/(?:[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*)?\/?$/;
 const TCP_PORT_EXAMPLE = '13000';
 const API_BASE_URL_REQUEST_TIMEOUT_MS = 5_000;

package/dist/lib/proxy-caddy.js

@@ -9,14 +9,17 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
+import { loadAuthConfig } from './auth-store.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 { run } from './run-npm.js';
+import { applyEnvProxyAppEntryOptions, buildManualEnvProxyCaddyBundle, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
+import { normalizeEnvProxyConfig } from './env-proxy-config.js';
+import { commandOutput, run } from './run-npm.js';
 const DOCKER_CADDY_PROXY_CONTAINER_SUFFIX = 'caddy-proxy';
 const DOCKER_CADDY_PROXY_IMAGE = 'caddy:latest';
 const DOCKER_CADDY_PROXY_RUNTIME_ROOT = '/apps';
 const DOCKER_CADDY_PROXY_CONF_DESTINATION = '/etc/caddy/Caddyfile';
+const DEFAULT_DOCKER_CADDY_PROXY_PUBLISHED_PORTS = [80, 443];
 async function readOptionalTextFile(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -62,8 +65,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 +86,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');
 }
@@ -149,11 +174,16 @@ async function reloadLocalCaddyProxy(runtimeContext) {
 }
 async function ensureDockerCaddyProxyContainer(runtimeContext) {
     const containerName = await resolveCaddyProxyContainerName();
+    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const publishedPorts = await resolveDockerCaddyPublishedPorts();
     if (await dockerContainerExists(containerName)) {
-        return;
+        if (await dockerCaddyProxyContainerMatchesPublishedPorts(containerName, publishedPorts)) {
+            return;
+        }
+        await removeDockerCaddyProxyContainer(containerName);
     }
     const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
-    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const dockerPortArgs = publishedPorts.flatMap((port) => ['-p', `${port}:${port}`]);
     await run('docker', [
         'run',
         '-d',
@@ -161,8 +191,7 @@ async function ensureDockerCaddyProxyContainer(runtimeContext) {
         containerName,
         '--add-host',
         'host.docker.internal:host-gateway',
-        '-p',
-        '80:80',
+        ...dockerPortArgs,
         '-v',
         `${hostCliRoot}:${DOCKER_CADDY_PROXY_RUNTIME_ROOT}`,
         '-v',
@@ -173,14 +202,53 @@ async function ensureDockerCaddyProxyContainer(runtimeContext) {
         stdio: 'ignore',
     });
 }
+async function resolveDockerCaddyPublishedPorts() {
+    const config = await loadAuthConfig();
+    const ports = new Set(DEFAULT_DOCKER_CADDY_PROXY_PUBLISHED_PORTS);
+    for (const envConfig of Object.values(config.envs)) {
+        const port = normalizeEnvProxyConfig(envConfig.proxy)?.port;
+        if (port !== undefined) {
+            ports.add(port);
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function readDockerCaddyPublishedPorts(containerName) {
+    const output = await commandOutput('docker', ['inspect', '--format', '{{json .HostConfig.PortBindings}}', containerName], { errorName: 'docker inspect' });
+    const parsed = JSON.parse(output.trim() || '{}');
+    const ports = new Set();
+    for (const bindings of Object.values(parsed)) {
+        if (!Array.isArray(bindings)) {
+            continue;
+        }
+        for (const binding of bindings) {
+            const port = Number.parseInt(String(binding?.HostPort ?? '').trim(), 10);
+            if (Number.isInteger(port) && port > 0) {
+                ports.add(port);
+            }
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function dockerCaddyProxyContainerMatchesPublishedPorts(containerName, expectedPorts) {
+    const currentPorts = await readDockerCaddyPublishedPorts(containerName);
+    return currentPorts.length === expectedPorts.length && currentPorts.every((port, index) => port === expectedPorts[index]);
+}
+async function removeDockerCaddyProxyContainer(containerName) {
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: 'ignore',
+    });
+}
 async function startDockerCaddyProxy(runtimeContext) {
     const containerName = await resolveCaddyProxyContainerName();
     await ensureCaddyProxyMainConfig(runtimeContext);
-    if (await dockerContainerExists(containerName)) {
+    const existedBeforeEnsure = await dockerContainerExists(containerName);
+    await ensureDockerCaddyProxyContainer(runtimeContext);
+    if (existedBeforeEnsure && (await dockerContainerExists(containerName))) {
         const state = await startDockerContainer(containerName, { stdio: 'ignore' });
         return state === 'already-running' ? 'already-running' : 'started';
     }
-    await ensureDockerCaddyProxyContainer(runtimeContext);
     return 'started';
 }
 async function stopDockerCaddyProxy() {

package/dist/lib/proxy-nginx.js

@@ -9,14 +9,17 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
+import { loadAuthConfig } from './auth-store.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 { run } from './run-npm.js';
+import { applyEnvProxyAppEntryOptions, appConfigHasManagedNginxBlock, buildManualEnvProxyNginxBundle, buildEnvProxyMainConfig, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, mapProxyPathFromCliRoot, reloadEnvProxyProvider, resolveEnvProxyMainOutputPath, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from './env-proxy.js';
+import { normalizeEnvProxyConfig } from './env-proxy-config.js';
+import { commandOutput, run } from './run-npm.js';
 const DOCKER_NGINX_PROXY_CONTAINER_SUFFIX = 'nginx-proxy';
 const DOCKER_NGINX_PROXY_IMAGE = 'nginx:latest';
 const DOCKER_NGINX_PROXY_RUNTIME_ROOT = '/apps';
 const DOCKER_NGINX_PROXY_CONF_DESTINATION = '/etc/nginx/conf.d/default.conf';
+const DEFAULT_DOCKER_NGINX_PROXY_PUBLISHED_PORTS = [80, 443];
 async function readOptionalTextFile(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -66,11 +69,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 +94,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 })]);
@@ -217,11 +234,16 @@ async function reloadLocalNginxProxy(runtimeContext) {
 }
 async function ensureDockerNginxProxyContainer(runtimeContext) {
     const containerName = await resolveNginxProxyContainerName();
+    const mainConfigPath = await ensureNginxProxyMainConfig(runtimeContext);
+    const publishedPorts = await resolveDockerNginxPublishedPorts();
     if (await dockerContainerExists(containerName)) {
-        return;
+        if (await dockerNginxProxyContainerMatchesPublishedPorts(containerName, publishedPorts)) {
+            return;
+        }
+        await removeDockerNginxProxyContainer(containerName);
     }
     const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
-    const mainConfigPath = await ensureNginxProxyMainConfig(runtimeContext);
+    const dockerPortArgs = publishedPorts.flatMap((port) => ['-p', `${port}:${port}`]);
     await run('docker', [
         'run',
         '-d',
@@ -229,8 +251,7 @@ async function ensureDockerNginxProxyContainer(runtimeContext) {
         containerName,
         '--add-host',
         'host.docker.internal:host-gateway',
-        '-p',
-        '80:80',
+        ...dockerPortArgs,
         '-v',
         `${hostCliRoot}:${DOCKER_NGINX_PROXY_RUNTIME_ROOT}`,
         '-v',
@@ -241,14 +262,53 @@ async function ensureDockerNginxProxyContainer(runtimeContext) {
         stdio: 'ignore',
     });
 }
+async function resolveDockerNginxPublishedPorts() {
+    const config = await loadAuthConfig();
+    const ports = new Set(DEFAULT_DOCKER_NGINX_PROXY_PUBLISHED_PORTS);
+    for (const envConfig of Object.values(config.envs)) {
+        const port = normalizeEnvProxyConfig(envConfig.proxy)?.port;
+        if (port !== undefined) {
+            ports.add(port);
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function readDockerNginxPublishedPorts(containerName) {
+    const output = await commandOutput('docker', ['inspect', '--format', '{{json .HostConfig.PortBindings}}', containerName], { errorName: 'docker inspect' });
+    const parsed = JSON.parse(output.trim() || '{}');
+    const ports = new Set();
+    for (const bindings of Object.values(parsed)) {
+        if (!Array.isArray(bindings)) {
+            continue;
+        }
+        for (const binding of bindings) {
+            const port = Number.parseInt(String(binding?.HostPort ?? '').trim(), 10);
+            if (Number.isInteger(port) && port > 0) {
+                ports.add(port);
+            }
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function dockerNginxProxyContainerMatchesPublishedPorts(containerName, expectedPorts) {
+    const currentPorts = await readDockerNginxPublishedPorts(containerName);
+    return currentPorts.length === expectedPorts.length && currentPorts.every((port, index) => port === expectedPorts[index]);
+}
+async function removeDockerNginxProxyContainer(containerName) {
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: 'ignore',
+    });
+}
 async function startDockerNginxProxy(runtimeContext) {
     const containerName = await resolveNginxProxyContainerName();
     await ensureNginxProxyMainConfig(runtimeContext);
-    if (await dockerContainerExists(containerName)) {
+    const existedBeforeEnsure = await dockerContainerExists(containerName);
+    await ensureDockerNginxProxyContainer(runtimeContext);
+    if (existedBeforeEnsure && (await dockerContainerExists(containerName))) {
         const state = await startDockerContainer(containerName, { stdio: 'ignore' });
         return state === 'already-running' ? 'already-running' : 'started';
     }
-    await ensureDockerNginxProxyContainer(runtimeContext);
     return 'started';
 }
 async function stopDockerNginxProxy() {

package/dist/lib/run-npm.js

@@ -44,6 +44,10 @@ const MISSING_COMMAND_SPECS = {
         displayName: 'Yarn',
         configKey: 'bin.yarn',
     },
+    pnpm: {
+        displayName: 'pnpm',
+        configKey: 'bin.pnpm',
+    },
 };
 const DOCKER_DAEMON_UNAVAILABLE_PATTERNS = [
     /cannot connect to the docker daemon/i,