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

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

@@ -8,20 +8,51 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getCaddyProxyDriver, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
+import { resolveEnvProxyEntry, setEnvProxyEntry } from '../../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { getCaddyProxyDriver, writeManualCaddyProxyBundle, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
 import { normalizeProxyListenPort } from '../../../lib/proxy-nginx.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyCaddyGenerate extends Command {
     static summary = 'Generate caddy proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy caddy generate --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy caddy 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/caddy 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 caddy reverse_proxy in manual mode',
+        }),
+        'upstream-port': Flags.string({
+            description: 'Upstream port used by caddy reverse_proxy in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
         }),
         host: Flags.string({
             description: 'Host exposed by the caddy site block, such as example.com or localhost',
@@ -35,9 +66,56 @@ export default class ProxyCaddyGenerate 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 getCaddyProxyDriver();
+            const runtimeContext = await resolveCaddyProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating caddy proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualCaddyProxyBundle({
+                    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, {
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
+                    : `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate caddy 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));
@@ -53,10 +131,18 @@ export default class ProxyCaddyGenerate extends Command {
         announceTargetEnv(runtime.envName);
         startTask(`Generating caddy proxy config for env "${runtime.envName}" with the ${driver} driver...`);
         try {
-            const { bundle, status } = await writeCaddyProxyBundle(runtime, {
-                host: flags.host?.trim() || undefined,
-                port: normalizedPort,
-            }, runtimeContext);
+            const savedAppEntryOptions = resolveEnvProxyEntry(runtime.env.config, 'caddy');
+            const appEntryOptions = {
+                host: flags.host?.trim() || savedAppEntryOptions?.host,
+                port: normalizedPort ?? (savedAppEntryOptions?.port !== undefined ? String(savedAppEntryOptions.port) : undefined),
+            };
+            const { bundle, status } = await writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+            });
+            await setEnvProxyEntry(runtime.envName, 'caddy', {
+                host: appEntryOptions.host,
+                port: appEntryOptions.port ? Number(appEntryOptions.port) : undefined,
+            }, { scope: resolveDefaultConfigScope() });
             succeedTask(status === 'created'
                 ? `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
                 : `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);

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

@@ -8,19 +8,54 @@
  */
 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 { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeManualNginxProxyBundle, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { resolveEnvProxyEntry, setEnvProxyEntry } from '../../../lib/auth-store.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 +69,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));
@@ -52,10 +134,19 @@ export default class ProxyNginxGenerate extends Command {
         announceTargetEnv(runtime.envName);
         startTask(`Generating nginx proxy config for env "${runtime.envName}" with the ${driver} driver...`);
         try {
-            const { bundle, status } = await writeNginxProxyBundle(runtime, {
-                host: flags.host?.trim() || undefined,
-                port: normalizedPort,
-            }, runtimeContext);
+            const savedAppEntryOptions = resolveEnvProxyEntry(runtime.env.config, 'nginx');
+            const appEntryOptions = {
+                host: flags.host?.trim() || savedAppEntryOptions?.host,
+                port: normalizedPort ?? (savedAppEntryOptions?.port !== undefined ? String(savedAppEntryOptions.port) : undefined),
+            };
+            const { bundle, status } = await writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                force: flags.force,
+            });
+            await setEnvProxyEntry(runtime.envName, 'nginx', {
+                host: appEntryOptions.host,
+                port: appEntryOptions.port ? Number(appEntryOptions.port) : undefined,
+            }, { scope: resolveDefaultConfigScope() });
             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/self/update.js

@@ -26,7 +26,7 @@ function formatSkillsUpdateMessage(result, verbose) {
 }
 export default class SelfUpdate extends Command {
     static summary = 'Update the globally installed NocoBase CLI';
-    static description = 'Update the current NocoBase CLI install when it is managed by a standard global npm install.';
+    static description = 'Update the current NocoBase CLI install when it is managed by a standard global npm, pnpm, or yarn install.';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --yes',
@@ -77,7 +77,7 @@ export default class SelfUpdate extends Command {
                     message: flags.skills
                         ? `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion} and refresh the globally installed NocoBase AI coding skills?`
                         : `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion}?`,
-                    default: false,
+                    default: true,
                 });
             }
             catch {

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

@@ -11,6 +11,7 @@ import path from 'node:path';
 import { resolveAppPublicPath } from './app-public-path.js';
 import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
 import { normalizeCliLocale } from './cli-locale.js';
+import { normalizeEnvProxyConfig, normalizeEnvProxyProviderConfig, } from './env-proxy-config.js';
 import { inferConfiguredAppPathFromLegacyConfig, resolveConfiguredAppPath, resolveConfiguredSourcePath, resolveConfiguredStoragePath, } from './env-paths.js';
 import { ENV_CONFIG_SCHEMA_VERSION, normalizeEnvConfigSchemaVersion } from './env-config.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
@@ -81,12 +82,14 @@ function normalizeEnvConfigEntry(entry) {
     const normalizedKind = resolveEnvKind(entry);
     const apiBaseUrl = readEnvApiBaseUrl(entry);
     const schemaVersion = normalizeEnvConfigSchemaVersion(entry.schemaVersion);
+    const proxy = normalizeEnvProxyConfig(entry.proxy);
     return {
         ...rest,
         ...(schemaVersion ? { schemaVersion } : {}),
         ...(normalizedKind ? { kind: normalizedKind } : {}),
         ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
         ...(normalizeOptionalString(entry.appPublicPath) ? { appPublicPath: resolveAppPublicPath(entry.appPublicPath) } : {}),
+        ...(proxy ? { proxy } : {}),
     };
 }
 function normalizeAuthConfig(config) {
@@ -99,6 +102,17 @@ function normalizeAuthConfig(config) {
         ? settings.log.retentionDays
         : undefined;
     const logEnabled = typeof settings.log?.enabled === 'boolean' ? settings.log.enabled : undefined;
+    const hasBinSettings = settings.bin?.docker ||
+        settings.bin?.caddy ||
+        settings.bin?.git ||
+        settings.bin?.nginx ||
+        settings.bin?.pnpm ||
+        settings.bin?.yarn;
+    const hasProxySettings = settings.proxy?.nbCliRoot ||
+        settings.proxy?.caddyDriver ||
+        settings.proxy?.nginxDriver ||
+        settings.proxy?.upstreamHost ||
+        settings.proxy?.host;
     return {
         name: config.name || config.dockerResourcePrefix,
         settings: {
@@ -114,31 +128,35 @@ 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) }
+                            : {}),
                     },
                 }
                 : {}),
-            ...(settings.bin?.docker || settings.bin?.caddy || settings.bin?.git || settings.bin?.nginx || settings.bin?.yarn
+            ...(hasBinSettings
                 ? {
                     bin: {
                         ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
                         ...(settings.bin?.caddy ? { caddy: normalizeOptionalString(settings.bin.caddy) } : {}),
                         ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
                         ...(settings.bin?.nginx ? { nginx: normalizeOptionalString(settings.bin.nginx) } : {}),
+                        ...(settings.bin?.pnpm ? { pnpm: normalizeOptionalString(settings.bin.pnpm) } : {}),
                         ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
                     },
                 }
                 : {}),
-            ...(settings.proxy?.nbCliRoot ||
-                settings.proxy?.caddyDriver ||
-                settings.proxy?.nginxDriver ||
-                settings.proxy?.upstreamHost ||
-                settings.proxy?.host
+            ...(hasProxySettings
                 ? {
                     proxy: {
                         ...(settings.proxy?.nbCliRoot ? { nbCliRoot: normalizeOptionalString(settings.proxy.nbCliRoot) } : {}),
@@ -501,6 +519,64 @@ export async function setEnvRuntime(envName, runtime, options = {}) {
     };
     await saveAuthConfig(config, options);
 }
+export function resolveEnvProxyEntry(config, provider) {
+    const proxy = normalizeEnvProxyConfig(config?.proxy);
+    const resolved = {
+        ...(proxy?.host ? { host: proxy.host } : {}),
+        ...(proxy?.port !== undefined ? { port: proxy.port } : {}),
+        ...((provider === 'nginx' ? proxy?.nginx : proxy?.caddy) ?? {}),
+    };
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+export async function setEnvProxyEntry(envName, provider, entry, options = {}) {
+    await writeEnv(envName, (previous) => {
+        const currentProxy = normalizeEnvProxyConfig(previous?.proxy) ?? {};
+        const nextEntry = normalizeEnvProxyProviderConfig(entry);
+        const nextProxy = { ...currentProxy };
+        if (nextEntry && 'host' in nextEntry) {
+            const host = normalizeOptionalString(nextEntry.host);
+            if (host) {
+                nextProxy.host = host;
+            }
+            else {
+                delete nextProxy.host;
+            }
+        }
+        if (nextEntry && 'port' in nextEntry) {
+            const portValue = nextEntry.port;
+            const port = typeof portValue === 'number' && Number.isInteger(portValue) && portValue >= 1 && portValue <= 65535
+                ? portValue
+                : undefined;
+            if (port !== undefined) {
+                nextProxy.port = port;
+            }
+            else {
+                delete nextProxy.port;
+            }
+        }
+        const providerConfig = nextEntry && Object.keys(nextEntry).some((key) => key !== 'host' && key !== 'port')
+            ? Object.fromEntries(Object.entries(nextEntry).filter(([key]) => key !== 'host' && key !== 'port'))
+            : undefined;
+        if (provider === 'nginx') {
+            if (providerConfig && Object.keys(providerConfig).length > 0) {
+                nextProxy.nginx = providerConfig;
+            }
+            else {
+                delete nextProxy.nginx;
+            }
+        }
+        else if (providerConfig && Object.keys(providerConfig).length > 0) {
+            nextProxy.caddy = providerConfig;
+        }
+        else {
+            delete nextProxy.caddy;
+        }
+        return {
+            ...previous,
+            proxy: nextProxy,
+        };
+    }, options);
+}
 export async function clearEnvRootSetup(envName, options = {}) {
     const config = await loadExactAuthConfig(options);
     const current = config.envs[envName];