@nocobase/cli 2.1.0-beta.23 → 2.1.0-beta.25

package/dist/commands/license/plugins/shared.js

@@ -0,0 +1,325 @@
+/**
+ * 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 path from 'node:path';
+import { access, mkdir, rm } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+import { createGunzip } from 'node:zlib';
+import * as tar from 'tar';
+import { removeStoragePluginSymlink, resolvePluginStoragePath, } from '../../../lib/plugin-storage.js';
+import { parseLicenseKey, readSavedLicenseKey, resolveLicensePkgUrl, } from '../shared.js';
+async function resolvePkgBaseUrl(pkgUrl) {
+    return await resolveLicensePkgUrl(pkgUrl);
+}
+function responseBodyToNodeReadable(body) {
+    return Readable.fromWeb(body);
+}
+async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loginPkg(baseURL, keyData) {
+    const username = String(keyData.accessKeyId ?? '').trim();
+    const password = String(keyData.accessKeySecret ?? '').trim();
+    if (!username || !password) {
+        throw new Error('The saved license key does not include package registry credentials.');
+    }
+    const response = await fetch(`${baseURL}-/verdaccio/sec/login`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({ username, password }),
+    });
+    if (!response.ok) {
+        throw new Error(`Package registry login failed with status ${response.status}.`);
+    }
+    const data = await response.json();
+    const token = String(data?.token ?? '').trim();
+    if (!token) {
+        throw new Error('Package registry login did not return a token.');
+    }
+    return token;
+}
+export async function loadSavedLicenseKeyData(runtime) {
+    const licenseKey = await readSavedLicenseKey(runtime);
+    if (!licenseKey) {
+        throw new Error(`No saved license key was found for env "${runtime.envName}". Run \`nb license activate\` first.`);
+    }
+    return parseLicenseKey(licenseKey);
+}
+export async function fetchLicensedPluginPackages(runtime, options = {}) {
+    const keyData = await loadSavedLicenseKeyData(runtime);
+    const baseURL = await resolvePkgBaseUrl(options.pkgUrl);
+    const token = await loginPkg(baseURL, keyData);
+    const response = await fetch(`${baseURL}pro-packages`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch commercial plugins with status ${response.status}.`);
+    }
+    const rawData = await response.json();
+    if (Array.isArray(rawData)) {
+        return {
+            commercialPlugins: rawData,
+            licensedPlugins: rawData,
+        };
+    }
+    return {
+        commercialPlugins: rawData?.meta?.commercial_plugins || [],
+        licensedPlugins: rawData?.data || [],
+    };
+}
+async function packageMetadata(baseURL, token, pluginName) {
+    try {
+        const response = await fetch(`${baseURL}${pluginName}`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            return undefined;
+        }
+        return await response.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveTarball(metadata, requestedVersion) {
+    if (metadata.versions?.[requestedVersion]) {
+        return [requestedVersion, metadata.versions[requestedVersion].dist.tarball];
+    }
+    let version = requestedVersion;
+    if (version.includes('rc')) {
+        version = version.split('-').shift() || version;
+    }
+    const keys = version.split('.');
+    if (keys.length === 5) {
+        keys.pop();
+        version = keys.join('.');
+    }
+    if (version === 'latest') {
+        version = metadata['dist-tags']?.latest;
+    }
+    else if (version === 'next') {
+        version = metadata['dist-tags']?.next;
+    }
+    else if (requestedVersion.includes('beta')) {
+        version = metadata['dist-tags']?.next;
+    }
+    else if (requestedVersion.includes('alpha')) {
+        version = metadata['dist-tags']?.alpha || metadata['dist-tags']?.next;
+    }
+    if (!metadata.versions?.[version]) {
+        return undefined;
+    }
+    return [version, metadata.versions[version].dist.tarball];
+}
+async function downloadPlugin(baseURL, token, pluginName, requestedVersion, storagePath) {
+    const metadata = await packageMetadata(baseURL, token, pluginName);
+    if (!metadata) {
+        return {
+            action: 'skipped',
+            warning: `Commercial plugin package "${pluginName}" does not exist in the package registry.`,
+        };
+    }
+    const tarball = resolveTarball(metadata, requestedVersion);
+    if (!tarball) {
+        return {
+            action: 'skipped',
+            warning: `Package ${pluginName} does not have a downloadable version for "${requestedVersion}".`,
+        };
+    }
+    const [resolvedVersion, tarballUrl] = tarball;
+    const outputDir = path.resolve(storagePath, pluginName);
+    const existedBefore = await pathExists(path.resolve(storagePath, pluginName, 'package.json'));
+    try {
+        await rm(outputDir, { recursive: true, force: true });
+        await mkdir(outputDir, { recursive: true });
+        const response = await fetch(tarballUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`download failed with status ${response.status}`);
+        }
+        if (!response.body) {
+            throw new Error('download response body is empty');
+        }
+        await new Promise((resolve, reject) => {
+            responseBodyToNodeReadable(response.body)
+                .pipe(createGunzip())
+                .pipe(tar.extract({ cwd: outputDir, strip: 1 }))
+                .on('finish', () => resolve())
+                .on('error', reject);
+        });
+        return {
+            action: existedBefore ? 'updated' : 'installed',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            action: 'skipped',
+            warning: `Failed to download ${pluginName}@${resolvedVersion} from ${tarballUrl}: ${message}`,
+        };
+    }
+}
+async function removeUnlicensedPlugin(pluginName, storagePath) {
+    const dir = path.resolve(storagePath, pluginName);
+    if (!(await pathExists(dir))) {
+        return false;
+    }
+    await rm(dir, { recursive: true, force: true });
+    return true;
+}
+async function removeDownloadedPlugin(pluginName, storagePath) {
+    const dir = path.resolve(storagePath, pluginName);
+    if (!(await pathExists(dir))) {
+        return false;
+    }
+    await rm(dir, { recursive: true, force: true });
+    return true;
+}
+export async function syncLicensedPlugins(runtime, options) {
+    const keyData = await loadSavedLicenseKeyData(runtime);
+    const baseURL = await resolvePkgBaseUrl(options.pkgUrl);
+    const token = await loginPkg(baseURL, keyData);
+    const { commercialPlugins, licensedPlugins } = await fetchLicensedPluginPackages(runtime, { pkgUrl: options.pkgUrl });
+    const storagePath = resolvePluginStoragePath(runtime.env.storagePath);
+    const nodeModulesPath = String(runtime.env.envVars.NODE_MODULES_PATH ?? '').trim();
+    const result = {
+        commercialPlugins,
+        licensedPlugins,
+        installed: [],
+        updated: [],
+        removed: [],
+        skipped: [],
+        warnings: [],
+        storagePath,
+        details: [],
+    };
+    const emitDetail = async (detail) => {
+        result.details.push(detail);
+        await options.onProgress?.(detail);
+    };
+    for (const pluginName of commercialPlugins) {
+        if (!licensedPlugins.includes(pluginName)) {
+            if (options.dryRun) {
+                result.removed.push(pluginName);
+                await emitDetail({
+                    packageName: pluginName,
+                    action: 'removed',
+                    outputDir: path.resolve(storagePath, pluginName),
+                });
+                continue;
+            }
+            if (await removeUnlicensedPlugin(pluginName, storagePath)) {
+                result.removed.push(pluginName);
+                await emitDetail({
+                    packageName: pluginName,
+                    action: 'removed',
+                    outputDir: path.resolve(storagePath, pluginName),
+                });
+            }
+        }
+    }
+    for (const pluginName of licensedPlugins) {
+        if (options.dryRun) {
+            const outputDir = path.resolve(storagePath, pluginName);
+            const existedBefore = await pathExists(path.resolve(outputDir, 'package.json'));
+            const action = existedBefore ? 'updated' : 'installed';
+            result[action].push(pluginName);
+            await emitDetail({
+                packageName: pluginName,
+                action,
+                outputDir,
+            });
+            continue;
+        }
+        const { action, warning } = await downloadPlugin(baseURL, token, pluginName, options.version, storagePath);
+        if (warning) {
+            result.warnings.push(warning);
+        }
+        if (action === 'installed') {
+            result.installed.push(pluginName);
+        }
+        else if (action === 'updated') {
+            result.updated.push(pluginName);
+        }
+        else {
+            result.skipped.push(pluginName);
+        }
+        await emitDetail({
+            packageName: pluginName,
+            action,
+            outputDir: path.resolve(storagePath, pluginName),
+            ...(warning ? { warning } : {}),
+        });
+    }
+    return result;
+}
+export async function cleanLicensedPlugins(runtime, options = {}) {
+    const { commercialPlugins } = await fetchLicensedPluginPackages(runtime, { pkgUrl: options.pkgUrl });
+    const storagePath = resolvePluginStoragePath(runtime.env.storagePath);
+    const nodeModulesPath = String(runtime.env.envVars.NODE_MODULES_PATH ?? '').trim();
+    const result = {
+        commercialPlugins,
+        removed: [],
+        skipped: [],
+        storagePath,
+        details: [],
+    };
+    const emitDetail = async (detail) => {
+        result.details.push(detail);
+        await options.onProgress?.(detail);
+    };
+    for (const pluginName of commercialPlugins) {
+        const outputDir = path.resolve(storagePath, pluginName);
+        const exists = await pathExists(outputDir);
+        if (!exists) {
+            result.skipped.push(pluginName);
+            await emitDetail({
+                packageName: pluginName,
+                action: 'skipped',
+                outputDir,
+                removedSymlink: false,
+            });
+            continue;
+        }
+        if (options.dryRun) {
+            result.removed.push(pluginName);
+            await emitDetail({
+                packageName: pluginName,
+                action: 'removed',
+                outputDir,
+                removedSymlink: Boolean(nodeModulesPath),
+            });
+            continue;
+        }
+        await removeDownloadedPlugin(pluginName, storagePath);
+        const removedSymlink = await removeStoragePluginSymlink(pluginName, runtime.env.storagePath, nodeModulesPath);
+        result.removed.push(pluginName);
+        await emitDetail({
+            packageName: pluginName,
+            action: 'removed',
+            outputDir,
+            removedSymlink,
+        });
+    }
+    return result;
+}

package/dist/commands/license/plugins/sync.js

@@ -0,0 +1,269 @@
+/**
+ * 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 pc from 'picocolors';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, requireLicenseRuntime } from '../shared.js';
+import { syncLicensedPlugins } from './shared.js';
+import { resolvePluginStoragePath } from '../../../lib/plugin-storage.js';
+import { commandOutput } from '../../../lib/run-npm.js';
+import { announceTargetEnv, startTask, stopTask, succeedTask, updateTask } from '../../../lib/ui.js';
+const SYNC_LOADING_DELAY_MS = 1200;
+const SYNC_LOADING_UPDATE_MS = 5000;
+const LOCAL_APP_PACKAGE_JSON_PATH = 'node_modules/@nocobase/app/package.json';
+const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
+const DEFAULT_DOCKER_VERSION = 'alpha';
+function formatActionLabel(action) {
+    switch (action) {
+        case 'installed':
+            return pc.green('installed');
+        case 'updated':
+            return pc.cyan('updated');
+        case 'removed':
+            return pc.yellow('removed');
+        case 'skipped':
+            return pc.dim('skipped');
+    }
+}
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function normalizeDockerPlatform(value) {
+    const text = trimValue(value);
+    if (!text || text === 'auto') {
+        return undefined;
+    }
+    if (text === 'linux/amd64' || text === 'linux/arm64') {
+        return text;
+    }
+    return undefined;
+}
+function normalizePluginRegistryVersion(version) {
+    const normalized = version.trim();
+    const rcMatch = normalized.match(/^(.+)-rc\.\d{8,}$/);
+    if (rcMatch) {
+        return rcMatch[1];
+    }
+    const betaMatch = normalized.match(/^(.+-beta\.\d+)\.\d{8,}$/);
+    if (betaMatch) {
+        return betaMatch[1];
+    }
+    const alphaMatch = normalized.match(/^(.+-alpha\.\d+)\.\d{8,}$/);
+    if (alphaMatch) {
+        return alphaMatch[1];
+    }
+    return normalized;
+}
+async function parseVersionFromPackageJson(content, sourceLabel) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new Error(`Failed to parse ${sourceLabel}.`);
+    }
+    const version = trimValue(parsed.version);
+    if (!version) {
+        throw new Error(`Missing version in ${sourceLabel}.`);
+    }
+    return version;
+}
+async function resolveLocalAppVersion(runtime) {
+    const packageJsonPath = path.join(runtime.projectRoot, LOCAL_APP_PACKAGE_JSON_PATH);
+    let content;
+    try {
+        content = await readFile(packageJsonPath, 'utf8');
+    }
+    catch {
+        throw new Error(`Missing ${LOCAL_APP_PACKAGE_JSON_PATH} for env "${runtime.envName}" at ${packageJsonPath}.`);
+    }
+    return await parseVersionFromPackageJson(content, packageJsonPath);
+}
+async function resolveDockerAppVersion(runtime) {
+    const config = runtime.env.config ?? {};
+    const imageRef = `${trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY}:${trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION}`;
+    const args = [
+        'run',
+        '--rm',
+        '--network',
+        runtime.workspaceName,
+    ];
+    const dockerPlatform = normalizeDockerPlatform(config.dockerPlatform);
+    if (dockerPlatform) {
+        args.push('--platform', dockerPlatform);
+    }
+    args.push('--entrypoint', 'nb', imageRef, '--version');
+    let output;
+    try {
+        output = await commandOutput('docker', args, {
+            errorName: 'docker run',
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read app version for env "${runtime.envName}" from Docker image ${imageRef}. ${message}`);
+    }
+    const versionMatch = output.match(/@nocobase\/cli\/([^\s]+)/);
+    const version = trimValue(versionMatch?.[1] ?? output.replace(/^"+|"+$/g, ''));
+    if (!version) {
+        throw new Error(`Missing app version for env "${runtime.envName}" inside Docker image ${imageRef}.`);
+    }
+    return version;
+}
+async function resolveManagedAppVersion(runtime) {
+    if (runtime.kind === 'local') {
+        return await resolveLocalAppVersion(runtime);
+    }
+    if (runtime.kind === 'docker') {
+        return await resolveDockerAppVersion(runtime);
+    }
+    throw new Error(`Env "${runtime.envName}" does not support automatic app version detection.`);
+}
+export default class LicensePluginsSync extends Command {
+    static summary = 'Synchronize commercial plugins for the selected env';
+    static description = 'Synchronize the commercial plugins allowed by the current saved license key.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --dry-run',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+    ];
+    static flags = {
+        env: licenseEnvFlag,
+        json: licenseJsonFlag,
+        'pkg-url': licensePkgUrlFlag,
+        'dry-run': Flags.boolean({
+            description: 'Preview plugin changes without installing, upgrading, or removing anything',
+            default: false,
+        }),
+        version: Flags.string({
+            description: 'Registry version or dist-tag to synchronize. Defaults to the current workspace version.',
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed per-plugin sync logs',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LicensePluginsSync);
+        const runtime = await requireLicenseRuntime(flags.env);
+        if (!flags.json) {
+            announceTargetEnv(runtime.envName);
+        }
+        const version = trimValue(flags.version) || await resolveManagedAppVersion(runtime);
+        const registryVersion = normalizePluginRegistryVersion(version);
+        const shouldStreamLogs = !flags.json && Boolean(flags.verbose);
+        const pluginStoragePath = resolvePluginStoragePath(runtime.env.storagePath);
+        const shouldShowLoading = !flags.json && !flags.verbose;
+        if (!flags.json) {
+            this.log(pc.bold(flags['dry-run']
+                ? `Commercial plugin sync preview for env "${runtime.envName}"`
+                : `Commercial plugin sync for env "${runtime.envName}"`));
+            this.log(pc.dim(`App version: ${version}`));
+            if (registryVersion !== version) {
+                this.log(pc.dim(`Download version: ${registryVersion}`));
+            }
+            this.log(pc.dim(`Plugin storage path: ${pluginStoragePath}`));
+        }
+        let loadingStarted = false;
+        let loadingTimer;
+        let updateTimer;
+        let elapsedSeconds = 0;
+        if (shouldShowLoading) {
+            loadingTimer = setTimeout(() => {
+                loadingStarted = true;
+                elapsedSeconds = Math.floor(SYNC_LOADING_DELAY_MS / 1000);
+                startTask(flags['dry-run']
+                    ? 'Preparing commercial plugin sync preview. Please wait...'
+                    : 'Synchronizing commercial plugins. Please wait...');
+                updateTimer = setInterval(() => {
+                    elapsedSeconds += Math.floor(SYNC_LOADING_UPDATE_MS / 1000);
+                    updateTask(flags['dry-run']
+                        ? `Preparing commercial plugin sync preview. Still working... (${elapsedSeconds}s elapsed)`
+                        : `Synchronizing commercial plugins. Still working... (${elapsedSeconds}s elapsed)`);
+                }, SYNC_LOADING_UPDATE_MS);
+            }, SYNC_LOADING_DELAY_MS);
+        }
+        let result;
+        try {
+            result = await syncLicensedPlugins(runtime, {
+                pkgUrl: flags['pkg-url'],
+                version: registryVersion,
+                dryRun: Boolean(flags['dry-run']),
+                onProgress: shouldStreamLogs
+                    ? async (detail) => {
+                        this.log(`${formatActionLabel(detail.action)} ${pc.bold(detail.packageName)}`);
+                        this.log(pc.dim(`  output: ${detail.outputDir}`));
+                        if (detail.warning) {
+                            this.log(pc.yellow(`  warning: ${detail.warning}`));
+                        }
+                    }
+                    : undefined,
+            });
+        }
+        finally {
+            if (loadingTimer) {
+                clearTimeout(loadingTimer);
+            }
+            if (updateTimer) {
+                clearInterval(updateTimer);
+            }
+            if (loadingStarted) {
+                stopTask();
+            }
+        }
+        const payload = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            dryRun: Boolean(flags['dry-run']),
+            version,
+            registryVersion,
+            ...result,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        if (loadingStarted) {
+            succeedTask(flags['dry-run']
+                ? 'Commercial plugin sync preview is ready.'
+                : 'Commercial plugin sync completed.');
+        }
+        if (!flags.verbose) {
+            const changes = [];
+            if (result.installed.length > 0) {
+                changes.push(pc.green(`${result.installed.length} installed`));
+            }
+            if (result.updated.length > 0) {
+                changes.push(pc.cyan(`${result.updated.length} updated`));
+            }
+            if (result.removed.length > 0) {
+                changes.push(pc.yellow(`${result.removed.length} removed`));
+            }
+            if (result.skipped.length > 0) {
+                changes.push(pc.dim(`${result.skipped.length} skipped`));
+            }
+            if (changes.length === 0) {
+                changes.push(pc.dim('no plugin changes'));
+            }
+            this.log(`Result: ${changes.join(', ')}`);
+        }
+        else {
+            this.log(`Summary: ${result.installed.length} installed, ${result.updated.length} updated, ${result.removed.length} removed, ${result.skipped.length} skipped, ${result.warnings.length} warnings`);
+        }
+        if (result.warnings.length > 0 && !flags.verbose) {
+            for (const warning of result.warnings) {
+                this.log(pc.yellow(`Warning: ${warning}`));
+            }
+        }
+    }
+}