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

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())) {
+        throw new Error('Local caddy proxy is not running. Start it first with `nb proxy caddy start`.');
+    }
+    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))) {
+        throw new Error('Docker caddy proxy is not running. Start it first with `nb proxy caddy start`.');
+    }
+    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())) {
+        throw new Error('Local nginx is not running. Start it first with `nb proxy nginx start`.');
+    }
+    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))) {
+        throw new Error('Docker nginx proxy is not running. Start it first with `nb proxy nginx start`.');
+    }
+    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

@@ -149,7 +149,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": {
@@ -320,7 +320,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}})",

package/dist/locale/zh-CN.json

@@ -149,7 +149,7 @@
         "appEntryMissingInclude": "可编辑入口配置 {{appConfigPath}} 没有引用 {{generatedConfigPath}}。请把托管的 generated 配置引用补回入口配置中，然后重新执行该命令。",
         "nginxOutputUnsupported": "nginx provider 不支持 `--output`。它会把 `app.conf`、`public/index-v1.html`、`public/index-v2.html` 和 `nocobase.conf` 写入 `~/.nocobase/proxy/nginx/<env>/`。",
         "caddyOutputUnsupported": "caddy provider 不支持 `--output`。它会把 `app.caddy`、`generated.caddy`、`public/index-v1.html`、`public/index-v2.html` 和 `nocobase.caddy` 写入 `~/.nocobase/proxy/caddy/<env>/`。",
-        "nginxAppEntryMissingManagedBlock": "可编辑的 nginx 入口配置 {{appConfigPath}} 不包含 NocoBase 的托管区块。请恢复这个托管区块，或删除该文件后重新执行 `nb env proxy`。"
+        "nginxAppEntryMissingManagedBlock": "可编辑的 nginx 入口配置 {{appConfigPath}} 不包含 NocoBase 的托管区块。请恢复这个托管区块，或删除该文件后重新执行 `nb proxy nginx generate`。"
       }
     },
     "shared": {
@@ -320,7 +320,7 @@
           "placeholder": "local"
         },
         "lang": {
-          "message": "你想使用哪种语言？"
+          "message": "你希望应用使用哪种语言？"
         },
         "appPath": {
           "message": "应用要放到哪里？（相对路径基于 {{root}}）",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.0-beta.46",
+  "version": "2.1.0-beta.47",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -138,5 +138,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "91fd3ab238a5ff58735bbfca04a8cb05d233b0af"
+  "gitHead": "bf8fc3790e3494c901b4d22861c5471a0d27c464"
 }

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

@@ -1,28 +0,0 @@
-/**
- * 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 { Command } from '@oclif/core';
-import { createEnvProxyCaddyFlags, ENV_PROXY_NAME_ARG, runEnvProxyCommand } from './index.js';
-export default class EnvProxyCaddy extends Command {
-    static summary = 'Generate Caddy proxy files for one managed env';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --env app1',
-        '<%= config.bin %> <%= command.id %> --env app1 --host a.local.nocobase.com --port 8080',
-        '<%= config.bin %> <%= command.id %> --env app1 --install --reload',
-        '<%= config.bin %> <%= command.id %> --env app1 --print',
-    ];
-    static args = {
-        name: ENV_PROXY_NAME_ARG,
-    };
-    static flags = createEnvProxyCaddyFlags();
-    async run() {
-        const { args, flags } = await this.parse(EnvProxyCaddy);
-        await runEnvProxyCommand(this, args, flags, 'caddy');
-    }
-}