@nocobase/cli 2.1.0-beta.17 → 2.1.0-beta.19

package/dist/lib/run-npm.js

@@ -6,18 +6,62 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+/**
+ * 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 fs from 'node:fs';
 import path from 'node:path';
 import spawn from 'cross-spawn';
+const FORWARDED_SIGNALS = ['SIGINT', 'SIGTERM'];
 function resolveCommandName(name) {
     return name;
 }
-function resolveCwd(cwd) {
+function pathExists(candidate) {
+    try {
+        return Boolean(candidate) && fs.statSync(candidate) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+function hasLocalNocoBaseBinary(candidate) {
+    return (pathExists(path.join(candidate, 'node_modules', '.bin', 'nocobase-v1'))
+        || pathExists(path.join(candidate, 'node_modules', '.bin', 'nocobase-v1.cmd')));
+}
+export function resolveCwd(cwd) {
     const next = cwd ?? process.cwd();
     if (path.isAbsolute(next)) {
         return next;
     }
     return path.resolve(process.cwd(), next);
 }
+export function resolveProjectCwd(cwd) {
+    const normalizedCwd = typeof cwd === 'string' && cwd.trim() === '' ? undefined : cwd;
+    const next = normalizedCwd ?? process.cwd();
+    const resolvedNext = resolveCwd(normalizedCwd);
+    if (!normalizedCwd || path.isAbsolute(next)) {
+        return resolvedNext;
+    }
+    const baseCwd = process.cwd();
+    let current = baseCwd;
+    const fallback = resolvedNext;
+    while (true) {
+        const candidate = path.resolve(current, next);
+        if (hasLocalNocoBaseBinary(candidate)) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return fallback;
+        }
+        current = parent;
+    }
+}
 export function run(name, args, options) {
     const cwd = resolveCwd(options?.cwd);
     const label = options?.errorName ?? name;
@@ -32,8 +76,13 @@ export function run(name, args, options) {
             },
             windowsHide: process.platform === 'win32',
         });
-        child.once('error', reject);
+        const cleanupSignalForwarding = forwardSignalsToChild(child);
+        child.once('error', (error) => {
+            cleanupSignalForwarding();
+            reject(error);
+        });
         child.once('close', (code, signal) => {
+            cleanupSignalForwarding();
             if (code === 0) {
                 resolve();
                 return;
@@ -46,6 +95,33 @@ export function run(name, args, options) {
         });
     });
 }
+function forwardSignalsToChild(child) {
+    let forwardedSignalCount = 0;
+    const listeners = new Map();
+    const isChildRunning = () => child.exitCode === null && child.signalCode === null;
+    for (const signal of FORWARDED_SIGNALS) {
+        const listener = () => {
+            if (!isChildRunning()) {
+                return;
+            }
+            const nextSignal = forwardedSignalCount > 0 ? 'SIGKILL' : signal;
+            forwardedSignalCount += 1;
+            try {
+                child.kill(nextSignal);
+            }
+            catch {
+                // Ignore kill errors here and let the child close/error handlers surface the failure.
+            }
+        };
+        listeners.set(signal, listener);
+        process.on(signal, listener);
+    }
+    return () => {
+        for (const [signal, listener] of listeners) {
+            process.off(signal, listener);
+        }
+    };
+}
 export function commandSucceeds(name, args, options) {
     const cwd = resolveCwd(options?.cwd);
     const command = resolveCommandName(name);
@@ -107,16 +183,14 @@ export function runNpm(args, options) {
     return run('yarn', [...args], { ...options, errorName: 'npm' });
 }
 export function runNocoBaseCommand(args, options) {
-    let cwd = options?.cwd ?? process.cwd();
-    if (!path.isAbsolute(cwd)) {
-        cwd = path.resolve(process.cwd(), cwd);
-    }
+    const cwd = resolveProjectCwd(options?.cwd);
     const localBin = path.join(cwd, 'node_modules', '.bin');
-    return run('node', ['./node_modules/.bin/nocobase-v1', ...args], {
+    return run('nocobase-v1', [...args], {
         ...options,
+        cwd,
         errorName: 'nocobase command',
         env: {
-            PATH: `${localBin}${path.delimiter}${process.env.PATH}`,
+            PATH: `${localBin}${path.delimiter}${process.env.PATH ?? ''}`,
             ...options?.env,
         },
     });

package/dist/lib/self-manager.js

@@ -0,0 +1,246 @@
+/**
+ * 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 fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { commandOutput, run } from './run-npm.js';
+const DEFAULT_PACKAGE_NAME = '@nocobase/cli';
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+function normalizePath(value) {
+    return path.resolve(value);
+}
+function isSubPath(parent, child) {
+    const relative = path.relative(normalizePath(parent), normalizePath(child));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function parseVersion(version) {
+    const normalized = String(version ?? '').trim();
+    const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-.]+))?$/);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4] ? match[4].split('.').filter(Boolean) : [],
+    };
+}
+function compareIdentifier(left, right) {
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+        return Number(left) - Number(right);
+    }
+    if (leftNumeric) {
+        return -1;
+    }
+    if (rightNumeric) {
+        return 1;
+    }
+    return left.localeCompare(right);
+}
+export function compareVersions(leftVersion, rightVersion) {
+    const left = parseVersion(leftVersion);
+    const right = parseVersion(rightVersion);
+    if (!left || !right) {
+        return String(leftVersion ?? '').localeCompare(String(rightVersion ?? ''));
+    }
+    if (left.major !== right.major) {
+        return left.major - right.major;
+    }
+    if (left.minor !== right.minor) {
+        return left.minor - right.minor;
+    }
+    if (left.patch !== right.patch) {
+        return left.patch - right.patch;
+    }
+    if (left.prerelease.length === 0 && right.prerelease.length === 0) {
+        return 0;
+    }
+    if (left.prerelease.length === 0) {
+        return 1;
+    }
+    if (right.prerelease.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(left.prerelease.length, right.prerelease.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftIdentifier = left.prerelease[index];
+        const rightIdentifier = right.prerelease[index];
+        if (leftIdentifier === undefined) {
+            return -1;
+        }
+        if (rightIdentifier === undefined) {
+            return 1;
+        }
+        const compared = compareIdentifier(leftIdentifier, rightIdentifier);
+        if (compared !== 0) {
+            return compared;
+        }
+    }
+    return 0;
+}
+function detectChannel(currentVersion) {
+    if (/-alpha(?:[.-]|$)/i.test(currentVersion)) {
+        return 'alpha';
+    }
+    if (/-beta(?:[.-]|$)/i.test(currentVersion)) {
+        return 'beta';
+    }
+    return 'latest';
+}
+function readCurrentVersion(packageRoot) {
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+    const content = fs.readFileSync(packageJsonPath, 'utf8');
+    const pkg = JSON.parse(content);
+    return String(pkg.version ?? '').trim();
+}
+function detectInstallMethod(packageRoot, globalPrefix) {
+    if (fs.existsSync(path.join(packageRoot, 'src'))
+        && fs.existsSync(path.join(packageRoot, 'tsconfig.json'))) {
+        return 'source';
+    }
+    if (globalPrefix && isSubPath(globalPrefix, packageRoot)) {
+        return 'npm-global';
+    }
+    if (packageRoot.includes(`${path.sep}node_modules${path.sep}`)) {
+        return 'package-local';
+    }
+    return 'unknown';
+}
+async function readGlobalPrefix(commandOutputFn) {
+    try {
+        return (await commandOutputFn('npm', ['prefix', '-g'], {
+            errorName: 'npm prefix',
+        })).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readDistTags(packageName, commandOutputFn) {
+    const output = await commandOutputFn('npm', ['view', packageName, 'dist-tags', '--json'], {
+        errorName: 'npm view',
+    });
+    const parsed = JSON.parse(output);
+    return parsed ?? {};
+}
+function getUnsupportedSelfUpdateReason(installMethod) {
+    if (installMethod === 'source') {
+        return [
+            'This CLI is running from source in a repository checkout.',
+            'Automatic self-update is only supported for standard global npm installs.',
+            'Upgrade this checkout through your repo workflow instead.',
+        ].join(' ');
+    }
+    if (installMethod === 'package-local') {
+        return [
+            'This CLI is installed from a local project dependency tree.',
+            'Automatic self-update is only supported for standard global npm installs.',
+            'Upgrade the parent project dependency that provides this CLI instead.',
+        ].join(' ');
+    }
+    if (installMethod === 'unknown') {
+        return [
+            'This CLI install could not be recognized as a standard global npm install.',
+            'Automatic self-update is only supported for standard global npm installs.',
+        ].join(' ');
+    }
+    return undefined;
+}
+export function getRecommendedSelfUpdateCommand(status) {
+    if (!status.updatable || !status.updateAvailable) {
+        return undefined;
+    }
+    return 'nb self update --yes';
+}
+export function formatSelfUpdateUnavailableMessage(status) {
+    if (status.registryError) {
+        return [
+            `Couldn't resolve the latest published version for ${status.packageName}.`,
+            'Check your npm registry access and try again.',
+            `Details: ${status.registryError}`,
+        ].join('\n');
+    }
+    return [
+        `Couldn't resolve the latest published version for ${status.packageName}.`,
+        'Check your npm registry access and try again.',
+    ].join('\n');
+}
+export function getSelfUpdatePackageSpec(status) {
+    return `${status.packageName}@${status.channel}`;
+}
+export async function inspectSelfStatus(options = {}) {
+    const packageRoot = options.packageRoot ? normalizePath(options.packageRoot) : PACKAGE_ROOT;
+    const packageName = options.packageName ?? DEFAULT_PACKAGE_NAME;
+    const currentVersion = options.currentVersion ?? readCurrentVersion(packageRoot);
+    const channel = options.channel && options.channel !== 'auto' ? options.channel : detectChannel(currentVersion);
+    const commandOutputFn = options.commandOutputFn ?? commandOutput;
+    const globalPrefix = await readGlobalPrefix(commandOutputFn);
+    const installMethod = detectInstallMethod(packageRoot, globalPrefix);
+    let latestVersion;
+    let registryError;
+    try {
+        const distTags = await readDistTags(packageName, commandOutputFn);
+        latestVersion = distTags[channel] || distTags.latest;
+    }
+    catch (error) {
+        registryError = error instanceof Error ? error.message : String(error);
+    }
+    const updateAvailable = latestVersion ? compareVersions(latestVersion, currentVersion) > 0 : false;
+    return {
+        packageName,
+        packageRoot,
+        currentVersion,
+        channel,
+        latestVersion,
+        updateAvailable,
+        installMethod,
+        updatable: installMethod === 'npm-global',
+        updateBlockedReason: getUnsupportedSelfUpdateReason(installMethod),
+        globalPrefix,
+        registryError,
+    };
+}
+export function formatUnsupportedSelfUpdateMessage(status) {
+    return status.updateBlockedReason
+        ?? [
+            'Automatic self-update is only supported for standard global npm installs.',
+        ].join('\n');
+}
+export async function updateSelf(options = {}) {
+    const status = await inspectSelfStatus(options);
+    if (!status.updatable) {
+        throw new Error(formatUnsupportedSelfUpdateMessage(status));
+    }
+    const targetVersion = options.targetVersion ?? status.latestVersion;
+    if (!targetVersion) {
+        throw new Error(formatSelfUpdateUnavailableMessage(status));
+    }
+    if (!targetVersion || compareVersions(targetVersion, status.currentVersion) <= 0) {
+        return {
+            action: 'noop',
+            status,
+            targetVersion,
+            packageSpec: getSelfUpdatePackageSpec(status),
+        };
+    }
+    const packageSpec = getSelfUpdatePackageSpec(status);
+    await (options.runFn ?? run)('npm', ['install', '-g', packageSpec], {
+        stdio: 'inherit',
+        errorName: 'npm install',
+    });
+    return {
+        action: 'updated',
+        status,
+        targetVersion,
+        packageSpec,
+    };
+}

package/dist/lib/skills-manager.js

@@ -0,0 +1,202 @@
+/**
+ * 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 fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { commandOutput, run } from './run-npm.js';
+export const NOCOBASE_SKILLS_PACKAGE = 'nocobase/skills';
+export const NOCOBASE_SKILLS_REPO_URL = 'https://github.com/nocobase/skills.git';
+const NOCOBASE_SKILLS_NAME_PREFIX = 'nocobase-';
+function normalizePath(value) {
+    return path.resolve(value);
+}
+export function resolveSkillsWorkspaceRoot(startCwd = process.cwd()) {
+    let current = normalizePath(startCwd);
+    while (true) {
+        if (fs.existsSync(path.join(current, '.nocobase')) || fs.existsSync(path.join(current, '.agents'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return normalizePath(startCwd);
+        }
+        current = parent;
+    }
+}
+export function getManagedSkillsStateFile(workspaceRoot) {
+    return path.join(workspaceRoot, '.nocobase', 'skills.json');
+}
+async function readManagedSkillsState(workspaceRoot) {
+    const filePath = getManagedSkillsStateFile(workspaceRoot);
+    try {
+        const content = await fsp.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeManagedSkillsState(workspaceRoot, state) {
+    const filePath = getManagedSkillsStateFile(workspaceRoot);
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, JSON.stringify(state, null, 2));
+}
+export async function listProjectSkills(options = {}) {
+    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
+    const output = await (options.commandOutputFn ?? commandOutput)('npx', ['-y', 'skills', 'list', '--json'], {
+        cwd: workspaceRoot,
+        errorName: 'skills list',
+    });
+    const parsed = JSON.parse(output);
+    return Array.isArray(parsed) ? parsed : [];
+}
+function pickInstalledNocoBaseSkillNames(installedSkills, state) {
+    const installedNames = new Set(installedSkills.map((skill) => String(skill.name ?? '').trim()).filter(Boolean));
+    if (state?.skillNames?.length) {
+        return state.skillNames.filter((name) => installedNames.has(name)).sort();
+    }
+    return Array.from(installedNames)
+        .filter((name) => name.startsWith(NOCOBASE_SKILLS_NAME_PREFIX))
+        .sort();
+}
+export async function readNocoBaseSkillsHeadRef(options = {}) {
+    try {
+        const output = await (options.commandOutputFn ?? commandOutput)('git', ['ls-remote', NOCOBASE_SKILLS_REPO_URL, 'HEAD'], {
+            cwd: options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot(),
+            errorName: 'git ls-remote',
+        });
+        const ref = output.trim().split(/\s+/)[0];
+        return { ref: ref || undefined };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function inspectSkillsStatus(options = {}) {
+    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
+    const stateFile = getManagedSkillsStateFile(workspaceRoot);
+    const [installedSkills, managedState] = await Promise.all([
+        listProjectSkills({
+            workspaceRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
+        readManagedSkillsState(workspaceRoot),
+    ]);
+    const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
+    const managedByNb = managedState?.packageName === NOCOBASE_SKILLS_PACKAGE;
+    let latestRef;
+    let registryError;
+    let updateAvailable = installedSkillNames.length > 0 ? null : false;
+    if (installedSkillNames.length > 0 || managedByNb) {
+        const remote = await readNocoBaseSkillsHeadRef({
+            workspaceRoot,
+            commandOutputFn: options.commandOutputFn,
+        });
+        latestRef = remote.ref;
+        registryError = remote.error;
+        if (managedState?.installedRef && latestRef) {
+            updateAvailable = latestRef !== managedState.installedRef;
+        }
+    }
+    return {
+        workspaceRoot,
+        stateFile,
+        installed: installedSkillNames.length > 0,
+        managedByNb,
+        sourcePackage: NOCOBASE_SKILLS_PACKAGE,
+        installedSkillNames,
+        latestRef,
+        installedRef: managedState?.installedRef,
+        updateAvailable,
+        registryError,
+    };
+}
+function formatSkillsNotInstalledMessage() {
+    return [
+        'NocoBase AI coding skills are not installed for this workspace.',
+        'Run `nb skills install` first.',
+    ].join('\n');
+}
+async function persistManagedSkillsState(workspaceRoot, options = {}) {
+    const installedSkills = await listProjectSkills({
+        workspaceRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    const managedState = await readManagedSkillsState(workspaceRoot);
+    const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
+    const remote = await readNocoBaseSkillsHeadRef({
+        workspaceRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    const now = new Date().toISOString();
+    await writeManagedSkillsState(workspaceRoot, {
+        packageName: NOCOBASE_SKILLS_PACKAGE,
+        repoUrl: NOCOBASE_SKILLS_REPO_URL,
+        installedAt: managedState?.installedAt ?? now,
+        updatedAt: now,
+        installedRef: remote.ref,
+        skillNames: installedSkillNames,
+    });
+    return await inspectSkillsStatus({
+        workspaceRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+}
+export async function installNocoBaseSkills(options = {}) {
+    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
+    const status = await inspectSkillsStatus({
+        workspaceRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (status.installed) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    await (options.runFn ?? run)('npx', ['-y', 'skills', 'add', NOCOBASE_SKILLS_PACKAGE, '-y'], {
+        cwd: workspaceRoot,
+        stdio: 'inherit',
+        errorName: 'skills add',
+    });
+    return {
+        action: 'installed',
+        status: await persistManagedSkillsState(workspaceRoot, options),
+    };
+}
+export async function updateNocoBaseSkills(options = {}) {
+    const workspaceRoot = options.workspaceRoot ? normalizePath(options.workspaceRoot) : resolveSkillsWorkspaceRoot();
+    const status = await inspectSkillsStatus({
+        workspaceRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed) {
+        throw new Error(formatSkillsNotInstalledMessage());
+    }
+    if (status.managedByNb
+        && status.latestRef
+        && status.installedRef
+        && status.latestRef === status.installedRef) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    await (options.runFn ?? run)('npx', ['-y', 'skills', 'update', '-p', '-y', ...status.installedSkillNames], {
+        cwd: workspaceRoot,
+        stdio: 'inherit',
+        errorName: 'skills update',
+    });
+    return {
+        action: 'updated',
+        status: await persistManagedSkillsState(workspaceRoot, options),
+    };
+}

package/dist/locale/en-US.json

@@ -135,13 +135,27 @@
       "prompts": {
         "source": {
           "message": "How would you like to get NocoBase?",
-          "npmLabel": "npm package",
-          "gitLabel": "Git repository",
-          "dockerLabel": "Docker image"
+          "dockerLabel": "Docker install (Recommended)",
+          "dockerHint": "Best for no-code and low-maintenance setups. You can upgrade later by pulling a newer image and restarting the app.",
+          "npmLabel": "create-nocobase-app install",
+          "npmHint": "Best when you want an app project with business code kept separate from the NocoBase framework, while still supporting low-code development.",
+          "gitLabel": "Git source install",
+          "gitHint": "Best when you want to try the latest unreleased changes, contribute code, or debug and modify NocoBase source directly. This option is more developer-oriented."
         },
         "version": {
-          "message": "Which version would you like to use? You can enter a package version, Docker image tag, or Git ref such as a branch name.",
-          "placeholder": "alpha"
+          "message": "Which version would you like to use?",
+          "latestLabel": "latest",
+          "latestHint": "Stable release. Best for production use and the most predictable experience. Currently unavailable.",
+          "betaLabel": "beta",
+          "betaHint": "Preview release. Good for trying upcoming features before general release.",
+          "alphaLabel": "alpha",
+          "alphaHint": "Development release. Includes the newest changes, but may be incomplete or unstable.",
+          "otherLabel": "Other",
+          "otherHint": "Enter another package version, Docker tag, or Git ref manually, such as a branch name."
+        },
+        "otherVersion": {
+          "message": "Enter the version, Docker tag, or Git ref you want to use.",
+          "placeholder": "For example: fix/cli-v2"
         },
         "dockerRegistry": {
           "message": "Which Docker registry would you like to use? The image tag is set separately in Version.",

package/dist/locale/zh-CN.json

@@ -135,17 +135,31 @@
       "prompts": {
         "source": {
           "message": "你想通过哪种方式获取 NocoBase？",
-          "npmLabel": "npm 包",
-          "gitLabel": "Git 仓库",
-          "dockerLabel": "Docker 镜像"
+          "dockerLabel": "Docker 安装（推荐）",
+          "dockerHint": "适合无代码或低维护成本场景。后续升级时，拉取新镜像并重启应用即可。",
+          "npmLabel": "create-nocobase-app 安装",
+          "npmHint": "适合希望将业务代码与 NocoBase 框架保持独立的场景，同时仍然支持低代码开发。",
+          "gitLabel": "Git 源码安装",
+          "gitHint": "适合体验最新未发布版本、参与贡献，或直接修改和调试 NocoBase 源码。这个方式更偏向开发者使用。"
         },
         "version": {
-          "message": "你想使用哪个版本？这里可以填写 npm 版本号、Docker tag，或 Git ref（例如分支名）。",
-          "placeholder": "alpha"
+          "message": "你想使用哪个版本？",
+          "latestLabel": "latest",
+          "latestHint": "稳定版。适合生产环境和希望获得稳定体验的场景。当前暂不可用。",
+          "betaLabel": "beta",
+          "betaHint": "测试版。包含即将发布的新功能，适合提前体验和反馈。",
+          "alphaLabel": "alpha",
+          "alphaHint": "开发版。功能更新最快，但可能不完整或不稳定。",
+          "otherLabel": "其他",
+          "otherHint": "手动填写其他版本号、Docker tag 或 Git ref，例如分支名。"
+        },
+        "otherVersion": {
+          "message": "请输入你想使用的版本号、Docker tag 或 Git ref。",
+          "placeholder": "例如：fix/cli-v2"
         },
         "dockerRegistry": {
           "message": "你想使用哪个 Docker registry？镜像 tag 请单独在 Version 中填写。",
-          "placeholder": "nocobase/nocobase"
+          "placeholder": "registry.cn-shanghai.aliyuncs.com/nocobase/nocobase"
         },
         "dockerPlatform": {
           "message": "要使用哪个 Docker 镜像平台？",

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.0-beta.17",
+  "version": "2.1.0-beta.19",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "yarn clean && tsc -p tsconfig.json && mkdir -p dist/locale && cp src/locale/*.json dist/locale/",
+    "clean": "node ./scripts/clean.mjs",
+    "build": "node ./scripts/build.mjs",
     "test": "TEST_ENV=server-side yarn --cwd ../../.. vitest run packages/core/cli"
   },
   "keywords": [],
@@ -39,6 +39,12 @@
       "env": {
         "description": "Manage NocoBase project environments and update command runtimes."
       },
+      "self": {
+        "description": "Inspect or update the NocoBase CLI itself."
+      },
+      "skills": {
+        "description": "Inspect or synchronize NocoBase AI coding skills for the current workspace."
+      },
       "api": {
         "description": "Work with NocoBase API."
       }
@@ -62,5 +68,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "227d625e47174ab7b3a90170e7c6c67bbdf36e23"
+  "gitHead": "d89ab08dbcb25877de69827d5bad6823c27b2cbb"
 }