@nocobase/cli 2.2.0-beta.8 → 2.3.0-alpha.1

package/dist/lib/proxy-caddy.js

@@ -9,14 +9,17 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
+import { loadAuthConfig } from './auth-store.js';
 import { CADDY_PROXY_DRIVER_OPTIONS, DEFAULT_CADDY_PROXY_DRIVER, getCliConfigValue, normalizeCaddyProxyDriver, resolveDockerContainerPrefix, setCliConfigValue, } from './cli-config.js';
 import { resolveCliHomeRoot } from './cli-home.js';
-import { applyEnvProxyAppEntryOptions, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
-import { run } from './run-npm.js';
+import { applyEnvProxyAppEntryOptions, buildManualEnvProxyCaddyBundle, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
+import { normalizeEnvProxyConfig } from './env-proxy-config.js';
+import { commandOutput, run } from './run-npm.js';
 const DOCKER_CADDY_PROXY_CONTAINER_SUFFIX = 'caddy-proxy';
 const DOCKER_CADDY_PROXY_IMAGE = 'caddy:latest';
 const DOCKER_CADDY_PROXY_RUNTIME_ROOT = '/apps';
 const DOCKER_CADDY_PROXY_CONF_DESTINATION = '/etc/caddy/Caddyfile';
+const DEFAULT_DOCKER_CADDY_PROXY_PUBLISHED_PORTS = [80, 443];
 async function readOptionalTextFile(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -62,8 +65,9 @@ export async function resolveCaddyProxyRuntimeContext(options) {
         upstreamHost: resolveCaddyProxyUpstreamHost(driver),
     };
 }
-export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext) {
+export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext, options) {
     const bundle = await buildEnvProxyCaddyBundle(runtime, {
+        cdnBaseUrl: options?.cdnBaseUrl,
         runtimeCliRoot: runtimeContext.runtimeCliRoot,
         upstreamHost: runtimeContext.upstreamHost,
     });
@@ -82,6 +86,27 @@ export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeCon
         status,
     };
 }
+export async function writeManualCaddyProxyBundle(input, appEntryOptions, runtimeContext, options) {
+    const bundle = await buildManualEnvProxyCaddyBundle(input, {
+        cdnBaseUrl: options?.cdnBaseUrl,
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: input.upstreamHost || runtimeContext.upstreamHost,
+    });
+    const currentAppConfigContent = await readOptionalTextFile(bundle.appConfigPath);
+    const nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'caddy', appEntryOptions);
+    const status = currentAppConfigContent ? 'updated' : 'created';
+    await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);
+    await Promise.all([
+        writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
+        writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
+        writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
+    ]);
+    return {
+        bundle,
+        status,
+    };
+}
 function resolveLocalCaddyPidFilePath() {
     return path.join(path.dirname(resolveEnvProxyMainOutputPath({ provider: 'caddy' })), 'caddy.pid');
 }
@@ -149,11 +174,16 @@ async function reloadLocalCaddyProxy(runtimeContext) {
 }
 async function ensureDockerCaddyProxyContainer(runtimeContext) {
     const containerName = await resolveCaddyProxyContainerName();
+    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const publishedPorts = await resolveDockerCaddyPublishedPorts();
     if (await dockerContainerExists(containerName)) {
-        return;
+        if (await dockerCaddyProxyContainerMatchesPublishedPorts(containerName, publishedPorts)) {
+            return;
+        }
+        await removeDockerCaddyProxyContainer(containerName);
     }
     const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
-    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const dockerPortArgs = publishedPorts.flatMap((port) => ['-p', `${port}:${port}`]);
     await run('docker', [
         'run',
         '-d',
@@ -161,8 +191,7 @@ async function ensureDockerCaddyProxyContainer(runtimeContext) {
         containerName,
         '--add-host',
         'host.docker.internal:host-gateway',
-        '-p',
-        '80:80',
+        ...dockerPortArgs,
         '-v',
         `${hostCliRoot}:${DOCKER_CADDY_PROXY_RUNTIME_ROOT}`,
         '-v',
@@ -173,14 +202,53 @@ async function ensureDockerCaddyProxyContainer(runtimeContext) {
         stdio: 'ignore',
     });
 }
+async function resolveDockerCaddyPublishedPorts() {
+    const config = await loadAuthConfig();
+    const ports = new Set(DEFAULT_DOCKER_CADDY_PROXY_PUBLISHED_PORTS);
+    for (const envConfig of Object.values(config.envs)) {
+        const port = normalizeEnvProxyConfig(envConfig.proxy)?.port;
+        if (port !== undefined) {
+            ports.add(port);
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function readDockerCaddyPublishedPorts(containerName) {
+    const output = await commandOutput('docker', ['inspect', '--format', '{{json .HostConfig.PortBindings}}', containerName], { errorName: 'docker inspect' });
+    const parsed = JSON.parse(output.trim() || '{}');
+    const ports = new Set();
+    for (const bindings of Object.values(parsed)) {
+        if (!Array.isArray(bindings)) {
+            continue;
+        }
+        for (const binding of bindings) {
+            const port = Number.parseInt(String(binding?.HostPort ?? '').trim(), 10);
+            if (Number.isInteger(port) && port > 0) {
+                ports.add(port);
+            }
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function dockerCaddyProxyContainerMatchesPublishedPorts(containerName, expectedPorts) {
+    const currentPorts = await readDockerCaddyPublishedPorts(containerName);
+    return currentPorts.length === expectedPorts.length && currentPorts.every((port, index) => port === expectedPorts[index]);
+}
+async function removeDockerCaddyProxyContainer(containerName) {
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: 'ignore',
+    });
+}
 async function startDockerCaddyProxy(runtimeContext) {
     const containerName = await resolveCaddyProxyContainerName();
     await ensureCaddyProxyMainConfig(runtimeContext);
-    if (await dockerContainerExists(containerName)) {
+    const existedBeforeEnsure = await dockerContainerExists(containerName);
+    await ensureDockerCaddyProxyContainer(runtimeContext);
+    if (existedBeforeEnsure && (await dockerContainerExists(containerName))) {
         const state = await startDockerContainer(containerName, { stdio: 'ignore' });
         return state === 'already-running' ? 'already-running' : 'started';
     }
-    await ensureDockerCaddyProxyContainer(runtimeContext);
     return 'started';
 }
 async function stopDockerCaddyProxy() {

package/dist/lib/proxy-nginx.js

@@ -9,14 +9,17 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
+import { loadAuthConfig } from './auth-store.js';
 import { DEFAULT_NGINX_PROXY_DRIVER, getCliConfigValue, NGINX_PROXY_DRIVER_OPTIONS, normalizeNginxProxyDriver, resolveDockerContainerPrefix, setCliConfigValue, } from './cli-config.js';
 import { resolveCliHomeRoot } from './cli-home.js';
-import { applyEnvProxyAppEntryOptions, appConfigHasManagedNginxBlock, buildEnvProxyMainConfig, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, mapProxyPathFromCliRoot, reloadEnvProxyProvider, resolveEnvProxyMainOutputPath, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from './env-proxy.js';
-import { run } from './run-npm.js';
+import { applyEnvProxyAppEntryOptions, appConfigHasManagedNginxBlock, buildManualEnvProxyNginxBundle, buildEnvProxyMainConfig, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, mapProxyPathFromCliRoot, reloadEnvProxyProvider, resolveEnvProxyMainOutputPath, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from './env-proxy.js';
+import { normalizeEnvProxyConfig } from './env-proxy-config.js';
+import { commandOutput, run } from './run-npm.js';
 const DOCKER_NGINX_PROXY_CONTAINER_SUFFIX = 'nginx-proxy';
 const DOCKER_NGINX_PROXY_IMAGE = 'nginx:latest';
 const DOCKER_NGINX_PROXY_RUNTIME_ROOT = '/apps';
 const DOCKER_NGINX_PROXY_CONF_DESTINATION = '/etc/nginx/conf.d/default.conf';
+const DEFAULT_DOCKER_NGINX_PROXY_PUBLISHED_PORTS = [80, 443];
 async function readOptionalTextFile(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -66,11 +69,23 @@ function buildNginxManagedBlockMissingMessage(appConfigPath) {
     return (`The editable nginx app entry config at ${appConfigPath} does not contain the NocoBase managed block. ` +
         'Restore the managed block or delete the file and regenerate the proxy config.');
 }
-export async function writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext) {
+export async function writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext, options) {
     const bundle = await buildEnvProxyNginxBundle(runtime, {
+        cdnBaseUrl: options?.cdnBaseUrl,
         runtimeCliRoot: runtimeContext.runtimeCliRoot,
         upstreamHost: runtimeContext.upstreamHost,
     });
+    return await writeResolvedNginxProxyBundle(bundle, appEntryOptions, options);
+}
+export async function writeManualNginxProxyBundle(input, appEntryOptions, runtimeContext, options) {
+    const bundle = await buildManualEnvProxyNginxBundle(input, {
+        cdnBaseUrl: options?.cdnBaseUrl,
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: runtimeContext.upstreamHost,
+    });
+    return await writeResolvedNginxProxyBundle(bundle, appEntryOptions, options);
+}
+async function writeResolvedNginxProxyBundle(bundle, appEntryOptions, options) {
     const managedConfigBlock = extractManagedNginxConfigBlock(bundle.appConfigContent);
     if (!managedConfigBlock) {
         throw new Error('Failed to render the managed nginx config block.');
@@ -79,10 +94,12 @@ export async function writeNginxProxyBundle(runtime, appEntryOptions, runtimeCon
     let nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'nginx', appEntryOptions);
     let status = 'created';
     if (currentAppConfigContent) {
-        if (!appConfigHasManagedNginxBlock(currentAppConfigContent)) {
+        if (!appConfigHasManagedNginxBlock(currentAppConfigContent) && !options?.force) {
             throw new Error(buildNginxManagedBlockMissingMessage(bundle.appConfigPath));
         }
-        nextAppConfigContent = applyEnvProxyAppEntryOptions(replaceManagedNginxConfigBlock(currentAppConfigContent, managedConfigBlock), 'nginx', appEntryOptions);
+        nextAppConfigContent = appConfigHasManagedNginxBlock(currentAppConfigContent)
+            ? applyEnvProxyAppEntryOptions(replaceManagedNginxConfigBlock(currentAppConfigContent, managedConfigBlock), 'nginx', appEntryOptions)
+            : applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'nginx', appEntryOptions);
         status = 'updated';
     }
     await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);
@@ -217,11 +234,16 @@ async function reloadLocalNginxProxy(runtimeContext) {
 }
 async function ensureDockerNginxProxyContainer(runtimeContext) {
     const containerName = await resolveNginxProxyContainerName();
+    const mainConfigPath = await ensureNginxProxyMainConfig(runtimeContext);
+    const publishedPorts = await resolveDockerNginxPublishedPorts();
     if (await dockerContainerExists(containerName)) {
-        return;
+        if (await dockerNginxProxyContainerMatchesPublishedPorts(containerName, publishedPorts)) {
+            return;
+        }
+        await removeDockerNginxProxyContainer(containerName);
     }
     const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
-    const mainConfigPath = await ensureNginxProxyMainConfig(runtimeContext);
+    const dockerPortArgs = publishedPorts.flatMap((port) => ['-p', `${port}:${port}`]);
     await run('docker', [
         'run',
         '-d',
@@ -229,8 +251,7 @@ async function ensureDockerNginxProxyContainer(runtimeContext) {
         containerName,
         '--add-host',
         'host.docker.internal:host-gateway',
-        '-p',
-        '80:80',
+        ...dockerPortArgs,
         '-v',
         `${hostCliRoot}:${DOCKER_NGINX_PROXY_RUNTIME_ROOT}`,
         '-v',
@@ -241,14 +262,53 @@ async function ensureDockerNginxProxyContainer(runtimeContext) {
         stdio: 'ignore',
     });
 }
+async function resolveDockerNginxPublishedPorts() {
+    const config = await loadAuthConfig();
+    const ports = new Set(DEFAULT_DOCKER_NGINX_PROXY_PUBLISHED_PORTS);
+    for (const envConfig of Object.values(config.envs)) {
+        const port = normalizeEnvProxyConfig(envConfig.proxy)?.port;
+        if (port !== undefined) {
+            ports.add(port);
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function readDockerNginxPublishedPorts(containerName) {
+    const output = await commandOutput('docker', ['inspect', '--format', '{{json .HostConfig.PortBindings}}', containerName], { errorName: 'docker inspect' });
+    const parsed = JSON.parse(output.trim() || '{}');
+    const ports = new Set();
+    for (const bindings of Object.values(parsed)) {
+        if (!Array.isArray(bindings)) {
+            continue;
+        }
+        for (const binding of bindings) {
+            const port = Number.parseInt(String(binding?.HostPort ?? '').trim(), 10);
+            if (Number.isInteger(port) && port > 0) {
+                ports.add(port);
+            }
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function dockerNginxProxyContainerMatchesPublishedPorts(containerName, expectedPorts) {
+    const currentPorts = await readDockerNginxPublishedPorts(containerName);
+    return currentPorts.length === expectedPorts.length && currentPorts.every((port, index) => port === expectedPorts[index]);
+}
+async function removeDockerNginxProxyContainer(containerName) {
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: 'ignore',
+    });
+}
 async function startDockerNginxProxy(runtimeContext) {
     const containerName = await resolveNginxProxyContainerName();
     await ensureNginxProxyMainConfig(runtimeContext);
-    if (await dockerContainerExists(containerName)) {
+    const existedBeforeEnsure = await dockerContainerExists(containerName);
+    await ensureDockerNginxProxyContainer(runtimeContext);
+    if (existedBeforeEnsure && (await dockerContainerExists(containerName))) {
         const state = await startDockerContainer(containerName, { stdio: 'ignore' });
         return state === 'already-running' ? 'already-running' : 'started';
     }
-    await ensureDockerNginxProxyContainer(runtimeContext);
     return 'started';
 }
 async function stopDockerNginxProxy() {

package/dist/locale/en-US.json

@@ -93,20 +93,20 @@
     "envAdd": {
       "prompts": {
         "name": {
-          "message": "What would you like to call this environment?",
+          "message": "App environment identifier",
           "placeholder": "default"
         },
         "scope": {
-          "message": "Where should this connection be saved?",
+          "message": "Connection save location",
           "globalLabel": "Global",
           "globalHint": "user-level config"
         },
         "apiBaseUrl": {
-          "message": "What is the API base URL?",
+          "message": "API base URL",
           "placeholder": "https://demo.example.com/api or https://demo.example.com/api/__app/<subapp>"
         },
         "authType": {
-          "message": "Which authentication method would you like to use?",
+          "message": "Authentication method",
           "basicLabel": "Basic authentication (username + password)",
           "basicHint": "uses your credentials to fetch a token after save",
           "oauthLabel": "OAuth (browser authentication)",
@@ -114,14 +114,14 @@
           "tokenLabel": "API token / API key"
         },
         "username": {
-          "message": "Enter the username for basic login",
+          "message": "Basic login username",
           "placeholder": "admin"
         },
         "password": {
-          "message": "Enter the password for basic login"
+          "message": "Basic login password"
         },
         "accessToken": {
-          "message": "Enter an API token or API key",
+          "message": "API token or API key",
           "placeholder": "Enter your API token / API key"
         }
       }
@@ -179,7 +179,7 @@
           },
           "prompts": {
             "provideMethod": {
-              "message": "How do you want to provide the license key?",
+              "message": "License key input method",
               "keyOption": "Paste the license key",
               "fileOption": "Read the key from a file"
             },
@@ -252,7 +252,7 @@
       },
       "prompts": {
         "source": {
-          "message": "How would you like to get NocoBase?",
+          "message": "NocoBase install source",
           "dockerLabel": "Docker install (Recommended)",
           "dockerHint": "Best for no-code and low-maintenance setups. You can upgrade later by pulling a newer image and restarting the app.",
           "npmLabel": "create-nocobase-app install",
@@ -261,9 +261,9 @@
           "gitHint": "Best when you want to try the latest unreleased changes, contribute code, or debug and modify NocoBase source directly. This option is more developer-oriented."
         },
         "version": {
-          "message": "Which version would you like to use?",
+          "message": "NocoBase version",
           "latestLabel": "latest",
-          "latestHint": "Stable release. Best for production use and the most predictable experience. Currently unavailable.",
+          "latestHint": "Stable release. Best for production use and the most predictable experience.",
           "betaLabel": "beta",
           "betaHint": "Preview release. Good for trying upcoming features before general release.",
           "alphaLabel": "alpha",
@@ -272,15 +272,15 @@
           "otherHint": "Enter another package version, Docker tag, or Git ref manually, such as a branch name."
         },
         "otherVersion": {
-          "message": "Enter the version, Docker tag, or Git ref you want to use.",
+          "message": "Custom version, Docker tag, or Git ref",
           "placeholder": "For example: fix/cli-v2"
         },
         "dockerRegistry": {
-          "message": "Which Docker registry would you like to use? The image tag is set separately in Version.",
+          "message": "Docker registry (image tag is set in Version)",
           "placeholder": "nocobase/nocobase"
         },
         "dockerPlatform": {
-          "message": "Which Docker image platform should be used?",
+          "message": "Architecture",
           "autoLabel": "Auto",
           "autoHint": "Use Docker default for this machine"
         },
@@ -323,79 +323,79 @@
       },
       "prompts": {
         "env": {
-          "message": "What would you like to call this app?",
+          "message": "App environment identifier",
           "placeholder": "local"
         },
         "lang": {
-          "message": "Which language would you like to use for the app?"
+          "message": "App language"
         },
         "appPath": {
-          "message": "Where should this app be stored? (relative to {{root}})",
+          "message": "App directory (relative to {{root}})",
           "placeholder": "./<env>/"
         },
         "appPort": {
-          "message": "Which port should this app use?",
+          "message": "App port",
           "placeholder": "13000"
         },
         "appPublicPath": {
-          "message": "What is the app subpath? (for example, /nocobase/)",
+          "message": "App subpath (for example, /nocobase/)",
           "placeholder": "/ or /nocobase/"
         },
         "storagePath": {
-          "message": "Where should uploads and local files be stored?",
+          "message": "Uploads and local files directory",
           "placeholder": "./<env>/storage/"
         },
         "dbDialect": {
-          "message": "Which database would you like to use?"
+          "message": "Database type"
         },
         "builtinDb": {
-          "message": "Would you like to use the built-in database?"
+          "message": "Use built-in database"
         },
         "builtinDbImage": {
-          "message": "Which Docker image should be used for the built-in database?",
+          "message": "Built-in database Docker image",
           "placeholder": "postgres:16"
         },
         "dbHost": {
-          "message": "What is the database host?",
+          "message": "Database host",
           "placeholder": "127.0.0.1"
         },
         "dbPort": {
-          "message": "What is the database port?",
+          "message": "Database port",
           "placeholder": "5432"
         },
         "dbDatabase": {
-          "message": "What is the database name?"
+          "message": "Database name"
         },
         "dbUser": {
-          "message": "What is the database username?"
+          "message": "Database username"
         },
         "dbPassword": {
-          "message": "What is the database password?"
+          "message": "Database password"
         },
         "dbSchema": {
-          "message": "What is the database schema? (PostgreSQL only, optional)",
+          "message": "Database schema (PostgreSQL/KingbaseES only, optional)",
           "placeholder": "Leave empty to use the default schema"
         },
         "dbTablePrefix": {
-          "message": "What table prefix should be used? (optional)",
+          "message": "Database table prefix (optional)",
           "placeholder": "For example: nb_"
         },
         "dbUnderscored": {
-          "message": "Use underscored names for database tables and columns?"
+          "message": "Use underscored names for database tables and columns"
         },
         "rootUsername": {
-          "message": "Choose the initial admin username",
+          "message": "Initial admin username",
           "placeholder": "nocobase"
         },
         "rootEmail": {
-          "message": "What is the initial admin email?",
+          "message": "Initial admin email",
           "placeholder": "admin@nocobase.com"
         },
         "rootPassword": {
-          "message": "Choose the initial admin password"
+          "message": "Initial admin password"
         },
         "rootNickname": {
-          "message": "What display name should the initial admin use?",
+          "message": "Initial admin display name",
           "placeholder": "Super Admin"
         }
       }
@@ -419,11 +419,11 @@
       },
       "prompts": {
         "appName": {
-          "message": "What should this environment use for `--env`?",
+          "message": "Unique app environment identifier (used by the CLI to locate and manage this environment)",
           "placeholder": "local"
         },
         "setupMode": {
-          "message": "How would you like to set up this environment?",
+          "message": "App environment setup method",
           "installNewLabel": "Install a new app",
           "installNewHint": "Install a brand-new app from scratch. Best for first-time setup, evaluation, or a fresh local environment.",
           "manageLocalLabel": "Manage an app already on this machine",
@@ -432,7 +432,7 @@
           "connectRemoteHint": "Save only the remote app connection. Nothing will be installed or taken over on this machine."
         },
         "installSkills": {
-          "message": "Install NocoBase AI coding skills (nocobase/skills)?"
+          "message": "Install NocoBase AI coding skills (nocobase/skills)"
         },
         "apiBaseUrl": {
           "message": "API base URL",