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

package/assets/env-proxy/nginx/snippets/proxy-location.conf

@@ -15,3 +15,4 @@ proxy_connect_timeout 600;
 proxy_send_timeout 600;
 proxy_read_timeout 600;
 send_timeout 600;
+proxy_buffering off;

package/dist/commands/app/start.js

@@ -37,6 +37,9 @@ function buildLicenseSyncArgv(envName, options) {
 }
 function resolveHookCommand(value) {
     const text = String(value ?? '').trim();
+    if (text === 'init') {
+        return text;
+    }
     if (text === 'app:restart' || text === 'app:upgrade') {
         return text;
     }
@@ -225,7 +228,7 @@ export default class AppStart extends Command {
         }),
         'hook-command': Flags.string({
             hidden: true,
-            options: ['app:start', 'app:restart', 'app:upgrade'],
+            options: ['init', 'app:start', 'app:restart', 'app:upgrade'],
         }),
     };
     async run() {

package/dist/commands/install.js

@@ -2253,6 +2253,13 @@ export default class Install extends Command {
         }
         await this.config.runCommand('env:update', [params.envName]);
     }
+    buildAppStartArgv(params) {
+        const argv = ['--env', params.envName, '--yes', '--no-sync-licensed-plugins', '--hook-command', 'init'];
+        if (params.verbose) {
+            argv.push('--verbose');
+        }
+        return argv;
+    }
     async runInstallHookIfNeeded(params) {
         const appPath = Install.resolveAbsoluteAppPath(params.envName, params.appResults);
         const savedHookScript = Install.toOptionalPromptString(params.appResults.hookScript);
@@ -2497,7 +2504,6 @@ export default class Install extends Command {
         const parsed = {
             ...flags,
         };
-        const defaultApiHost = await resolveDefaultApiHost();
         if (parsed['skip-auth'] && (parsed['access-token'] !== undefined || parsed.token !== undefined)) {
             this.error('--skip-auth cannot be used with --access-token or --token.');
         }
@@ -2577,8 +2583,7 @@ export default class Install extends Command {
             dbResults.dbUser = builtinDbPlan.dbUser;
             dbResults.dbPassword = builtinDbPlan.dbPassword;
         }
-        let dockerAppPlan;
-        let localAppPlan;
+        let shouldStartApp = false;
         if (source === 'docker' || source === 'npm' || source === 'git') {
             this.logStage('Preparing application');
             if (source === 'docker') {
@@ -2590,111 +2595,28 @@ export default class Install extends Command {
                     printInfo('Application image ready.');
                 }
                 if (!parsed['prepare-only']) {
-                    await this.runInstallHookIfNeeded({
-                        hookName: 'beforeAppInstall',
-                        envName,
-                        source,
-                        appResults,
-                        downloadResults,
-                        dbResults,
-                        rootResults,
-                        envAddResults,
-                        defaultApiHost,
-                    });
-                    dockerAppPlan = await this.installDockerApp({
-                        envName,
-                        dockerNetworkName,
-                        dockerContainerPrefix,
-                        appResults,
-                        downloadResults,
-                        dbResults,
-                        rootResults,
-                        builtinDbPlan,
-                        force: parsed.force,
-                        commandStdio,
-                    });
-                    appResults.appKey = dockerAppPlan.appKey;
-                    appResults.timeZone = dockerAppPlan.timeZone;
+                    shouldStartApp = true;
                 }
             }
             else if (source === 'npm' || source === 'git') {
-                const localSource = source === 'npm' ? 'npm' : 'git';
-                const projectRoot = parsed['skip-download'] || parsed['prepare-only']
-                    ? Install.resolveLocalProjectRoot({
-                        envName,
-                        appResults,
-                        downloadResults,
-                    })
-                    : await this.downloadLocalApp({
+                if (!parsed['skip-download'] && !parsed['prepare-only']) {
+                    await this.downloadLocalApp({
                         envName,
                         appResults,
                         downloadResults,
                         verbose: parsed.verbose,
                     });
-                if (!parsed['skip-download'] && !parsed['prepare-only']) {
                     printInfo('Application files ready.');
                 }
                 if (!parsed['prepare-only']) {
-                    await this.runInstallHookIfNeeded({
-                        hookName: 'beforeAppInstall',
-                        envName,
-                        source,
-                        appResults,
-                        downloadResults,
-                        dbResults,
-                        rootResults,
-                        envAddResults,
-                        projectRoot,
-                        defaultApiHost,
-                    });
-                    localAppPlan = await this.startLocalApp({
-                        envName,
-                        source: localSource,
-                        projectRoot,
-                        appResults,
-                        dbResults,
-                        rootResults,
-                        commandStdio,
-                    });
-                    appResults.appKey = localAppPlan.appKey;
-                    appResults.timeZone = localAppPlan.timeZone;
+                    shouldStartApp = true;
                 }
             }
         }
         else {
             this.logDetail('Skipped app download and install.');
         }
-        if (dockerAppPlan || localAppPlan) {
-            this.logStage('Starting NocoBase');
-            await this.waitForAppHealthCheck(Install.resolveApiBaseUrl({
-                appResults,
-                envAddResults,
-                defaultApiHost,
-            }), {
-                containerName: dockerAppPlan?.containerName,
-                verbose: parsed.verbose,
-            });
-            const displayApiBaseUrl = Install.resolveApiBaseUrl({
-                appResults,
-                envAddResults,
-                defaultApiHost,
-            });
-            printInfo(`NocoBase is ready at ${formatInstallDisplayUrl(displayApiBaseUrl)}`);
-            appResults.setupState = 'installed';
-            await this.runInstallHookIfNeeded({
-                hookName: 'afterAppStart',
-                envName,
-                source,
-                appResults,
-                downloadResults,
-                dbResults,
-                rootResults,
-                envAddResults,
-                projectRoot: localAppPlan?.projectRoot,
-                defaultApiHost,
-            });
-        }
-        if (dockerAppPlan || localAppPlan || builtinDbPlan) {
+        if (shouldStartApp || builtinDbPlan) {
             await this.saveInstalledEnv({
                 envName,
                 appResults,
@@ -2704,10 +2626,14 @@ export default class Install extends Command {
                 envAddResults,
             });
         }
+        if (shouldStartApp) {
+            this.logStage('Starting NocoBase');
+            await this.config.runCommand('app:start', this.buildAppStartArgv({ envName, verbose: parsed.verbose }));
+        }
         await this.syncInstalledEnvConnection({
             envName,
             envAddResults,
-            appReady: Boolean(dockerAppPlan || localAppPlan),
+            appReady: shouldStartApp,
             skipAuth: Boolean(parsed['skip-auth']),
         });
         if (!parsed['prepare-only']) {
@@ -2716,7 +2642,7 @@ export default class Install extends Command {
         if (parsed['prepare-only']) {
             printInfo(`Preparation complete for "${envName}". Activate the license, then run \`nb app start --env ${envName}\`.`);
         }
-        else if (!dockerAppPlan && !localAppPlan) {
+        else if (!shouldStartApp) {
             printInfo(`Install config for "${envName}" has been saved.`);
         }
     }

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

@@ -8,6 +8,8 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.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';
@@ -129,12 +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,7 +8,9 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.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';
@@ -132,13 +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/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) {
@@ -516,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];

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

@@ -487,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
@@ -525,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;`,
@@ -989,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;
@@ -1034,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/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, buildManualEnvProxyCaddyBundle, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
-import { run } from './run-npm.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');
@@ -171,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',
@@ -183,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',
@@ -195,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, buildManualEnvProxyNginxBundle, buildEnvProxyMainConfig, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, mapProxyPathFromCliRoot, reloadEnvProxyProvider, resolveEnvProxyMainOutputPath, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from './env-proxy.js';
-import { run } from './run-npm.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');
@@ -231,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',
@@ -243,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',
@@ -255,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.2.0-alpha.5",
+  "version": "2.2.0-alpha.6",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -144,5 +144,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "814ff497dd1233ca7218c9f7f2a016c2ead6516d"
+  "gitHead": "f55b252811f6af01d08cd3814171867b70c8ef7a"
 }