@nocobase/cli 2.1.0-alpha.3 → 2.1.0-alpha.30

package/dist/lib/self-manager.js

@@ -0,0 +1,301 @@
+/**
+ * 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 { fileURLToPath } from 'node:url';
+import { resolveCliHomeDir } from './cli-home.js';
+import { commandOutput, run } from './run-npm.js';
+const DEFAULT_PACKAGE_NAME = '@nocobase/cli';
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const INSTALL_METHOD_CACHE_FILE = 'self-install-methods.json';
+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';
+}
+function getInstallMethodCacheFile() {
+    return path.join(resolveCliHomeDir('global'), INSTALL_METHOD_CACHE_FILE);
+}
+function getInstallMethodCacheKey(packageRoot) {
+    return normalizePath(path.join(packageRoot, 'bin', 'run.js'));
+}
+async function readInstallMethodCache() {
+    try {
+        const raw = await fsp.readFile(getInstallMethodCacheFile(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeInstallMethodCache(state) {
+    const filePath = getInstallMethodCacheFile();
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, JSON.stringify(state, null, 2));
+}
+async function readCachedInstallMethod(packageRoot) {
+    const state = await readInstallMethodCache();
+    return state.entries?.[getInstallMethodCacheKey(packageRoot)];
+}
+async function writeCachedInstallMethod(packageRoot, entry) {
+    const state = await readInstallMethodCache();
+    const entries = {
+        ...(state.entries ?? {}),
+        [getInstallMethodCacheKey(packageRoot)]: entry,
+    };
+    await writeInstallMethodCache({ entries });
+}
+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 inspectSelfInstall(options = {}) {
+    const packageRoot = options.packageRoot ? normalizePath(options.packageRoot) : PACKAGE_ROOT;
+    const commandOutputFn = options.commandOutputFn ?? commandOutput;
+    const cachedInstallMethod = await readCachedInstallMethod(packageRoot);
+    const globalPrefix = cachedInstallMethod?.globalPrefix ?? await readGlobalPrefix(commandOutputFn);
+    const installMethod = cachedInstallMethod?.installMethod ?? detectInstallMethod(packageRoot, globalPrefix);
+    if (!cachedInstallMethod) {
+        await writeCachedInstallMethod(packageRoot, {
+            installMethod,
+            globalPrefix,
+        });
+    }
+    return {
+        packageRoot,
+        installMethod,
+        globalPrefix,
+    };
+}
+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 { installMethod, globalPrefix } = await inspectSelfInstall({
+        packageRoot,
+        commandOutputFn,
+    });
+    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: options.verbose ? 'inherit' : 'ignore',
+        errorName: 'npm install',
+    });
+    return {
+        action: 'updated',
+        status,
+        targetVersion,
+        packageSpec,
+    };
+}

package/dist/lib/skills-manager.js

@@ -0,0 +1,296 @@
+/**
+ * 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 fsp from 'node:fs/promises';
+import path from 'node:path';
+import { resolveCliHomeDir } from './cli-home.js';
+import { compareVersions } from './self-manager.js';
+import { commandOutput, commandOutputViaFile, run } from './run-npm.js';
+export const NOCOBASE_SKILLS_SOURCE = 'nocobase/skills';
+export const NOCOBASE_SKILLS_PACKAGE_NAME = '@nocobase/skills';
+const NOCOBASE_SKILLS_NAME_PREFIX = 'nocobase-';
+function normalizePath(value) {
+    return path.resolve(value);
+}
+export function resolveGlobalSkillsRoot(_startCwd = process.cwd()) {
+    return normalizePath(resolveCliHomeDir('global'));
+}
+export function resolveSkillsWorkspaceRoot(startCwd = process.cwd()) {
+    return resolveGlobalSkillsRoot(startCwd);
+}
+function resolveSkillsRoot(options = {}) {
+    return options.globalRoot
+        ? normalizePath(options.globalRoot)
+        : options.workspaceRoot
+            ? normalizePath(options.workspaceRoot)
+            : resolveGlobalSkillsRoot();
+}
+function getSkillsCacheRoot(globalRoot) {
+    return path.join(globalRoot, 'cache', 'skills');
+}
+export function getManagedSkillsStateFile(workspaceRoot) {
+    return path.join(workspaceRoot, 'skills.json');
+}
+async function ensureSkillsWorkspaceRoot(workspaceRoot) {
+    await fsp.mkdir(workspaceRoot, { recursive: true });
+}
+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 listGlobalSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    const output = await (options.commandOutputFn ?? commandOutputViaFile)('npx', ['-y', 'skills', 'list', '-g', '--json'], {
+        cwd: globalRoot,
+        errorName: 'skills list',
+    });
+    const parsed = JSON.parse(output);
+    return Array.isArray(parsed) ? parsed : [];
+}
+export async function listProjectSkills(options = {}) {
+    return await listGlobalSkills(options);
+}
+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();
+}
+async function readPublishedSkillsVersion(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    try {
+        const output = await (options.commandOutputFn ?? commandOutput)('npm', ['view', NOCOBASE_SKILLS_PACKAGE_NAME, 'version', '--json'], {
+            cwd: globalRoot,
+            errorName: 'npm view',
+        });
+        const parsed = JSON.parse(output);
+        const version = String(parsed ?? '').trim();
+        return { version: version || undefined };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function readCachedSkillsVersion(cacheRoot) {
+    const packageJsonPath = path.join(cacheRoot, 'node_modules', '@nocobase', 'skills', 'package.json');
+    try {
+        const content = await fsp.readFile(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(content);
+        const version = String(parsed.version ?? '').trim();
+        return version || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function prepareLocalSkillsPackage(globalRoot, options = {}, targetVersion) {
+    const cacheRoot = getSkillsCacheRoot(globalRoot);
+    const packageDir = path.join(cacheRoot, 'node_modules', '@nocobase', 'skills');
+    const packageSpec = targetVersion ? `${NOCOBASE_SKILLS_PACKAGE_NAME}@${targetVersion}` : NOCOBASE_SKILLS_PACKAGE_NAME;
+    const cachedVersion = await readCachedSkillsVersion(cacheRoot);
+    await fsp.mkdir(cacheRoot, { recursive: true });
+    if (targetVersion && cachedVersion && compareVersions(cachedVersion, targetVersion) === 0) {
+        return {
+            packageDir,
+            cleanup: async () => undefined,
+        };
+    }
+    await fsp.rm(path.join(cacheRoot, 'node_modules'), { recursive: true, force: true });
+    await (options.runFn ?? run)('npm', ['install', '--no-save', '--ignore-scripts', '--no-package-lock', packageSpec], {
+        cwd: cacheRoot,
+        stdio: options.verbose ? 'inherit' : 'ignore',
+        errorName: 'npm install',
+    });
+    try {
+        await fsp.access(packageDir);
+    }
+    catch {
+        throw new Error(`npm install did not produce a local ${NOCOBASE_SKILLS_PACKAGE_NAME} package.`);
+    }
+    return {
+        packageDir,
+        cleanup: async () => undefined,
+    };
+}
+export async function inspectSkillsStatus(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const stateFile = getManagedSkillsStateFile(globalRoot);
+    const [installedSkills, managedState] = await Promise.all([
+        listGlobalSkills({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
+        readManagedSkillsState(globalRoot),
+    ]);
+    const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
+    const managedByNb = managedState?.packageName === NOCOBASE_SKILLS_PACKAGE_NAME;
+    let latestVersion;
+    let registryError;
+    let updateAvailable = installedSkillNames.length > 0 ? null : false;
+    if (installedSkillNames.length > 0 || managedByNb) {
+        const published = await readPublishedSkillsVersion({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        });
+        latestVersion = published.version;
+        registryError = published.error;
+        const installedVersion = managedState?.installedVersion ?? managedState?.installedRef;
+        if (installedVersion && latestVersion) {
+            updateAvailable = compareVersions(latestVersion, installedVersion) > 0;
+        }
+    }
+    const installedVersion = managedState?.installedVersion ?? managedState?.installedRef;
+    return {
+        globalRoot,
+        workspaceRoot: globalRoot,
+        stateFile,
+        installed: installedSkillNames.length > 0,
+        managedByNb,
+        sourcePackage: managedState?.sourcePackage ?? NOCOBASE_SKILLS_SOURCE,
+        npmPackageName: managedState?.packageName ?? NOCOBASE_SKILLS_PACKAGE_NAME,
+        installedSkillNames,
+        latestVersion,
+        installedVersion,
+        latestRef: latestVersion,
+        installedRef: installedVersion,
+        updateAvailable,
+        registryError,
+    };
+}
+async function persistManagedSkillsState(globalRoot, options = {}) {
+    const installedSkills = await listGlobalSkills({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    const managedState = await readManagedSkillsState(globalRoot);
+    const installedSkillNames = pickInstalledNocoBaseSkillNames(installedSkills, managedState);
+    const published = await readPublishedSkillsVersion({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    const now = new Date().toISOString();
+    await writeManagedSkillsState(globalRoot, {
+        packageName: NOCOBASE_SKILLS_PACKAGE_NAME,
+        sourcePackage: NOCOBASE_SKILLS_SOURCE,
+        installedAt: managedState?.installedAt ?? now,
+        updatedAt: now,
+        installedVersion: published.version,
+        skillNames: installedSkillNames,
+    });
+    return await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+}
+async function reinstallManagedSkills(globalRoot, options = {}, targetVersion) {
+    const prepared = await prepareLocalSkillsPackage(globalRoot, options, targetVersion);
+    try {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'add', prepared.packageDir, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills add',
+        });
+    }
+    finally {
+        await prepared.cleanup();
+    }
+}
+export async function installNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (status.installed) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    await ensureSkillsWorkspaceRoot(globalRoot);
+    await reinstallManagedSkills(globalRoot, options, status.latestVersion);
+    return {
+        action: 'installed',
+        status: await persistManagedSkillsState(globalRoot, options),
+    };
+}
+export async function updateNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed) {
+        return {
+            action: 'noop',
+            reason: 'not-installed',
+            status,
+        };
+    }
+    if (status.managedByNb
+        && status.latestVersion
+        && status.installedVersion
+        && compareVersions(status.latestVersion, status.installedVersion) <= 0) {
+        return {
+            action: 'noop',
+            reason: 'up-to-date',
+            status,
+        };
+    }
+    await reinstallManagedSkills(globalRoot, options, status.latestVersion);
+    return {
+        action: 'updated',
+        status: await persistManagedSkillsState(globalRoot, options),
+    };
+}
+export async function removeNocoBaseSkills(options = {}) {
+    const globalRoot = resolveSkillsRoot(options);
+    const status = await inspectSkillsStatus({
+        globalRoot,
+        commandOutputFn: options.commandOutputFn,
+    });
+    if (!status.installed || status.installedSkillNames.length === 0) {
+        return {
+            action: 'noop',
+            status,
+        };
+    }
+    for (const skillName of status.installedSkillNames) {
+        await (options.runFn ?? run)('npx', ['-y', 'skills', 'remove', skillName, '-g', '-y'], {
+            cwd: globalRoot,
+            stdio: options.verbose ? 'inherit' : 'ignore',
+            errorName: 'skills remove',
+        });
+    }
+    await fsp.rm(getManagedSkillsStateFile(globalRoot), { force: true });
+    return {
+        action: 'removed',
+        status: await inspectSkillsStatus({
+            globalRoot,
+            commandOutputFn: options.commandOutputFn,
+        }),
+    };
+}