@nocobase/cli 2.1.0-beta.46 → 2.1.0-beta.48

package/dist/lib/prompt-validators.js

@@ -18,6 +18,9 @@ const TCP_PORT_PROBE_HOSTS = ['127.0.0.1', '0.0.0.0', '::1'];
 function buildHealthCheckUrl(apiBaseUrl) {
     return `${apiBaseUrl.replace(/\/+$/, '')}/__health_check`;
 }
+function hasSupportedApiBasePath(pathname) {
+    return /\/api(?:\/__app\/[^/]+)?\/?$/.test(pathname);
+}
 function isMaintainingHealthCheckResponse(status, body) {
     if (status !== 503 || !body || typeof body !== 'object') {
         return false;
@@ -47,6 +50,9 @@ export async function validateApiBaseUrl(value) {
     if (/\/__health_check\/?$/i.test(url.pathname)) {
         return translateCli('validators.apiBaseUrl.healthCheckPathNotAllowed');
     }
+    if (!hasSupportedApiBasePath(url.pathname)) {
+        return translateCli('validators.apiBaseUrl.missingApiPrefix', { example: API_BASE_URL_EXAMPLE });
+    }
     const controller = new AbortController();
     const timeout = setTimeout(() => {
         controller.abort();

package/dist/lib/proxy-caddy.js

@@ -0,0 +1,274 @@
+/**
+ * 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.
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.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';
+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';
+async function readOptionalTextFile(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function isCaddyProxyDriver(value) {
+    return CADDY_PROXY_DRIVER_OPTIONS.includes(value);
+}
+export async function getCaddyProxyDriver() {
+    const configured = await getCliConfigValue('proxy.caddy-driver');
+    return normalizeCaddyProxyDriver(configured) ?? DEFAULT_CADDY_PROXY_DRIVER;
+}
+export async function setCaddyProxyDriver(driver) {
+    const normalized = await setCliConfigValue('proxy.caddy-driver', driver);
+    return normalizeCaddyProxyDriver(normalized) ?? DEFAULT_CADDY_PROXY_DRIVER;
+}
+export async function resolveCaddyProxyContainerName() {
+    const prefix = await resolveDockerContainerPrefix();
+    return `${prefix}-${DOCKER_CADDY_PROXY_CONTAINER_SUFFIX}`;
+}
+export function resolveCaddyProxyImage() {
+    return DOCKER_CADDY_PROXY_IMAGE;
+}
+export function resolveCaddyProxyRuntimeRoot(driver, cliRoot) {
+    return driver === 'docker' ? DOCKER_CADDY_PROXY_RUNTIME_ROOT : cliRoot;
+}
+export function resolveCaddyProxyUpstreamHost(driver) {
+    return driver === 'docker' ? 'host.docker.internal' : '127.0.0.1';
+}
+export async function resolveCaddyProxyRuntimeContext(options) {
+    const driver = await getCaddyProxyDriver();
+    const cliRoot = String(options?.cliRoot ?? process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
+    return {
+        driver,
+        runtimeCliRoot: resolveCaddyProxyRuntimeRoot(driver, cliRoot),
+        upstreamHost: resolveCaddyProxyUpstreamHost(driver),
+    };
+}
+export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext) {
+    const bundle = await buildEnvProxyCaddyBundle(runtime, {
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        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');
+}
+async function isLocalCaddyRunning() {
+    const pidText = await readOptionalTextFile(resolveLocalCaddyPidFilePath());
+    const pid = Number.parseInt(String(pidText ?? '').trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureCaddyProxyMainConfig(runtimeContext) {
+    const mainConfigPath = resolveEnvProxyMainOutputPath({ provider: 'caddy' });
+    const mainConfigContent = await buildEnvProxyMainConfig({
+        provider: 'caddy',
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+    });
+    await mkdir(path.dirname(mainConfigPath), { recursive: true });
+    await writeFile(mainConfigPath, mainConfigContent, 'utf8');
+    return mainConfigPath;
+}
+async function startLocalCaddyProxy(runtimeContext) {
+    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const pidFilePath = resolveLocalCaddyPidFilePath();
+    if (await isLocalCaddyRunning()) {
+        return 'already-running';
+    }
+    await run('caddy', ['start', '--config', mainConfigPath, '--adapter', 'caddyfile', '--pidfile', pidFilePath], {
+        errorName: 'caddy start',
+        stdio: 'ignore',
+    });
+    return 'started';
+}
+async function stopLocalCaddyProxy() {
+    const pidFilePath = resolveLocalCaddyPidFilePath();
+    const pidText = await readOptionalTextFile(pidFilePath);
+    const pid = Number.parseInt(String(pidText ?? '').trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return 'already-stopped';
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        return 'stopped';
+    }
+    catch {
+        return 'already-stopped';
+    }
+}
+async function reloadLocalCaddyProxy(runtimeContext) {
+    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    if (!(await isLocalCaddyRunning())) {
+        return await startLocalCaddyProxy(runtimeContext);
+    }
+    await run('caddy', ['reload', '--config', mainConfigPath, '--adapter', 'caddyfile'], {
+        errorName: 'caddy reload',
+        stdio: 'ignore',
+    });
+    return 'reloaded';
+}
+async function ensureDockerCaddyProxyContainer(runtimeContext) {
+    const containerName = await resolveCaddyProxyContainerName();
+    if (await dockerContainerExists(containerName)) {
+        return;
+    }
+    const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
+    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    await run('docker', [
+        'run',
+        '-d',
+        '--name',
+        containerName,
+        '--add-host',
+        'host.docker.internal:host-gateway',
+        '-p',
+        '80:80',
+        '-v',
+        `${hostCliRoot}:${DOCKER_CADDY_PROXY_RUNTIME_ROOT}`,
+        '-v',
+        `${mainConfigPath}:${DOCKER_CADDY_PROXY_CONF_DESTINATION}:ro`,
+        DOCKER_CADDY_PROXY_IMAGE,
+    ], {
+        errorName: 'docker run',
+        stdio: 'ignore',
+    });
+}
+async function startDockerCaddyProxy(runtimeContext) {
+    const containerName = await resolveCaddyProxyContainerName();
+    await ensureCaddyProxyMainConfig(runtimeContext);
+    if (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() {
+    const containerName = await resolveCaddyProxyContainerName();
+    if (!(await dockerContainerExists(containerName))) {
+        return 'already-stopped';
+    }
+    return await stopDockerContainer(containerName, { stdio: 'ignore' });
+}
+async function reloadDockerCaddyProxy(runtimeContext) {
+    const containerName = await resolveCaddyProxyContainerName();
+    await ensureCaddyProxyMainConfig(runtimeContext);
+    if (!(await dockerContainerIsRunning(containerName))) {
+        return await startDockerCaddyProxy(runtimeContext);
+    }
+    await run('docker', ['exec', containerName, 'caddy', 'reload', '--config', DOCKER_CADDY_PROXY_CONF_DESTINATION, '--adapter', 'caddyfile'], {
+        errorName: 'docker exec caddy reload',
+        stdio: 'ignore',
+    });
+    return 'reloaded';
+}
+export async function startCaddyProxy(runtimeContext) {
+    return runtimeContext.driver === 'docker'
+        ? await startDockerCaddyProxy(runtimeContext)
+        : await startLocalCaddyProxy(runtimeContext);
+}
+export async function stopCaddyProxy(runtimeContext) {
+    return runtimeContext.driver === 'docker' ? await stopDockerCaddyProxy() : await stopLocalCaddyProxy();
+}
+export async function reloadCaddyProxy(runtimeContext) {
+    return runtimeContext.driver === 'docker'
+        ? await reloadDockerCaddyProxy(runtimeContext)
+        : await reloadLocalCaddyProxy(runtimeContext);
+}
+export async function restartCaddyProxy(runtimeContext) {
+    await stopCaddyProxy(runtimeContext);
+    await startCaddyProxy(runtimeContext);
+    return 'restarted';
+}
+export async function getCaddyProxyStatus(runtimeContext) {
+    const configFile = await mapProxyPathFromCliRoot(resolveEnvProxyMainOutputPath({ provider: 'caddy' }), {
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+    });
+    if (runtimeContext.driver === 'docker') {
+        const containerName = await resolveCaddyProxyContainerName();
+        return {
+            driver: runtimeContext.driver,
+            state: (await dockerContainerIsRunning(containerName)) ? 'running' : 'stopped',
+            configFile,
+            runtimeRoot: runtimeContext.runtimeCliRoot,
+            upstreamHost: runtimeContext.upstreamHost,
+            containerName,
+            image: resolveCaddyProxyImage(),
+        };
+    }
+    return {
+        driver: runtimeContext.driver,
+        state: (await isLocalCaddyRunning()) ? 'running' : 'stopped',
+        configFile,
+        runtimeRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: runtimeContext.upstreamHost,
+        caddyBinary: await getCliConfigValue('bin.caddy'),
+    };
+}
+export function formatCaddyProxyInfoLines(info) {
+    const lines = [
+        `driver:      ${info.driver}`,
+        `configFile:  ${info.configFile}`,
+        `runtimeRoot: ${info.runtimeRoot}`,
+        `upstreamHost:${info.upstreamHost}`,
+    ];
+    if (info.driver === 'local') {
+        lines.push(`caddyBin:    ${info.caddyBinary}`);
+    }
+    else {
+        lines.push(`container:   ${info.containerName}`);
+        lines.push(`image:       ${info.image}`);
+    }
+    return lines;
+}
+export function formatCaddyProxyStatusLines(status) {
+    const lines = [`driver: ${status.driver}`, `status: ${status.state}`, `config: ${status.configFile}`];
+    if (status.driver === 'local') {
+        lines.push(`caddy:  ${status.caddyBinary}`);
+    }
+    else {
+        lines.push(`container: ${status.containerName}`);
+        lines.push(`image: ${status.image}`);
+    }
+    return lines;
+}

package/dist/lib/proxy-nginx.js

@@ -0,0 +1,330 @@
+/**
+ * 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.
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.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';
+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';
+async function readOptionalTextFile(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function isNginxProxyDriver(value) {
+    return NGINX_PROXY_DRIVER_OPTIONS.includes(value);
+}
+export async function getNginxProxyDriver() {
+    const configured = await getCliConfigValue('proxy.nginx-driver');
+    return normalizeNginxProxyDriver(configured) ?? DEFAULT_NGINX_PROXY_DRIVER;
+}
+export async function setNginxProxyDriver(driver) {
+    const normalized = await setCliConfigValue('proxy.nginx-driver', driver);
+    return normalizeNginxProxyDriver(normalized) ?? DEFAULT_NGINX_PROXY_DRIVER;
+}
+export async function resolveNginxProxyContainerName() {
+    const prefix = await resolveDockerContainerPrefix();
+    return `${prefix}-${DOCKER_NGINX_PROXY_CONTAINER_SUFFIX}`;
+}
+export function resolveNginxProxyImage() {
+    return DOCKER_NGINX_PROXY_IMAGE;
+}
+export function resolveNginxProxyRuntimeRoot(driver, cliRoot) {
+    return driver === 'docker' ? DOCKER_NGINX_PROXY_RUNTIME_ROOT : cliRoot;
+}
+export function resolveNginxProxyUpstreamHost(driver) {
+    return driver === 'docker' ? 'host.docker.internal' : '127.0.0.1';
+}
+export async function resolveNginxProxyRuntimeContext(options) {
+    const driver = await getNginxProxyDriver();
+    const cliRoot = String(options?.cliRoot ?? process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
+    return {
+        driver,
+        runtimeCliRoot: resolveNginxProxyRuntimeRoot(driver, cliRoot),
+        upstreamHost: resolveNginxProxyUpstreamHost(driver),
+    };
+}
+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) {
+    const bundle = await buildEnvProxyNginxBundle(runtime, {
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: runtimeContext.upstreamHost,
+    });
+    const managedConfigBlock = extractManagedNginxConfigBlock(bundle.appConfigContent);
+    if (!managedConfigBlock) {
+        throw new Error('Failed to render the managed nginx config block.');
+    }
+    const currentAppConfigContent = await readOptionalTextFile(bundle.appConfigPath);
+    let nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'nginx', appEntryOptions);
+    let status = 'created';
+    if (currentAppConfigContent) {
+        if (!appConfigHasManagedNginxBlock(currentAppConfigContent)) {
+            throw new Error(buildNginxManagedBlockMissingMessage(bundle.appConfigPath));
+        }
+        nextAppConfigContent = applyEnvProxyAppEntryOptions(replaceManagedNginxConfigBlock(currentAppConfigContent, managedConfigBlock), 'nginx', appEntryOptions);
+        status = 'updated';
+    }
+    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'),
+        syncEnvProxyNginxSnippets(),
+    ]);
+    return {
+        bundle,
+        status,
+    };
+}
+export function normalizeProxyListenPort(value) {
+    const normalized = value?.trim() || undefined;
+    if (!normalized || !/^\d+$/.test(normalized)) {
+        return undefined;
+    }
+    const port = Number(normalized);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return undefined;
+    }
+    return normalized;
+}
+export function resolveProxyAppEntryOptions(flags) {
+    return {
+        host: flags.host?.trim() || undefined,
+        port: normalizeProxyListenPort(flags.port?.trim()),
+    };
+}
+export function formatNginxProxyInfoLines(info) {
+    const lines = [
+        `driver:      ${info.driver}`,
+        `configFile:  ${info.configFile}`,
+        `snippetsDir: ${info.snippetsDir}`,
+        `runtimeRoot: ${info.runtimeRoot}`,
+        `upstreamHost:${info.upstreamHost}`,
+    ];
+    if (info.driver === 'local') {
+        lines.push(`nginxBin:    ${info.nginxBinary}`);
+    }
+    else {
+        lines.push(`container:   ${info.containerName}`);
+        lines.push(`image:       ${info.image}`);
+    }
+    return lines;
+}
+function parseNginxPidPathFromVersionOutput(output) {
+    const match = output.match(/--pid-path=(?:"([^"]+)"|'([^']+)'|([^\s]+))/);
+    const pidPath = String(match?.[1] ?? match?.[2] ?? match?.[3] ?? '').trim();
+    if (!pidPath) {
+        throw new Error('Failed to detect the nginx pid path from `nginx -V`.');
+    }
+    return pidPath;
+}
+async function captureNginxVersionOutput() {
+    let stdout = '';
+    let stderr = '';
+    await run('nginx', ['-V'], {
+        errorName: 'nginx -V',
+        stdio: 'pipe',
+        onStdout: (chunk) => {
+            stdout += chunk;
+        },
+        onStderr: (chunk) => {
+            stderr += chunk;
+        },
+    });
+    return `${stdout}${stderr}`.trim();
+}
+async function resolveLocalNginxPidPath() {
+    return parseNginxPidPathFromVersionOutput(await captureNginxVersionOutput());
+}
+async function isLocalNginxRunning() {
+    const pidPath = await resolveLocalNginxPidPath();
+    const pidText = await readOptionalTextFile(pidPath);
+    const pid = Number.parseInt(String(pidText ?? '').trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureNginxProxyMainConfig(runtimeContext) {
+    const mainConfigPath = resolveEnvProxyMainOutputPath({ provider: 'nginx' });
+    const mainConfigContent = await buildEnvProxyMainConfig({
+        provider: 'nginx',
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+    });
+    await mkdir(path.dirname(mainConfigPath), { recursive: true });
+    await writeFile(mainConfigPath, mainConfigContent, 'utf8');
+    await syncEnvProxyNginxSnippets();
+    return mainConfigPath;
+}
+async function startLocalNginxProxy(runtimeContext) {
+    await ensureNginxProxyMainConfig(runtimeContext);
+    await installEnvProxyProvider('nginx', { runtimeCliRoot: runtimeContext.runtimeCliRoot });
+    if (await isLocalNginxRunning()) {
+        return 'already-running';
+    }
+    await run('nginx', [], {
+        errorName: 'nginx',
+        stdio: 'ignore',
+    });
+    return 'started';
+}
+async function stopLocalNginxProxy() {
+    if (!(await isLocalNginxRunning())) {
+        return 'already-stopped';
+    }
+    await run('nginx', ['-s', 'stop'], {
+        errorName: 'nginx -s stop',
+        stdio: 'ignore',
+    });
+    return 'stopped';
+}
+async function reloadLocalNginxProxy(runtimeContext) {
+    await ensureNginxProxyMainConfig(runtimeContext);
+    await installEnvProxyProvider('nginx', { runtimeCliRoot: runtimeContext.runtimeCliRoot });
+    if (!(await isLocalNginxRunning())) {
+        return await startLocalNginxProxy(runtimeContext);
+    }
+    await reloadEnvProxyProvider('nginx', { runtimeCliRoot: runtimeContext.runtimeCliRoot });
+    return 'reloaded';
+}
+async function ensureDockerNginxProxyContainer(runtimeContext) {
+    const containerName = await resolveNginxProxyContainerName();
+    if (await dockerContainerExists(containerName)) {
+        return;
+    }
+    const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
+    const mainConfigPath = await ensureNginxProxyMainConfig(runtimeContext);
+    await run('docker', [
+        'run',
+        '-d',
+        '--name',
+        containerName,
+        '--add-host',
+        'host.docker.internal:host-gateway',
+        '-p',
+        '80:80',
+        '-v',
+        `${hostCliRoot}:${DOCKER_NGINX_PROXY_RUNTIME_ROOT}`,
+        '-v',
+        `${mainConfigPath}:${DOCKER_NGINX_PROXY_CONF_DESTINATION}:ro`,
+        DOCKER_NGINX_PROXY_IMAGE,
+    ], {
+        errorName: 'docker run',
+        stdio: 'ignore',
+    });
+}
+async function startDockerNginxProxy(runtimeContext) {
+    const containerName = await resolveNginxProxyContainerName();
+    await ensureNginxProxyMainConfig(runtimeContext);
+    if (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() {
+    const containerName = await resolveNginxProxyContainerName();
+    if (!(await dockerContainerExists(containerName))) {
+        return 'already-stopped';
+    }
+    return await stopDockerContainer(containerName, { stdio: 'ignore' });
+}
+async function reloadDockerNginxProxy(runtimeContext) {
+    const containerName = await resolveNginxProxyContainerName();
+    await ensureNginxProxyMainConfig(runtimeContext);
+    if (!(await dockerContainerIsRunning(containerName))) {
+        return await startDockerNginxProxy(runtimeContext);
+    }
+    await run('docker', ['exec', containerName, 'nginx', '-s', 'reload'], {
+        errorName: 'docker exec nginx -s reload',
+        stdio: 'ignore',
+    });
+    return 'reloaded';
+}
+export async function startNginxProxy(runtimeContext) {
+    return runtimeContext.driver === 'docker'
+        ? await startDockerNginxProxy(runtimeContext)
+        : await startLocalNginxProxy(runtimeContext);
+}
+export async function stopNginxProxy(runtimeContext) {
+    return runtimeContext.driver === 'docker' ? await stopDockerNginxProxy() : await stopLocalNginxProxy();
+}
+export async function reloadNginxProxy(runtimeContext) {
+    return runtimeContext.driver === 'docker'
+        ? await reloadDockerNginxProxy(runtimeContext)
+        : await reloadLocalNginxProxy(runtimeContext);
+}
+export async function restartNginxProxy(runtimeContext) {
+    await stopNginxProxy(runtimeContext);
+    await startNginxProxy(runtimeContext);
+    return 'restarted';
+}
+export async function getNginxProxyStatus(runtimeContext) {
+    const configFile = await mapProxyPathFromCliRoot(resolveEnvProxyMainOutputPath({ provider: 'nginx' }), {
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+    });
+    if (runtimeContext.driver === 'docker') {
+        const containerName = await resolveNginxProxyContainerName();
+        return {
+            driver: runtimeContext.driver,
+            state: (await dockerContainerIsRunning(containerName)) ? 'running' : 'stopped',
+            configFile,
+            runtimeRoot: runtimeContext.runtimeCliRoot,
+            upstreamHost: runtimeContext.upstreamHost,
+            containerName,
+            image: resolveNginxProxyImage(),
+        };
+    }
+    return {
+        driver: runtimeContext.driver,
+        state: (await isLocalNginxRunning()) ? 'running' : 'stopped',
+        configFile,
+        runtimeRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: runtimeContext.upstreamHost,
+        nginxBinary: await getCliConfigValue('bin.nginx'),
+    };
+}
+export function formatNginxProxyStatusLines(status) {
+    const lines = [
+        `driver: ${status.driver}`,
+        `status: ${status.state}`,
+        `config: ${status.configFile}`,
+    ];
+    if (status.driver === 'local') {
+        lines.push(`nginx:  ${status.nginxBinary}`);
+    }
+    else {
+        lines.push(`container: ${status.containerName}`);
+        lines.push(`image: ${status.image}`);
+    }
+    return lines;
+}

package/dist/locale/en-US.json

@@ -54,6 +54,7 @@
     "apiBaseUrl": {
       "invalid": "Enter a valid URL, for example {{example}}.",
       "invalidProtocol": "URL must start with http:// or https://, for example {{example}}.",
+      "missingApiPrefix": "The API base URL must include the /api prefix, for example {{example}}.",
       "healthCheckPathNotAllowed": "Do not include /__health_check in the API base URL. Enter the application API base URL, for example http://localhost:13000/api.",
       "maintaining": "The API base URL is reachable, but the app is still starting or in maintenance mode. Please try again later.",
       "healthCheckFailed": "The API base URL did not pass the health check (HTTP {{status}}). Make sure it points to a running NocoBase API endpoint.",
@@ -149,7 +150,7 @@
         "appEntryMissingInclude": "The editable app entry config at {{appConfigPath}} does not reference {{generatedConfigPath}}. Add the managed generated-config reference back into the editable app entry and rerun the command.",
         "nginxOutputUnsupported": "The nginx provider does not support `--output`. It writes `app.conf`, `public/index-v1.html`, `public/index-v2.html`, and `nocobase.conf` into `~/.nocobase/proxy/nginx/<env>/`.",
         "caddyOutputUnsupported": "The caddy provider does not support `--output`. It writes `app.caddy`, `generated.caddy`, `public/index-v1.html`, `public/index-v2.html`, and `nocobase.caddy` into `~/.nocobase/proxy/caddy/<env>/`.",
-        "nginxAppEntryMissingManagedBlock": "The editable nginx app entry config at {{appConfigPath}} does not contain the NocoBase managed block. Restore the managed block or delete the file and rerun `nb env proxy`."
+        "nginxAppEntryMissingManagedBlock": "The editable nginx app entry config at {{appConfigPath}} does not contain the NocoBase managed block. Restore the managed block or delete the file and rerun `nb proxy nginx generate`."
       }
     },
     "shared": {
@@ -201,7 +202,7 @@
         },
         "messages": {
           "activated": "Activated the license for env \"{{envName}}\".",
-          "savedLicenseKey": "Saved license key at {{licenseKeyPath}}"
+          "savedLicenseKey": "Saved the license key securely for this env"
         }
       }
     },
@@ -320,7 +321,7 @@
           "placeholder": "local"
         },
         "lang": {
-          "message": "Which language would you like to use?"
+          "message": "Which language would you like to use for the app?"
         },
         "appPath": {
           "message": "Where should this app be stored? (relative to {{root}})",