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

package/dist/commands/proxy/nginx/generate.js

@@ -8,19 +8,52 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeManualNginxProxyBundle, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyNginxGenerate extends Command {
     static summary = 'Generate nginx proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy nginx generate --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy nginx generate --manual --name default --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0 --upstream-port 13000',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/nginx in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by nginx proxy_pass in manual mode',
+        }),
+        'upstream-port': Flags.string({
+            description: 'Upstream port used by nginx proxy_pass in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
+        }),
+        force: Flags.boolean({
+            description: 'Overwrite existing app.conf even when the managed block is missing',
+            default: false,
         }),
         host: Flags.string({
             description: 'Host exposed by the nginx entry config, such as example.com or localhost',
@@ -34,9 +67,56 @@ export default class ProxyNginxGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedUpstreamPort = flags['upstream-port']?.trim() || undefined;
+            const upstreamPort = normalizeProxyListenPort(requestedUpstreamPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedUpstreamPort && !upstreamPort) {
+                this.error(`Invalid manual upstream port "${requestedUpstreamPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !upstreamPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--upstream-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getNginxProxyDriver();
+            const runtimeContext = await resolveNginxProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating nginx proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualNginxProxyBundle({
+                    name,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    upstreamPort,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    force: flags.force,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
+                    : `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate nginx proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -55,7 +135,10 @@ export default class ProxyNginxGenerate extends Command {
             const { bundle, status } = await writeNginxProxyBundle(runtime, {
                 host: flags.host?.trim() || undefined,
                 port: normalizedPort,
-            }, runtimeContext);
+            }, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                force: flags.force,
+            });
             succeedTask(status === 'created'
                 ? `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
                 : `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);

package/dist/commands/revision/create.js

@@ -100,7 +100,7 @@ export default class RevisionCreate extends Command {
             path: '/app:publishEvent',
             body: {
                 plugin: 'plugin-version-control',
-                command: 'revision:create',
+                command: 'revision.create',
                 payload: {
                     description,
                 },

package/dist/commands/source/download.js

@@ -12,9 +12,10 @@ import path from 'node:path';
 import { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
 import { runPromptCatalog, } from "../../lib/prompt-catalog.js";
 import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, localeText, resolveCliLocale, translateCli, } from "../../lib/cli-locale.js";
-import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_REGISTRY_ZH_CN, resolveDockerImageRef, } from "../../lib/docker-image.js";
+import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_REGISTRY_ZH_CN, resolveOfficialDockerRegistry, resolveDockerImageRef, } from "../../lib/docker-image.js";
 import { getEnv } from '../../lib/auth-store.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { getCliConfigValue } from '../../lib/cli-config.js';
 import { buildBeforeDependencyInstallHookContext, runBeforeDependencyInstallHook, } from '../../lib/hook-script.js';
 import { run } from "../../lib/run-npm.js";
 import { printVerbose, setVerboseMode, startTask, stopTask, updateTask } from '../../lib/ui.js';
@@ -450,9 +451,9 @@ export default class SourceDownload extends Command {
         }
         return outputAbs;
     }
-    dockerTarPath(flags, outputAbs) {
+    async dockerTarPath(flags, outputAbs) {
         const imageRef = resolveDockerImageRef(flags['docker-registry'], flags.version, {
-            defaultRegistry: defaultDockerRegistryForLang(process.env.NB_LOCALE),
+            defaultRegistry: await this.resolveConfiguredDockerRegistryDefault(),
             defaultVersion: 'latest',
         });
         const safeBase = imageRef.replace(/[\\/:]/g, '-');
@@ -462,9 +463,11 @@ export default class SourceDownload extends Command {
      * Defaults for prompts only. Keys present in **`preset`** are omitted so `runPromptCatalog` uses
      * **`values`** (preset) alone for those steps — no duplicate prefill for skipped prompts.
      */
-    buildInitialValuesFromParsed(flags, preset) {
+    async resolveConfiguredDockerRegistryDefault() {
+        return resolveOfficialDockerRegistry(await getCliConfigValue('nb-image-registry'));
+    }
+    buildInitialValuesFromParsed(flags, preset, defaultDockerRegistry) {
         const initialValues = {};
-        const localeDefaultDockerRegistry = defaultDockerRegistryForLang(flags.locale ?? process.env.NB_LOCALE);
         const source = flags.source?.trim();
         if (source) {
             initialValues.source = source;
@@ -488,7 +491,7 @@ export default class SourceDownload extends Command {
             initialValues.dockerRegistry = String(flags['docker-registry'] ?? '').trim();
         }
         else {
-            initialValues.dockerRegistry = localeDefaultDockerRegistry;
+            initialValues.dockerRegistry = defaultDockerRegistry;
         }
         initialValues.dockerPlatform = normalizeDockerPlatform(flags['docker-platform']);
         initialValues.dockerSave = flags['docker-save'];
@@ -569,7 +572,7 @@ export default class SourceDownload extends Command {
         }
         return flags.build;
     }
-    mapCatalogResultsToResolved(results, flags) {
+    mapCatalogResultsToResolved(results, flags, defaultDockerRegistry) {
         const source = String(results.source);
         const version = resolveVersionFromResults(results, flags.version) || 'latest';
         const devDependencies = source === 'npm' ? Boolean(results.devDependencies) : undefined;
@@ -583,7 +586,7 @@ export default class SourceDownload extends Command {
         const dockerRegistry = source === 'docker'
             ? results.dockerRegistry !== undefined
                 ? String(results.dockerRegistry).trim() || undefined
-                : flags['docker-registry']?.trim() || defaultDockerRegistryForLang(flags.locale ?? process.env.NB_LOCALE)
+                : flags['docker-registry']?.trim() || defaultDockerRegistry
             : undefined;
         const dockerPlatform = source === 'docker'
             ? normalizeDockerPlatform(results.dockerPlatform !== undefined ? results.dockerPlatform : flags['docker-platform'])
@@ -628,7 +631,8 @@ export default class SourceDownload extends Command {
             this.error('Download source is required in non-interactive mode. Use --source npm, --source git, or --source docker.');
         }
         const presetValues = this.buildPresetValuesFromFlags(flags);
-        const initialValues = this.buildInitialValuesFromParsed(flags, presetValues);
+        const defaultDockerRegistry = await this.resolveConfiguredDockerRegistryDefault();
+        const initialValues = this.buildInitialValuesFromParsed(flags, presetValues, defaultDockerRegistry);
         const results = await runPromptCatalog(SourceDownload.prompts, {
             initialValues,
             values: presetValues,
@@ -654,7 +658,7 @@ export default class SourceDownload extends Command {
         if (flags['docker-save'] && source !== 'docker') {
             this.error('--docker-save is only available when --source docker is selected.');
         }
-        return this.mapCatalogResultsToResolved(results, flags);
+        return this.mapCatalogResultsToResolved(results, flags, defaultDockerRegistry);
     }
     npmRegistryUrl(flags) {
         const url = flags['npm-registry']?.trim();
@@ -784,7 +788,7 @@ export default class SourceDownload extends Command {
     }
     async downloadFromDocker(flags) {
         const imageRef = resolveDockerImageRef(flags['docker-registry'], flags.version, {
-            defaultRegistry: defaultDockerRegistryForLang(process.env.NB_LOCALE),
+            defaultRegistry: await this.resolveConfiguredDockerRegistryDefault(),
             defaultVersion: 'latest',
         });
         const platform = dockerPlatformArg(flags['docker-platform']);
@@ -811,7 +815,7 @@ export default class SourceDownload extends Command {
             await fsp.rm(outAbs, { recursive: true, force: true });
         }
         await fsp.mkdir(outAbs, { recursive: true });
-        const tarPath = this.dockerTarPath(flags, outAbs);
+        const tarPath = await this.dockerTarPath(flags, outAbs);
         this.log(`Saving Docker image tarball to ${tarPath}`);
         await this.runExternalCommand('docker', ['save', '-o', tarPath, imageRef], {
             errorName: 'docker save',

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

@@ -14,7 +14,7 @@ import { dockerContainerExists, managedAppLifecycleEnvVars, runLocalNocoBaseComm
 import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
 import { resolveConfiguredStoragePath } from './env-paths.js';
 import { resolveDockerEnvFileArg } from "./docker-env-file.js";
-import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "./docker-image.js";
+import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageContainerPort, resolveDockerImageRef, } from "./docker-image.js";
 import { resolveHookScriptPath } from './hook-script.js';
 import { commandSucceeds, ensureDockerDaemonRunning, run } from './run-npm.js';
 import Install from '../commands/install.js';
@@ -192,6 +192,7 @@ export async function buildSavedDockerRunArgs(runtime, options) {
         defaultRegistry: DEFAULT_DOCKER_REGISTRY,
         defaultVersion: DEFAULT_DOCKER_VERSION,
     });
+    const containerPort = resolveDockerImageContainerPort(imageRef);
     const missing = [];
     if (!storagePath) {
         missing.push('storagePath');
@@ -225,8 +226,6 @@ export async function buildSavedDockerRunArgs(runtime, options) {
         '-d',
         '--name',
         runtime.containerName,
-        '--restart',
-        'always',
         '--network',
         runtime.workspaceName,
     ];
@@ -235,7 +234,7 @@ export async function buildSavedDockerRunArgs(runtime, options) {
         args.push('--platform', dockerPlatform);
     }
     if (appPort) {
-        args.push('-p', `${appPort}:80`);
+        args.push('-p', `${appPort}:${containerPort}`);
     }
     if (envFile) {
         args.push('--env-file', envFile);

package/dist/lib/auth-store.js

@@ -125,12 +125,19 @@ function normalizeAuthConfig(config) {
             ...(updatePolicy ? { update: { policy: updatePolicy } } : {}),
             ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
             ...(settings.docker?.network || settings.docker?.containerPrefix
+                || settings.docker?.nbImageRegistry || settings.docker?.nbImageVariant
                 ? {
                     docker: {
                         ...(settings.docker?.network ? { network: normalizeOptionalString(settings.docker.network) } : {}),
                         ...(settings.docker?.containerPrefix
                             ? { containerPrefix: normalizeOptionalString(settings.docker.containerPrefix) }
                             : {}),
+                        ...(settings.docker?.nbImageRegistry
+                            ? { nbImageRegistry: normalizeOptionalString(settings.docker.nbImageRegistry) }
+                            : {}),
+                        ...(settings.docker?.nbImageVariant
+                            ? { nbImageVariant: normalizeOptionalString(settings.docker.nbImageVariant) }
+                            : {}),
                     },
                 }
                 : {}),

package/dist/lib/cli-config.js

@@ -9,6 +9,7 @@
 import { loadExactAuthConfig, saveAuthConfig } from './auth-store.js';
 import { resolveCliHomeRoot, resolveDefaultConfigScope } from './cli-home.js';
 import { CLI_LOCALE_FLAG_OPTIONS, normalizeCliLocale, resolveCliLocale } from './cli-locale.js';
+import { DEFAULT_NB_IMAGE_REGISTRY, DEFAULT_NB_IMAGE_VARIANT, NB_IMAGE_REGISTRY_OPTIONS, NB_IMAGE_VARIANT_OPTIONS, normalizeNbImageRegistry, normalizeNbImageVariant, } from './docker-image.js';
 export const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
 export const DEFAULT_DOCKER_NETWORK = 'nocobase';
 export const DEFAULT_DOCKER_CONTAINER_PREFIX = 'nb';
@@ -37,6 +38,8 @@ export const SUPPORTED_CLI_CONFIG_KEYS = [
     'license.pkg-url',
     'docker.network',
     'docker.container-prefix',
+    'nb-image-registry',
+    'nb-image-variant',
     'bin.docker',
     'bin.caddy',
     'bin.git',
@@ -129,7 +132,11 @@ function pruneSettings(config) {
         delete config.settings?.license;
     }
     const docker = config.settings?.docker;
-    if (docker && !trimValue(docker.network) && !trimValue(docker.containerPrefix)) {
+    if (docker &&
+        !trimValue(docker.network) &&
+        !trimValue(docker.containerPrefix) &&
+        !trimValue(docker.nbImageRegistry) &&
+        !trimValue(docker.nbImageVariant)) {
         delete config.settings?.docker;
     }
     const bin = config.settings?.bin;
@@ -182,6 +189,10 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.docker?.network);
         case 'docker.container-prefix':
             return trimValue(config.settings?.docker?.containerPrefix);
+        case 'nb-image-registry':
+            return normalizeNbImageRegistry(config.settings?.docker?.nbImageRegistry);
+        case 'nb-image-variant':
+            return normalizeNbImageVariant(config.settings?.docker?.nbImageVariant);
         case 'bin.docker':
             return trimValue(config.settings?.bin?.docker);
         case 'bin.caddy':
@@ -230,6 +241,10 @@ export function getEffectiveCliConfigValue(config, key) {
             return trimValue(config.name) || DEFAULT_DOCKER_NETWORK;
         case 'docker.container-prefix':
             return trimValue(config.name) || DEFAULT_DOCKER_CONTAINER_PREFIX;
+        case 'nb-image-registry':
+            return explicit ?? DEFAULT_NB_IMAGE_REGISTRY;
+        case 'nb-image-variant':
+            return explicit ?? DEFAULT_NB_IMAGE_VARIANT;
         case 'bin.docker':
             return DEFAULT_DOCKER_BIN;
         case 'bin.caddy':
@@ -305,6 +320,20 @@ export function normalizeCliConfigValue(key, value) {
         }
         return driver;
     }
+    if (key === 'nb-image-registry') {
+        const registry = normalizeNbImageRegistry(normalized);
+        if (!registry) {
+            throw new Error(`Config key "${key}" must be one of: ${NB_IMAGE_REGISTRY_OPTIONS.join(', ')}`);
+        }
+        return registry;
+    }
+    if (key === 'nb-image-variant') {
+        const variant = normalizeNbImageVariant(normalized);
+        if (!variant) {
+            throw new Error(`Config key "${key}" must be one of: ${NB_IMAGE_VARIANT_OPTIONS.join(', ')}`);
+        }
+        return variant;
+    }
     return normalized;
 }
 export async function loadCliConfig(options = {}) {
@@ -370,6 +399,18 @@ export async function setCliConfigValue(key, value, options = {}) {
                 containerPrefix: normalized,
             };
             break;
+        case 'nb-image-registry':
+            config.settings.docker = {
+                ...(config.settings.docker ?? {}),
+                nbImageRegistry: normalized,
+            };
+            break;
+        case 'nb-image-variant':
+            config.settings.docker = {
+                ...(config.settings.docker ?? {}),
+                nbImageVariant: normalized,
+            };
+            break;
         case 'bin.docker':
             config.settings.bin = {
                 ...(config.settings.bin ?? {}),
@@ -489,6 +530,16 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.docker.containerPrefix;
             }
             break;
+        case 'nb-image-registry':
+            if (config.settings.docker) {
+                delete config.settings.docker.nbImageRegistry;
+            }
+            break;
+        case 'nb-image-variant':
+            if (config.settings.docker) {
+                delete config.settings.docker.nbImageVariant;
+            }
+            break;
         case 'bin.docker':
             if (config.settings.bin) {
                 delete config.settings.bin.docker;

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