@nocobase/cli 2.1.0-beta.2 → 2.1.0-beta.20

package/dist/commands/ps.js

@@ -0,0 +1,116 @@
+/**
+ * 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 { buildDockerDbContainerName, dockerContainerExists, dockerContainerIsRunning, formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../lib/app-runtime.js';
+import { listEnvs } from '../lib/auth-store.js';
+import { renderTable } from '../lib/ui.js';
+function appUrl(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (port) {
+        return `http://127.0.0.1:${port}`;
+    }
+    const baseUrl = String(runtime.env.config.baseUrl ?? '').trim();
+    return baseUrl.replace(/\/api\/?$/, '');
+}
+async function isLocalAppHealthy(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (!port) {
+        return false;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/api/__health_check`, {
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        return response.ok && text.trim().toLowerCase() === 'ok';
+    }
+    catch (_error) {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function dockerStatus(containerName) {
+    if (!(await dockerContainerExists(containerName))) {
+        return 'missing';
+    }
+    return await dockerContainerIsRunning(containerName) ? 'running' : 'stopped';
+}
+async function dbStatus(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return runtime.kind === 'remote' ? 'external' : '-';
+    }
+    if (runtime.kind === 'remote') {
+        return 'external';
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.workspaceName);
+    return await dockerStatus(containerName);
+}
+async function appStatus(runtime) {
+    if (runtime.kind === 'remote') {
+        return 'remote';
+    }
+    if (runtime.kind === 'docker') {
+        return await dockerStatus(runtime.containerName);
+    }
+    return await isLocalAppHealthy(runtime) ? 'running' : 'stopped';
+}
+function sourceLabel(runtime) {
+    if (runtime.kind === 'remote') {
+        return 'remote';
+    }
+    return runtime.source;
+}
+export default class Ps extends Command {
+    static description = 'Show NocoBase runtime status for configured envs without starting or stopping anything.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to inspect. Omit to show all configured envs',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Ps);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const envNames = requestedEnv
+            ? [requestedEnv]
+            : Object.keys((await listEnvs()).envs).sort();
+        if (!envNames.length) {
+            this.log('No NocoBase env is configured yet. Run `nb init` to create one first.');
+            return;
+        }
+        const rows = [];
+        for (const envName of envNames) {
+            const runtime = await resolveManagedAppRuntime(envName);
+            if (!runtime) {
+                if (requestedEnv) {
+                    this.error(formatMissingManagedAppEnvMessage(envName));
+                }
+                rows.push([envName, '-', 'missing', '-', '']);
+                continue;
+            }
+            rows.push([
+                runtime.envName,
+                sourceLabel(runtime),
+                await appStatus(runtime),
+                await dbStatus(runtime),
+                appUrl(runtime),
+            ]);
+        }
+        this.log(renderTable(['Env', 'Source', 'App', 'Database', 'URL'], rows));
+    }
+}

package/dist/commands/restart.js

@@ -0,0 +1,74 @@
+/**
+ * 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';
+function argvHasToken(argv, tokens) {
+    return tokens.some((token) => argv.includes(token));
+}
+function pushFlag(argv, flag, value) {
+    if (value !== undefined) {
+        argv.push(flag, String(value));
+    }
+}
+export default class Restart extends Command {
+    static description = 'Restart NocoBase for the selected env by stopping it first, then starting it again.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env local',
+        '<%= config.bin %> <%= command.id %> --env local --quickstart',
+        '<%= config.bin %> <%= command.id %> --env local --port 12000',
+        '<%= config.bin %> <%= command.id %> --env local --daemon',
+        '<%= config.bin %> <%= command.id %> --env local --no-daemon',
+        '<%= config.bin %> <%= command.id %> --env local --instances 2',
+        '<%= config.bin %> <%= command.id %> --env local --launch-mode pm2',
+        '<%= config.bin %> <%= command.id %> --env local --verbose',
+        '<%= config.bin %> <%= command.id %> --env local-docker',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to restart. Defaults to the current env when omitted',
+        }),
+        quickstart: Flags.boolean({ description: 'Quickstart the application after stopping it', required: false }),
+        port: Flags.string({ description: 'Port (overrides appPort from env config when set)', char: 'p', required: false }),
+        daemon: Flags.boolean({
+            description: 'Run the application as a daemon after stopping it (default: true; use --no-daemon to stay in the foreground)',
+            char: 'd',
+            required: false,
+            default: true,
+            allowNo: true,
+        }),
+        instances: Flags.integer({ description: 'Number of instances to run after stopping it', char: 'i', required: false }),
+        'launch-mode': Flags.string({ description: 'Launch Mode', required: false, options: ['pm2', 'node'] }),
+        verbose: Flags.boolean({
+            description: 'Show raw shutdown/startup output from the underlying local or Docker command',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Restart);
+        const stopArgv = [];
+        const daemonFlagWasProvided = argvHasToken(this.argv, ['--daemon', '--no-daemon']);
+        pushFlag(stopArgv, '--env', flags.env?.trim() || undefined);
+        if (flags.verbose) {
+            stopArgv.push('--verbose');
+        }
+        await this.config.runCommand('stop', stopArgv);
+        const startArgv = [...stopArgv];
+        if (flags.quickstart) {
+            startArgv.push('--quickstart');
+        }
+        pushFlag(startArgv, '--port', flags.port);
+        if (daemonFlagWasProvided) {
+            startArgv.push(flags.daemon === false ? '--no-daemon' : '--daemon');
+        }
+        pushFlag(startArgv, '--instances', flags.instances);
+        pushFlag(startArgv, '--launch-mode', flags['launch-mode']);
+        await this.config.runCommand('start', startArgv);
+    }
+}

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 = 'Run the legacy NocoBase scaffold migration (forwards to `npm run scaffold:migration` in the repo root)';
+    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 = 'Run the legacy NocoBase scaffold plugin (forwards to `npm run scaffold:plugin` in the repo root)';
+    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` to update the CLI.');
+        }
+        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,
+        ]);
+    }
+}

package/dist/commands/self/update.js

@@ -0,0 +1,76 @@
+/**
+ * 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 { confirmAction } from '../../lib/ui.js';
+import { formatSelfUpdateUnavailableMessage, formatUnsupportedSelfUpdateMessage, inspectSelfStatus, updateSelf, } from '../../lib/self-manager.js';
+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 examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --channel alpha --json',
+    ];
+    static flags = {
+        channel: Flags.string({
+            description: 'Release channel to update to. Defaults to the current CLI channel.',
+            options: ['auto', 'latest', 'beta', 'alpha'],
+            default: 'auto',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip the update confirmation prompt',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SelfUpdate);
+        const status = await inspectSelfStatus({
+            channel: flags.channel,
+        });
+        if (!status.updatable) {
+            this.error(formatUnsupportedSelfUpdateMessage(status));
+        }
+        if (!status.latestVersion && status.registryError) {
+            this.error(formatSelfUpdateUnavailableMessage(status));
+        }
+        if (!flags.yes && status.updateAvailable) {
+            const confirmed = await confirmAction(`Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion}?`, { defaultValue: false });
+            if (!confirmed) {
+                this.log('Skipped CLI update.');
+                return;
+            }
+        }
+        const result = await updateSelf({
+            channel: flags.channel,
+        });
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                kind: 'self',
+                action: result.action,
+                packageName: result.status.packageName,
+                packageSpec: result.packageSpec,
+                channel: result.status.channel,
+                fromVersion: result.status.currentVersion,
+                toVersion: result.targetVersion,
+            }, null, 2));
+            return;
+        }
+        if (result.action === 'noop') {
+            this.log(`NocoBase CLI is already up to date at ${result.status.currentVersion}.`);
+            return;
+        }
+        this.log(`Updated NocoBase CLI from ${result.status.currentVersion} using ${result.packageSpec}${result.targetVersion ? ` (latest ${result.status.channel} resolves to ${result.targetVersion})` : ''}.`);
+    }
+}

package/dist/commands/skills/check.js

@@ -0,0 +1,63 @@
+/**
+ * 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 { inspectSkillsStatus } from '../../lib/skills-manager.js';
+import { printInfo, renderTable } from '../../lib/ui.js';
+export default class SkillsCheck extends Command {
+    static summary = 'Check the NocoBase AI coding skills installed for this workspace';
+    static description = 'Inspect the current workspace for 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 flags = {
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SkillsCheck);
+        const status = await inspectSkillsStatus();
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                kind: 'skills',
+                workspaceRoot: status.workspaceRoot,
+                installed: status.installed,
+                managedByNb: status.managedByNb,
+                sourcePackage: status.sourcePackage,
+                installedSkillNames: status.installedSkillNames,
+                installedRef: status.installedRef,
+                latestRef: status.latestRef,
+                updateAvailable: status.updateAvailable,
+                recommendedCommand: status.installed ? 'nb skills update --yes' : 'nb skills install --yes',
+                registryError: status.registryError,
+            }, null, 2));
+            return;
+        }
+        this.log(renderTable(['Field', 'Value'], [
+            ['Workspace', status.workspaceRoot],
+            ['Installed', status.installed ? 'yes' : 'no'],
+            ['Managed by nb', status.managedByNb ? 'yes' : 'no'],
+            ['Installed skills', status.installedSkillNames.length ? status.installedSkillNames.join(', ') : '(none)'],
+            ['Update available', status.updateAvailable === null ? 'unknown' : status.updateAvailable ? 'yes' : 'no'],
+        ]));
+        if (!status.installed) {
+            printInfo('Run `nb skills install` to install the NocoBase AI coding skills for this workspace.');
+            return;
+        }
+        if (status.updateAvailable) {
+            printInfo('Run `nb skills update` to refresh the NocoBase AI coding skills for this workspace.');
+        }
+        if (status.registryError) {
+            printInfo(`Update check warning: ${status.registryError}`);
+        }
+    }
+}

package/dist/commands/skills/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 Skills extends Command {
+    static summary = 'Inspect or synchronize NocoBase AI coding skills for this workspace';
+    async run() {
+        await this.parse(Skills);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'skills',
+            ...this.argv,
+        ]);
+    }
+}

package/dist/commands/skills/install.js

@@ -0,0 +1,58 @@
+/**
+ * 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 { confirmAction } from '../../lib/ui.js';
+import { installNocoBaseSkills } from '../../lib/skills-manager.js';
+export default class SkillsInstall extends Command {
+    static summary = 'Install the NocoBase AI coding skills for this workspace';
+    static description = 'Install the NocoBase AI coding skills for the current workspace. If they are already installed, this command does not update them.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip the install confirmation prompt',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SkillsInstall);
+        if (!flags.yes) {
+            const confirmed = await confirmAction('Install the NocoBase AI coding skills for this workspace?', { defaultValue: true });
+            if (!confirmed) {
+                this.log('Skipped skills install.');
+                return;
+            }
+        }
+        const result = await installNocoBaseSkills();
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                kind: 'skills',
+                action: result.action,
+                workspaceRoot: result.status.workspaceRoot,
+                installedSkillNames: result.status.installedSkillNames,
+                installedRef: result.status.installedRef,
+            }, null, 2));
+            return;
+        }
+        if (result.action === 'noop') {
+            this.log('NocoBase AI coding skills are already installed for this workspace. Run `nb skills update` to refresh them.');
+            return;
+        }
+        this.log('Installed the NocoBase AI coding skills for this workspace.');
+    }
+}

package/dist/commands/skills/update.js

@@ -0,0 +1,58 @@
+/**
+ * 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 { confirmAction } from '../../lib/ui.js';
+import { updateNocoBaseSkills } from '../../lib/skills-manager.js';
+export default class SkillsUpdate extends Command {
+    static summary = 'Update the NocoBase AI coding skills for this workspace';
+    static description = 'Refresh the NocoBase AI coding skills for the current workspace. This command only updates an existing nocobase/skills install.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip the update confirmation prompt',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SkillsUpdate);
+        if (!flags.yes) {
+            const confirmed = await confirmAction('Update the NocoBase AI coding skills for this workspace?', { defaultValue: true });
+            if (!confirmed) {
+                this.log('Skipped skills update.');
+                return;
+            }
+        }
+        const result = await updateNocoBaseSkills();
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                kind: 'skills',
+                action: result.action,
+                workspaceRoot: result.status.workspaceRoot,
+                installedSkillNames: result.status.installedSkillNames,
+                installedRef: result.status.installedRef,
+            }, null, 2));
+            return;
+        }
+        if (result.action === 'noop') {
+            this.log('NocoBase AI coding skills are already up to date for this workspace.');
+            return;
+        }
+        this.log('Updated the NocoBase AI coding skills for this workspace.');
+    }
+}