@nocobase/cli 2.1.0-beta.8 → 2.1.0

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

@@ -0,0 +1,68 @@
+/**
+ * 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 { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
+import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.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 --env app1 --host app1.example.com',
+        '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com --port 8080',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to generate proxy files for',
+            required: true,
+        }),
+        host: Flags.string({
+            description: 'Host exposed by the nginx entry config, such as example.com or localhost',
+        }),
+        port: Flags.string({
+            description: 'Port exposed by the nginx entry config, not the upstream NocoBase app port',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProxyNginxGenerate);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const requestedPort = flags.port?.trim() || undefined;
+        const normalizedPort = normalizeProxyListenPort(requestedPort);
+        if (requestedPort && !normalizedPort) {
+            this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind === 'http') {
+            this.error(`Can't generate an nginx proxy config for "${runtime.envName}" from this machine because the env only has an API connection.`);
+        }
+        if (runtime.kind === 'ssh') {
+            this.error(`Can't generate an nginx proxy config for "${runtime.envName}" yet because SSH envs are not implemented.`);
+        }
+        const driver = await getNginxProxyDriver();
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        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);
+            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}.`);
+        }
+        catch (error) {
+            failTask(`Failed to generate nginx proxy config for env "${runtime.envName}".`);
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * 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, loadHelpClass } from '@oclif/core';
+export default class ProxyNginx extends Command {
+    static summary = 'Manage nginx proxy generation and runtime selection';
+    static examples = [
+        '<%= config.bin %> proxy nginx current',
+        '<%= config.bin %> proxy nginx use local',
+        '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com',
+        '<%= config.bin %> proxy nginx start',
+        '<%= config.bin %> proxy nginx status',
+        '<%= config.bin %> proxy nginx info',
+    ];
+    async run() {
+        await this.parse(ProxyNginx);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'proxy nginx',
+            ...this.argv,
+        ]);
+    }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 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 { getCliConfigValue } from '../../../lib/cli-config.js';
+import { mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, resolveEnvProxyNginxSnippetsOutputDir, } from '../../../lib/env-proxy.js';
+import { formatNginxProxyInfoLines, resolveNginxProxyContainerName, resolveNginxProxyImage, resolveNginxProxyRuntimeContext, } from '../../../lib/proxy-nginx.js';
+export default class ProxyNginxInfo extends Command {
+    static summary = 'Show current nginx proxy driver and generated path info';
+    async run() {
+        await this.parse(ProxyNginxInfo);
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        const lines = formatNginxProxyInfoLines({
+            driver: runtimeContext.driver,
+            configFile: await mapProxyPathFromCliRoot(resolveEnvProxyMainOutputPath(), {
+                runtimeCliRoot: runtimeContext.runtimeCliRoot,
+            }),
+            snippetsDir: await mapProxyPathFromCliRoot(resolveEnvProxyNginxSnippetsOutputDir(), {
+                runtimeCliRoot: runtimeContext.runtimeCliRoot,
+            }),
+            upstreamHost: runtimeContext.upstreamHost,
+            nginxBinary: await getCliConfigValue('bin.nginx'),
+            runtimeRoot: runtimeContext.runtimeCliRoot,
+            containerName: await resolveNginxProxyContainerName(),
+            image: resolveNginxProxyImage(),
+        });
+        this.log(lines.join('\n'));
+    }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * 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 { getNginxProxyDriver, reloadNginxProxy, resolveNginxProxyRuntimeContext } from '../../../lib/proxy-nginx.js';
+import { failTask, startTask, succeedTask } from '../../../lib/ui.js';
+export default class ProxyNginxReload extends Command {
+    static summary = 'Reload the managed nginx proxy';
+    async run() {
+        await this.parse(ProxyNginxReload);
+        const driver = await getNginxProxyDriver();
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        startTask(`Reloading nginx proxy with the ${driver} driver...`);
+        try {
+            const result = await reloadNginxProxy(runtimeContext);
+            succeedTask(result === 'started'
+                ? `Nginx proxy started with the ${driver} driver using the latest config.`
+                : `Nginx proxy reloaded with the ${driver} driver.`);
+        }
+        catch (error) {
+            failTask(`Failed to reload nginx proxy with the ${driver} driver.`);
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * 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 { getNginxProxyDriver, resolveNginxProxyRuntimeContext, restartNginxProxy } from '../../../lib/proxy-nginx.js';
+import { failTask, startTask, succeedTask } from '../../../lib/ui.js';
+export default class ProxyNginxRestart extends Command {
+    static summary = 'Restart the managed nginx proxy';
+    async run() {
+        await this.parse(ProxyNginxRestart);
+        const driver = await getNginxProxyDriver();
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        startTask(`Restarting nginx proxy with the ${driver} driver...`);
+        try {
+            await restartNginxProxy(runtimeContext);
+            succeedTask(`Nginx proxy restarted with the ${driver} driver.`);
+        }
+        catch (error) {
+            failTask(`Failed to restart nginx proxy with the ${driver} driver.`);
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * 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 { getNginxProxyDriver, resolveNginxProxyRuntimeContext, startNginxProxy } from '../../../lib/proxy-nginx.js';
+import { failTask, startTask, succeedTask } from '../../../lib/ui.js';
+export default class ProxyNginxStart extends Command {
+    static summary = 'Start the managed nginx proxy';
+    async run() {
+        await this.parse(ProxyNginxStart);
+        const driver = await getNginxProxyDriver();
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        startTask(`Starting nginx proxy with the ${driver} driver...`);
+        try {
+            const result = await startNginxProxy(runtimeContext);
+            succeedTask(result === 'already-running'
+                ? `Nginx proxy is already running with the ${driver} driver.`
+                : `Nginx proxy started with the ${driver} driver.`);
+        }
+        catch (error) {
+            failTask(`Failed to start nginx proxy with the ${driver} driver.`);
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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 { formatNginxProxyStatusLines, getNginxProxyStatus, resolveNginxProxyRuntimeContext, } from '../../../lib/proxy-nginx.js';
+export default class ProxyNginxStatus extends Command {
+    static summary = 'Show the current nginx proxy runtime status';
+    async run() {
+        await this.parse(ProxyNginxStatus);
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        const status = await getNginxProxyStatus(runtimeContext);
+        this.log(formatNginxProxyStatusLines(status).join('\n'));
+    }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * 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 { getNginxProxyDriver, resolveNginxProxyRuntimeContext, stopNginxProxy } from '../../../lib/proxy-nginx.js';
+import { failTask, startTask, succeedTask } from '../../../lib/ui.js';
+export default class ProxyNginxStop extends Command {
+    static summary = 'Stop the managed nginx proxy';
+    async run() {
+        await this.parse(ProxyNginxStop);
+        const driver = await getNginxProxyDriver();
+        const runtimeContext = await resolveNginxProxyRuntimeContext();
+        startTask(`Stopping nginx proxy with the ${driver} driver...`);
+        try {
+            const result = await stopNginxProxy(runtimeContext);
+            succeedTask(result === 'already-stopped'
+                ? `Nginx proxy is already stopped with the ${driver} driver.`
+                : `Nginx proxy stopped with the ${driver} driver.`);
+        }
+        catch (error) {
+            failTask(`Failed to stop nginx proxy with the ${driver} driver.`);
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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 } from '@oclif/core';
+import { NGINX_PROXY_DRIVER_OPTIONS, normalizeNginxProxyDriver } from '../../../lib/cli-config.js';
+import { setNginxProxyDriver } from '../../../lib/proxy-nginx.js';
+export default class ProxyNginxUse extends Command {
+    static summary = 'Choose whether nginx runs locally or in Docker';
+    static examples = ['<%= config.bin %> proxy nginx use local', '<%= config.bin %> proxy nginx use docker'];
+    static args = {
+        driver: Args.string({
+            description: 'Nginx runtime driver',
+            required: true,
+            options: [...NGINX_PROXY_DRIVER_OPTIONS],
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(ProxyNginxUse);
+        const driver = normalizeNginxProxyDriver(args.driver);
+        if (!driver) {
+            this.error(`Unsupported nginx driver "${args.driver}". Use one of: ${NGINX_PROXY_DRIVER_OPTIONS.join(', ')}`);
+        }
+        const saved = await setNginxProxyDriver(driver);
+        this.log(saved);
+    }
+}

package/dist/commands/restart.js

@@ -0,0 +1,12 @@
+/**
+ * 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 AppRestart from './app/restart.js';
+export default class Restart extends AppRestart {
+    static hidden = true;
+}

package/dist/commands/revision/create.js

@@ -0,0 +1,118 @@
+/**
+ * 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 { executeRawApiRequest } from '../../lib/api-client.js';
+import { ensureCrossEnvConfirmed } from '../../lib/env-guard.js';
+const VERSION_CONTROL_PLUGIN_PACKAGE = '@nocobase/plugin-version-control';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function extractPluginList(data) {
+    const list = Array.isArray(data) ? data : isRecord(data) && Array.isArray(data.data) ? data.data : [];
+    return list.filter(isRecord).map((item) => ({
+        packageName: typeof item.packageName === 'string' ? item.packageName : undefined,
+        enabled: typeof item.enabled === 'boolean' ? item.enabled : undefined,
+    }));
+}
+export default class RevisionCreate extends Command {
+    static summary = 'Save the current NocoBase build as a restorable revision';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "description here"',
+        '<%= config.bin %> <%= command.id %> --env app1 "description here"',
+    ];
+    static args = {
+        description: Args.string({
+            required: true,
+            description: 'Revision description, up to 2000 characters.',
+        }),
+    };
+    static flags = {
+        'api-base-url': Flags.string({
+            description: 'NocoBase API base URL, for example http://localhost:13000/api',
+        }),
+        env: Flags.string({
+            char: 'e',
+            description: 'Environment name',
+        }),
+        role: Flags.string({
+            description: 'Role override, sent as X-Role',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'API key override',
+        }),
+        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',
+            description: 'Print raw JSON response',
+            default: false,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RevisionCreate);
+        const description = args.description;
+        if (description.length > 2000) {
+            this.error('Description length should not be over 2000');
+        }
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv: flags.env,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            return;
+        }
+        const pluginListResponse = await executeRawApiRequest({
+            envName: flags.env,
+            baseUrl: flags['api-base-url'],
+            role: flags.role,
+            token: flags.token,
+            method: 'GET',
+            path: '/pm:list',
+            query: {
+                mode: 'summary',
+            },
+        });
+        if (!pluginListResponse.ok) {
+            this.error(`Failed to check plugin status with status ${pluginListResponse.status}\n${JSON.stringify(pluginListResponse.data, null, 2)}`);
+        }
+        const versionControlPlugin = extractPluginList(pluginListResponse.data).find((plugin) => plugin.packageName === VERSION_CONTROL_PLUGIN_PACKAGE);
+        if (!versionControlPlugin?.enabled) {
+            this.error(`The ${VERSION_CONTROL_PLUGIN_PACKAGE} plugin is not enabled. Enable it first with \`nb plugin enable ${VERSION_CONTROL_PLUGIN_PACKAGE}\`.`);
+        }
+        const response = await executeRawApiRequest({
+            envName: flags.env,
+            baseUrl: flags['api-base-url'],
+            role: flags.role,
+            token: flags.token,
+            method: 'POST',
+            path: '/app:publishEvent',
+            body: {
+                plugin: 'plugin-version-control',
+                command: 'revision:create',
+                payload: {
+                    description,
+                },
+            },
+        });
+        if (!response.ok) {
+            this.error(`Request failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`);
+        }
+        if (flags['json-output']) {
+            this.log(JSON.stringify(response.data, null, 2));
+            return;
+        }
+        this.log('Revision created successfully');
+    }
+}

package/dist/commands/scaffold/migration.js

@@ -0,0 +1,38 @@
+/**
+ * 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 { runNocoBaseCommand } from "../../lib/run-npm.js";
+export default class ScaffoldMigration extends Command {
+    static args = {
+        name: Args.string({ description: 'migration name', required: true }),
+    };
+    static description = 'Generate a plugin migration file.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> migration-name --pkg @nocobase/plugin-acl',
+        '<%= config.bin %> <%= command.id %> migration-name --pkg @nocobase/plugin-acl --on afterLoad',
+    ];
+    static flags = {
+        pkg: Flags.string({ description: 'plugin package name', required: true }),
+        on: Flags.string({ description: 'on', required: false, options: ['beforeLoad', 'afterSync', 'afterLoad'] }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ScaffoldMigration);
+        const npmArgs = ['create-migration', args.name, '--pkg', flags.pkg];
+        if (flags.on) {
+            npmArgs.push('--on', flags.on);
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, { env: { LOGGER_SILENT: 'true' } });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/scaffold/plugin.js

@@ -0,0 +1,37 @@
+/**
+ * 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 { runNocoBaseCommand } from "../../lib/run-npm.js";
+export default class ScaffoldPlugin extends Command {
+    static args = {
+        pkg: Args.string({ description: 'plugin package name', required: true }),
+    };
+    static description = 'Generate a NocoBase plugin scaffold.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> @nocobase-example/plugin-hello',
+        '<%= config.bin %> <%= command.id %> @nocobase-example/plugin-hello --force-recreate',
+    ];
+    static flags = {
+        'force-recreate': Flags.boolean({ description: 'Force recreate the plugin', char: 'f', required: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ScaffoldPlugin);
+        const npmArgs = ['pm', 'create', args.pkg];
+        if (flags['force-recreate']) {
+            npmArgs.push('--force-recreate');
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, { env: { LOGGER_SILENT: 'true' } });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/self/check.js

@@ -0,0 +1,71 @@
+/**
+ * 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 { getRecommendedSelfUpdateCommand, inspectSelfStatus, } from '../../lib/self-manager.js';
+import { printInfo, renderTable } from '../../lib/ui.js';
+export default class SelfCheck extends Command {
+    static summary = 'Check the installed NocoBase CLI version and self-update support';
+    static description = 'Inspect the current NocoBase CLI install, resolve the latest version for the selected channel, and report whether automatic self-update is supported.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --channel beta',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        channel: Flags.string({
+            description: 'Release channel to compare against. Defaults to the current CLI channel.',
+            options: ['auto', 'latest', 'beta', 'alpha'],
+            default: 'auto',
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SelfCheck);
+        const status = await inspectSelfStatus({
+            channel: flags.channel,
+        });
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                kind: 'self',
+                packageName: status.packageName,
+                currentVersion: status.currentVersion,
+                latestVersion: status.latestVersion,
+                channel: status.channel,
+                updateAvailable: status.updateAvailable,
+                installMethod: status.installMethod,
+                updatable: status.updatable,
+                updateBlockedReason: status.updateBlockedReason,
+                recommendedCommand: getRecommendedSelfUpdateCommand(status),
+                registryError: status.registryError,
+            }, null, 2));
+            return;
+        }
+        this.log(renderTable(['Field', 'Value'], [
+            ['Current version', status.currentVersion || 'unknown'],
+            ['Latest version', status.latestVersion || 'unknown'],
+            ['Channel', status.channel],
+            ['Install method', status.installMethod],
+            ['Auto-update', status.updatable ? 'supported' : 'not supported'],
+            ['Update available', status.updateAvailable ? 'yes' : 'no'],
+        ]));
+        if (status.updateAvailable && status.updatable) {
+            printInfo('Run `nb self update`.');
+        }
+        else if (status.updateAvailable && status.updateBlockedReason) {
+            printInfo(status.updateBlockedReason);
+        }
+        if (status.registryError) {
+            printInfo(`Version check warning: ${status.registryError}`);
+        }
+    }
+}

package/dist/commands/self/index.js

@@ -0,0 +1,20 @@
+/**
+ * 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, loadHelpClass } from '@oclif/core';
+export default class Self extends Command {
+    static summary = 'Inspect or update the NocoBase CLI itself';
+    async run() {
+        await this.parse(Self);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'self',
+            ...this.argv,
+        ]);
+    }
+}