@nocobase/cli 2.2.0-alpha.1 → 2.2.0-alpha.11

package/dist/commands/portal/list.js

@@ -0,0 +1,98 @@
+/**
+ * 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, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { translateCli } from '../../lib/cli-locale.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { listPortalWorkspaces, toPortalOutputItem } from '../../lib/portal-list.js';
+import { printInfo, renderTable } from '../../lib/ui.js';
+const portalListText = (key, values, fallback) => translateCli(`commands.portalList.${key}`, values, { fallback });
+function formatBoolean(value) {
+    if (value === null) {
+        return '';
+    }
+    return value ? 'yes' : 'no';
+}
+export default class PortalList extends Command {
+    static summary = 'List portal records and local sync status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env dev --yes',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name; omitted uses the current env',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
+        }),
+        'json-output': Flags.boolean({
+            char: 'j',
+            aliases: ['json'],
+            description: 'Print portal records as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PortalList);
+        const requestedEnv = hasExplicitEnvSelection(this.argv) ? flags.env : undefined;
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            return;
+        }
+        const scope = resolveDefaultConfigScope();
+        const envName = requestedEnv ?? (await getCurrentEnvName({ scope }));
+        const env = await getEnv(envName, { scope });
+        if (!env) {
+            this.error(portalListText(requestedEnv ? 'errors.envNotConfigured' : 'errors.noEnvConfigured', { envName }, requestedEnv
+                ? `Env "${envName}" is not configured. Run \`nb env add ${envName} --api-base-url <url>\` first.`
+                : 'No NocoBase env is configured yet. Run `nb init --ui` to create one first.'));
+        }
+        const result = await listPortalWorkspaces({
+            env,
+            envName,
+            cliVersion: String(this.config.pjson.version ?? '').trim(),
+        });
+        const outputItems = result.items.map(toPortalOutputItem);
+        if (flags['json-output']) {
+            this.log(JSON.stringify(outputItems, null, 2));
+            return;
+        }
+        if (!outputItems.length) {
+            printInfo(portalListText('messages.empty', undefined, 'No portal records found.'));
+            return;
+        }
+        this.log(renderTable([
+            portalListText('table.name', undefined, 'Name'),
+            portalListText('table.url', undefined, 'URL'),
+            portalListText('table.portalType', undefined, 'Portal type'),
+            portalListText('table.sourceStorage', undefined, 'Source storage'),
+            portalListText('table.path', undefined, 'Local path'),
+            portalListText('table.enabled', undefined, 'Enabled'),
+            portalListText('table.localSynced', undefined, 'Local synced'),
+        ], outputItems.map((item) => [
+            item.name,
+            item.url,
+            item.portalType,
+            item.sourceStorage,
+            item.localPath,
+            formatBoolean(item.enabled),
+            formatBoolean(item.localSynced),
+        ])));
+    }
+}

package/dist/commands/portal/pull.js

@@ -0,0 +1,84 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { translateCli } from '../../lib/cli-locale.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { pullPortalSource } from '../../lib/portal-source.js';
+import { printInfo, printSuccess } from '../../lib/ui.js';
+const portalPullText = (key, values, fallback) => translateCli(`commands.portalPull.${key}`, values, { fallback });
+export default class PortalPull extends Command {
+    static summary = 'Pull portal source into local files';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> customer',
+        '<%= config.bin %> <%= command.id %> customer --env prod --yes',
+        '<%= config.bin %> <%= command.id %> customer --force',
+        '<%= config.bin %> <%= command.id %> customer --no-install',
+    ];
+    static args = {
+        portal: Args.string({
+            required: true,
+            description: 'Portal name',
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name; omitted uses the current env',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Delete the existing local files and pull them again',
+            default: false,
+        }),
+        install: Flags.boolean({
+            description: 'Run pnpm install after pulling the portal source',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PortalPull);
+        const requestedEnv = hasExplicitEnvSelection(this.argv) ? flags.env : undefined;
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            return;
+        }
+        const scope = resolveDefaultConfigScope();
+        const envName = requestedEnv ?? (await getCurrentEnvName({ scope }));
+        const env = await getEnv(envName, { scope });
+        if (!env) {
+            this.error(portalPullText(requestedEnv ? 'errors.envNotConfigured' : 'errors.noEnvConfigured', { envName }, requestedEnv
+                ? `Env "${envName}" is not configured. Run \`nb env add ${envName} --api-base-url <url>\` first.`
+                : 'No NocoBase env is configured yet. Run `nb init --ui` to create one first.'));
+        }
+        const result = await pullPortalSource({
+            portal: args.portal,
+            env,
+            envName,
+            cliVersion: String(this.config.pjson.version ?? '').trim(),
+            force: flags.force,
+            installDependencies: flags.install,
+        });
+        if (!result.changed) {
+            printInfo(result.noopReason ?? portalPullText('messages.noop', undefined, 'No pull is needed.'));
+            return;
+        }
+        printSuccess(portalPullText('messages.pulled', { portal: result.portal, portalDir: result.portalDir }, `Pulled portal source "${result.portal}" into ${result.portalDir}.`));
+    }
+}

package/dist/commands/portal/push.js

@@ -0,0 +1,79 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { translateCli } from '../../lib/cli-locale.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { pushPortalSource } from '../../lib/portal-source.js';
+import { printInfo, printSuccess } from '../../lib/ui.js';
+const portalPushText = (key, values, fallback) => translateCli(`commands.portalPush.${key}`, values, { fallback });
+export default class PortalPush extends Command {
+    static summary = 'Push local portal source changes to source storage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> customer',
+        '<%= config.bin %> <%= command.id %> customer --env prod --yes',
+        '<%= config.bin %> <%= command.id %> customer --message "Update customer portal"',
+    ];
+    static args = {
+        portal: Args.string({
+            required: true,
+            description: 'Portal name',
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name; omitted uses the current env',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
+        }),
+        message: Flags.string({
+            char: 'm',
+            description: 'Source update message; used as the Git commit message for Git-managed source',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PortalPush);
+        const requestedEnv = hasExplicitEnvSelection(this.argv) ? flags.env : undefined;
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            return;
+        }
+        const scope = resolveDefaultConfigScope();
+        const envName = requestedEnv ?? (await getCurrentEnvName({ scope }));
+        const env = await getEnv(envName, { scope });
+        if (!env) {
+            this.error(portalPushText(requestedEnv ? 'errors.envNotConfigured' : 'errors.noEnvConfigured', { envName }, requestedEnv
+                ? `Env "${envName}" is not configured. Run \`nb env add ${envName} --api-base-url <url>\` first.`
+                : 'No NocoBase env is configured yet. Run `nb init --ui` to create one first.'));
+        }
+        const result = await pushPortalSource({
+            portal: args.portal,
+            env,
+            envName,
+            cliVersion: String(this.config.pjson.version ?? '').trim(),
+            message: flags.message,
+        });
+        if (!result.changed) {
+            printInfo(result.noopReason ?? portalPushText('messages.noop', undefined, 'No push is needed.'));
+            return;
+        }
+        printSuccess(portalPushText('messages.pushed', { portal: result.portal, sourceRevision: result.sourceRevision ?? '' }, result.sourceRevision
+            ? `Pushed portal source "${result.portal}" (${result.sourceRevision}).`
+            : `Pushed portal source "${result.portal}".`));
+    }
+}

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

@@ -8,20 +8,51 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getCaddyProxyDriver, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
+import { resolveEnvProxyEntry, setEnvProxyEntry } from '../../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { getCaddyProxyDriver, writeManualCaddyProxyBundle, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
 import { normalizeProxyListenPort } from '../../../lib/proxy-nginx.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyCaddyGenerate extends Command {
     static summary = 'Generate caddy proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy caddy generate --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy caddy generate --manual --name default --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0 --upstream-port 13000',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/caddy in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by caddy reverse_proxy in manual mode',
+        }),
+        'upstream-port': Flags.string({
+            description: 'Upstream port used by caddy reverse_proxy in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
         }),
         host: Flags.string({
             description: 'Host exposed by the caddy site block, such as example.com or localhost',
@@ -35,9 +66,56 @@ export default class ProxyCaddyGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedUpstreamPort = flags['upstream-port']?.trim() || undefined;
+            const upstreamPort = normalizeProxyListenPort(requestedUpstreamPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedUpstreamPort && !upstreamPort) {
+                this.error(`Invalid manual upstream port "${requestedUpstreamPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !upstreamPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--upstream-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getCaddyProxyDriver();
+            const runtimeContext = await resolveCaddyProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating caddy proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualCaddyProxyBundle({
+                    name,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    upstreamPort,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
+                    : `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate caddy proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -53,10 +131,18 @@ export default class ProxyCaddyGenerate extends Command {
         announceTargetEnv(runtime.envName);
         startTask(`Generating caddy proxy config for env "${runtime.envName}" with the ${driver} driver...`);
         try {
-            const { bundle, status } = await writeCaddyProxyBundle(runtime, {
-                host: flags.host?.trim() || undefined,
-                port: normalizedPort,
-            }, runtimeContext);
+            const savedAppEntryOptions = resolveEnvProxyEntry(runtime.env.config, 'caddy');
+            const appEntryOptions = {
+                host: flags.host?.trim() || savedAppEntryOptions?.host,
+                port: normalizedPort ?? (savedAppEntryOptions?.port !== undefined ? String(savedAppEntryOptions.port) : undefined),
+            };
+            const { bundle, status } = await writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+            });
+            await setEnvProxyEntry(runtime.envName, 'caddy', {
+                host: appEntryOptions.host,
+                port: appEntryOptions.port ? Number(appEntryOptions.port) : undefined,
+            }, { scope: resolveDefaultConfigScope() });
             succeedTask(status === 'created'
                 ? `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
                 : `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);

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

@@ -8,19 +8,54 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeManualNginxProxyBundle, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { resolveEnvProxyEntry, setEnvProxyEntry } from '../../../lib/auth-store.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyNginxGenerate extends Command {
     static summary = 'Generate nginx proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy nginx generate --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy nginx generate --manual --name default --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0 --upstream-port 13000',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/nginx in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by nginx proxy_pass in manual mode',
+        }),
+        'upstream-port': Flags.string({
+            description: 'Upstream port used by nginx proxy_pass in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
+        }),
+        force: Flags.boolean({
+            description: 'Overwrite existing app.conf even when the managed block is missing',
+            default: false,
         }),
         host: Flags.string({
             description: 'Host exposed by the nginx entry config, such as example.com or localhost',
@@ -34,9 +69,56 @@ export default class ProxyNginxGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedUpstreamPort = flags['upstream-port']?.trim() || undefined;
+            const upstreamPort = normalizeProxyListenPort(requestedUpstreamPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedUpstreamPort && !upstreamPort) {
+                this.error(`Invalid manual upstream port "${requestedUpstreamPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !upstreamPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--upstream-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getNginxProxyDriver();
+            const runtimeContext = await resolveNginxProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating nginx proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualNginxProxyBundle({
+                    name,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    upstreamPort,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    force: flags.force,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
+                    : `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate nginx proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -52,10 +134,19 @@ export default class ProxyNginxGenerate extends Command {
         announceTargetEnv(runtime.envName);
         startTask(`Generating nginx proxy config for env "${runtime.envName}" with the ${driver} driver...`);
         try {
-            const { bundle, status } = await writeNginxProxyBundle(runtime, {
-                host: flags.host?.trim() || undefined,
-                port: normalizedPort,
-            }, runtimeContext);
+            const savedAppEntryOptions = resolveEnvProxyEntry(runtime.env.config, 'nginx');
+            const appEntryOptions = {
+                host: flags.host?.trim() || savedAppEntryOptions?.host,
+                port: normalizedPort ?? (savedAppEntryOptions?.port !== undefined ? String(savedAppEntryOptions.port) : undefined),
+            };
+            const { bundle, status } = await writeNginxProxyBundle(runtime, appEntryOptions, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                force: flags.force,
+            });
+            await setEnvProxyEntry(runtime.envName, 'nginx', {
+                host: appEntryOptions.host,
+                port: appEntryOptions.port ? Number(appEntryOptions.port) : undefined,
+            }, { scope: resolveDefaultConfigScope() });
             succeedTask(status === 'created'
                 ? `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
                 : `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);

package/dist/commands/revision/create.js

@@ -100,7 +100,7 @@ export default class RevisionCreate extends Command {
             path: '/app:publishEvent',
             body: {
                 plugin: 'plugin-version-control',
-                command: 'revision:create',
+                command: 'revision.create',
                 payload: {
                     description,
                 },

package/dist/commands/self/check.js

@@ -20,7 +20,7 @@ export default class SelfCheck extends Command {
     static flags = {
         channel: Flags.string({
             description: 'Release channel to compare against. Defaults to the current CLI channel.',
-            options: ['auto', 'latest', 'beta', 'alpha'],
+            options: ['auto', 'latest', 'test', 'beta', 'alpha'],
             default: 'auto',
         }),
         json: Flags.boolean({

package/dist/commands/self/update.js

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

package/dist/commands/skills/check.js

@@ -12,10 +12,7 @@ import { printInfo, renderTable } from '../../lib/ui.js';
 export default class SkillsCheck extends Command {
     static summary = 'Check the globally installed NocoBase AI coding skills';
     static description = 'Inspect the global NocoBase AI coding skills and report whether they are managed by the CLI and whether an update is available.';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --json',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --json'];
     static flags = {
         json: Flags.boolean({
             description: 'Output the result as JSON',
@@ -25,6 +22,7 @@ export default class SkillsCheck extends Command {
     async run() {
         const { flags } = await this.parse(SkillsCheck);
         const status = await inspectSkillsStatus();
+        const displaySkillNames = status.packageSkillNames.length ? status.packageSkillNames : status.installedSkillNames;
         if (flags.json) {
             this.log(JSON.stringify({
                 ok: true,
@@ -35,6 +33,7 @@ export default class SkillsCheck extends Command {
                 managedByNb: status.managedByNb,
                 sourcePackage: status.sourcePackage,
                 npmPackageName: status.npmPackageName,
+                packageSkillNames: status.packageSkillNames,
                 installedSkillNames: status.installedSkillNames,
                 installedVersion: status.installedVersion,
                 latestVersion: status.latestVersion,
@@ -50,7 +49,7 @@ export default class SkillsCheck extends Command {
             ['Skills home', status.globalRoot],
             ['Installed', status.installed ? 'yes' : 'no'],
             ['Managed by nb', status.managedByNb ? 'yes' : 'no'],
-            ['Installed skills', status.installedSkillNames.length ? status.installedSkillNames.join(', ') : '(none)'],
+            ['Installed skills', displaySkillNames.length ? displaySkillNames.join(', ') : '(none)'],
             ['Installed version', status.installedVersion ?? '(unknown)'],
             ['Latest version', status.latestVersion ?? '(unknown)'],
             ['Update available', status.updateAvailable === null ? 'unknown' : status.updateAvailable ? 'yes' : 'no'],