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

package/dist/lib/docker-image.js

@@ -9,7 +9,30 @@
 export const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
 export const DEFAULT_DOCKER_REGISTRY_ZH_CN = 'registry.cn-shanghai.aliyuncs.com/nocobase/nocobase';
 export const DEFAULT_DOCKER_VERSION = 'alpha';
+export const NB_IMAGE_REGISTRY_OPTIONS = ['dockerhub', 'aliyun'];
+export const DEFAULT_NB_IMAGE_REGISTRY = 'dockerhub';
+export const NB_IMAGE_VARIANT_OPTIONS = ['standard', 'no-nginx', 'full', 'full-no-nginx'];
+export const DEFAULT_NB_IMAGE_VARIANT = 'full';
 export const DOCKER_IMAGE_FULL_SUFFIX = '-full';
+export const DOCKER_IMAGE_NO_NGINX_SUFFIX = '-no-nginx';
+export const DOCKER_IMAGE_FULL_NO_NGINX_SUFFIX = '-full-no-nginx';
+export const DEFAULT_KINGBASE_IMAGE = 'registry.cn-shanghai.aliyuncs.com/nocobase/kingbase:v009r001c001b0030_single_x86';
+const OFFICIAL_DOCKER_REGISTRY_REPOSITORIES = {
+    dockerhub: DEFAULT_DOCKER_REGISTRY,
+    aliyun: DEFAULT_DOCKER_REGISTRY_ZH_CN,
+};
+const DEFAULT_BUILTIN_DB_IMAGES = {
+    postgres: 'postgres:16',
+    mysql: 'mysql:8',
+    mariadb: 'mariadb:11',
+    kingbase: DEFAULT_KINGBASE_IMAGE,
+};
+const ALIYUN_BUILTIN_DB_IMAGES = {
+    postgres: 'registry.cn-shanghai.aliyuncs.com/nocobase/postgres:16',
+    mysql: 'registry.cn-shanghai.aliyuncs.com/nocobase/mysql:8',
+    mariadb: 'registry.cn-shanghai.aliyuncs.com/nocobase/mariadb:11',
+    kingbase: DEFAULT_KINGBASE_IMAGE,
+};
 const OFFICIAL_FULL_IMAGE_REGISTRIES = new Set([
     DEFAULT_DOCKER_REGISTRY,
     DEFAULT_DOCKER_REGISTRY_ZH_CN,
@@ -17,21 +40,86 @@ const OFFICIAL_FULL_IMAGE_REGISTRIES = new Set([
 function trimValue(value) {
     return String(value ?? '').trim();
 }
+export function normalizeNbImageRegistry(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return NB_IMAGE_REGISTRY_OPTIONS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+export function normalizeNbImageVariant(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return NB_IMAGE_VARIANT_OPTIONS.includes(normalized)
+        ? normalized
+        : undefined;
+}
+export function resolveOfficialDockerRegistry(value) {
+    const registry = normalizeNbImageRegistry(value) ?? DEFAULT_NB_IMAGE_REGISTRY;
+    return OFFICIAL_DOCKER_REGISTRY_REPOSITORIES[registry];
+}
+export function inferNbImageRegistryFromRepository(value) {
+    const repository = trimValue(value);
+    return Object.entries(OFFICIAL_DOCKER_REGISTRY_REPOSITORIES).find(([, candidate]) => candidate === repository)?.[0];
+}
+function hasKnownVariantSuffix(tag) {
+    return (tag.endsWith(DOCKER_IMAGE_FULL_NO_NGINX_SUFFIX) ||
+        tag.endsWith(DOCKER_IMAGE_NO_NGINX_SUFFIX) ||
+        tag.endsWith(DOCKER_IMAGE_FULL_SUFFIX));
+}
 export function shouldUseFullDockerImageTag(registry) {
     return OFFICIAL_FULL_IMAGE_REGISTRIES.has(trimValue(registry));
 }
-export function normalizeDockerImageTag(registry, version) {
+export function normalizeDockerImageTag(registry, version, options) {
     const tag = trimValue(version) || DEFAULT_DOCKER_VERSION;
-    if (!shouldUseFullDockerImageTag(registry)) {
+    if (hasKnownVariantSuffix(tag)) {
         return tag;
     }
-    return tag.endsWith(DOCKER_IMAGE_FULL_SUFFIX)
-        ? tag
-        : `${tag}${DOCKER_IMAGE_FULL_SUFFIX}`;
+    const explicitVariant = normalizeNbImageVariant(options?.variant) ?? normalizeNbImageVariant(options?.defaultVariant);
+    const inferredVariant = shouldUseFullDockerImageTag(registry) ? DEFAULT_NB_IMAGE_VARIANT : 'standard';
+    const variant = explicitVariant ?? inferredVariant;
+    switch (variant) {
+        case 'standard':
+            return tag;
+        case 'no-nginx':
+            return `${tag}${DOCKER_IMAGE_NO_NGINX_SUFFIX}`;
+        case 'full':
+            return `${tag}${DOCKER_IMAGE_FULL_SUFFIX}`;
+        case 'full-no-nginx':
+            return `${tag}${DOCKER_IMAGE_FULL_NO_NGINX_SUFFIX}`;
+    }
 }
 export function resolveDockerImageRef(registry, version, options) {
     const resolvedRegistry = trimValue(registry) || options?.defaultRegistry || DEFAULT_DOCKER_REGISTRY;
     const rawVersion = trimValue(version) || options?.defaultVersion || DEFAULT_DOCKER_VERSION;
-    const normalizedTag = normalizeDockerImageTag(resolvedRegistry, rawVersion);
+    const normalizedTag = normalizeDockerImageTag(resolvedRegistry, rawVersion, {
+        variant: options?.variant,
+        defaultVariant: options?.defaultVariant,
+    });
     return `${resolvedRegistry}:${normalizedTag}`;
 }
+function extractDockerImageTag(imageRef) {
+    const ref = trimValue(imageRef);
+    const lastSlashIndex = ref.lastIndexOf('/');
+    const lastColonIndex = ref.lastIndexOf(':');
+    if (lastColonIndex <= lastSlashIndex) {
+        return undefined;
+    }
+    return ref.slice(lastColonIndex + 1) || undefined;
+}
+export function resolveDockerImageContainerPort(imageRef) {
+    const tag = extractDockerImageTag(imageRef);
+    return tag?.endsWith(DOCKER_IMAGE_NO_NGINX_SUFFIX) ? '13000' : '80';
+}
+export function resolveBuiltinDbImage(dbDialect, options) {
+    const dialect = trimValue(dbDialect) || 'postgres';
+    const configuredRegistry = normalizeNbImageRegistry(options?.registry) ??
+        inferNbImageRegistryFromRepository(options?.registry) ??
+        DEFAULT_NB_IMAGE_REGISTRY;
+    const defaults = configuredRegistry === 'aliyun' ? ALIYUN_BUILTIN_DB_IMAGES : DEFAULT_BUILTIN_DB_IMAGES;
+    return defaults[dialect] ?? defaults.postgres;
+}

package/dist/lib/env-config.js

@@ -6,6 +6,7 @@
  * 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 { normalizeEnvProxyConfig } from './env-proxy-config.js';
 import { resolveAppPublicPath } from './app-public-path.js';
 const STRING_ENV_CONFIG_KEYS = [
     'source',
@@ -110,5 +111,9 @@ export function buildStoredEnvConfig(input) {
     if ((authType === 'basic' || authType === 'token') && accessToken) {
         envConfig.accessToken = accessToken;
     }
+    const proxy = normalizeEnvProxyConfig(input.proxy);
+    if (proxy) {
+        envConfig.proxy = proxy;
+    }
     return envConfig;
 }

package/dist/lib/env-proxy-config.js

@@ -0,0 +1,48 @@
+/**
+ * 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 normalizeOptionalString(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized || undefined;
+}
+function normalizeOptionalPort(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized || !/^\d+$/.test(normalized)) {
+        return undefined;
+    }
+    const port = Number(normalized);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return undefined;
+    }
+    return port;
+}
+export function normalizeEnvProxyProviderConfig(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    return { ...value };
+}
+export function normalizeEnvProxyConfig(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const proxy = value;
+    const host = normalizeOptionalString(proxy.host);
+    const port = normalizeOptionalPort(proxy.port);
+    const nginx = normalizeEnvProxyProviderConfig(proxy.nginx);
+    const caddy = normalizeEnvProxyProviderConfig(proxy.caddy);
+    if (!host && port === undefined && !nginx && !caddy) {
+        return undefined;
+    }
+    return {
+        ...(host ? { host } : {}),
+        ...(port !== undefined ? { port } : {}),
+        ...(nginx ? { nginx } : {}),
+        ...(caddy ? { caddy } : {}),
+    };
+}

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}
     }