@nocobase/cli 2.1.0-alpha.26 → 2.1.0-alpha.27

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

@@ -0,0 +1,98 @@
+/**
+ * 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 { licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, requireLicenseRuntime } from '../shared.js';
+import { cleanLicensedPlugins } from './shared.js';
+import { resolvePluginStoragePath } from '../../../lib/plugin-storage.js';
+function formatActionLabel(action) {
+    switch (action) {
+        case 'removed':
+            return pc.yellow('removed');
+        case 'skipped':
+            return pc.dim('skipped');
+    }
+}
+export default class LicensePluginsClean extends Command {
+    static summary = 'Remove downloaded commercial plugins for the selected env';
+    static description = 'Remove local commercial plugin downloads for the selected env without changing license activation.';
+    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 --verbose',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+    ];
+    static flags = {
+        env: licenseEnvFlag,
+        json: licenseJsonFlag,
+        'pkg-url': licensePkgUrlFlag,
+        'dry-run': Flags.boolean({
+            description: 'Preview which commercial plugins would be removed without deleting anything',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            char: 'V',
+            description: 'Show detailed per-plugin clean logs',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LicensePluginsClean);
+        const runtime = await requireLicenseRuntime(flags.env);
+        const shouldStreamLogs = !flags.json && Boolean(flags.verbose);
+        const pluginStoragePath = resolvePluginStoragePath(runtime.env.storagePath);
+        if (!flags.json) {
+            this.log(pc.bold(flags['dry-run']
+                ? `Commercial plugin clean preview for env "${runtime.envName}"`
+                : `Commercial plugin clean for env "${runtime.envName}"`));
+            this.log(pc.dim(`Plugin storage path: ${pluginStoragePath}`));
+        }
+        const result = await cleanLicensedPlugins(runtime, {
+            pkgUrl: flags['pkg-url'],
+            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.action === 'removed') {
+                        this.log(pc.dim(`  symlink: ${detail.removedSymlink ? 'removed' : 'not found'}`));
+                    }
+                }
+                : undefined,
+        });
+        const payload = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            dryRun: Boolean(flags['dry-run']),
+            ...result,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        if (!flags.verbose) {
+            const changes = [];
+            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.removed.length} removed, ${result.skipped.length} skipped`);
+        }
+    }
+}

package/dist/commands/license/plugins/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 LicensePlugins extends Command {
+    static summary = 'List or synchronize commercial plugins allowed by the current license';
+    async run() {
+        await this.parse(LicensePlugins);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'license plugins',
+            ...this.argv,
+        ]);
+    }
+}

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

@@ -0,0 +1,50 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Command } from '@oclif/core';
+import { licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, requireLicenseRuntime } from '../shared.js';
+import { fetchLicensedPluginPackages } from './shared.js';
+import { renderTable } from '../../../lib/ui.js';
+export default class LicensePluginsList extends Command {
+    static summary = 'List commercial plugins available to the selected env';
+    static description = 'Show the commercial plugins associated with the current saved license key for the selected env.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+    ];
+    static flags = {
+        env: licenseEnvFlag,
+        json: licenseJsonFlag,
+        'pkg-url': licensePkgUrlFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(LicensePluginsList);
+        const runtime = await requireLicenseRuntime(flags.env);
+        const { commercialPlugins, licensedPlugins } = await fetchLicensedPluginPackages(runtime, {
+            pkgUrl: flags['pkg-url'],
+        });
+        const payload = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            commercialPlugins,
+            licensedPlugins,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        const rows = commercialPlugins.map((pluginName) => [
+            pluginName,
+            licensedPlugins.includes(pluginName) ? 'licensed' : 'unlicensed',
+        ]);
+        this.log(`Commercial plugins for env "${runtime.envName}"`);
+        this.log(renderTable(['Package', 'Status'], rows));
+    }
+}

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;
+}