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

package/dist/commands/license/activate.js

@@ -0,0 +1,357 @@
+/**
+ * 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 * as p from '@clack/prompts';
+import { Command, Flags } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { ensureInstanceId, licenseEnvFlag, licenseJsonFlag, licensePkgUrlFlag, redactLicenseKey, requireLicenseRuntime, resolveLicenseKeyFile, resolveLicenseServiceUrl, saveLicenseKey, sanitizeLicenseOutput, validateLicenseKey, } from './shared.js';
+import { isInteractiveTerminal } from '../../lib/ui.js';
+import { appUrl } from '../env/shared.js';
+function resolveOnlineInputValue(value) {
+    return String(value ?? '').trim();
+}
+async function promptActivationMode() {
+    const answer = await p.select({
+        message: 'How do you want to activate the license?',
+        options: [
+            { value: 'key', label: 'Use an existing license key' },
+            { value: 'online', label: 'Request and activate a license online' },
+            { value: 'cancel', label: 'Cancel' },
+        ],
+        initialValue: 'key',
+    });
+    if (p.isCancel(answer)) {
+        p.cancel('License activation cancelled.');
+        return 'cancel';
+    }
+    return answer;
+}
+async function promptLicenseKeyInput() {
+    const answer = await p.select({
+        message: 'How do you want to provide the license key?',
+        options: [
+            { value: 'key', label: 'Paste the license key' },
+            { value: 'file', label: 'Read the key from a file' },
+        ],
+        initialValue: 'key',
+    });
+    if (p.isCancel(answer)) {
+        p.cancel('License activation cancelled.');
+        return {};
+    }
+    if (answer === 'key') {
+        const key = await p.text({
+            message: 'License key',
+            validate: (value) => String(value ?? '').trim() ? undefined : 'License key is required.',
+        });
+        if (p.isCancel(key)) {
+            p.cancel('License activation cancelled.');
+            return {};
+        }
+        return { key: String(key ?? '').trim() || undefined };
+    }
+    const keyFile = await p.text({
+        message: 'Path to the license key file',
+        validate: (value) => String(value ?? '').trim() ? undefined : 'License key file path is required.',
+    });
+    if (p.isCancel(keyFile)) {
+        p.cancel('License activation cancelled.');
+        return {};
+    }
+    return { keyFile: String(keyFile ?? '').trim() || undefined };
+}
+async function promptOnlineActivationInput(initial) {
+    let account = String(initial.account ?? '').trim();
+    if (!account) {
+        const answer = await p.text({
+            message: 'Service account',
+            validate: (value) => String(value ?? '').trim() ? undefined : 'Service account is required.',
+        });
+        if (p.isCancel(answer)) {
+            p.cancel('License activation cancelled.');
+            return;
+        }
+        account = String(answer ?? '').trim();
+    }
+    if (!account) {
+        p.cancel('License activation cancelled.');
+        return;
+    }
+    let password = String(initial.password ?? '').trim();
+    if (!password) {
+        const answer = await p.password({
+            message: 'Service password',
+            validate: (value) => String(value ?? '').trim() ? undefined : 'Service password is required.',
+        });
+        if (p.isCancel(answer)) {
+            p.cancel('License activation cancelled.');
+            return;
+        }
+        password = String(answer ?? '').trim();
+    }
+    if (!password) {
+        p.cancel('License activation cancelled.');
+        return;
+    }
+    let appName = String(initial.appName ?? '').trim();
+    if (!appName) {
+        const answer = await p.text({
+            message: 'Application name',
+            validate: (value) => String(value ?? '').trim() ? undefined : 'Application name is required.',
+        });
+        if (p.isCancel(answer)) {
+            p.cancel('License activation cancelled.');
+            return;
+        }
+        appName = String(answer ?? '').trim();
+    }
+    if (!appName) {
+        p.cancel('License activation cancelled.');
+        return;
+    }
+    const confirmedAnswer = typeof initial.confirmed === 'boolean'
+        ? initial.confirmed
+        : await p.confirm({
+            message: 'Confirm that the submitted license information is true and accurate?',
+            initialValue: false,
+        });
+    if (p.isCancel(confirmedAnswer)) {
+        p.cancel('License activation cancelled.');
+        return;
+    }
+    return {
+        account,
+        password,
+        appName,
+        confirmed: Boolean(confirmedAnswer),
+        serviceUrl: await resolveLicenseServiceUrl(initial.serviceUrl),
+    };
+}
+function resolveAppUrlOrThrow(runtime) {
+    const currentAppUrl = appUrl(runtime);
+    if (!currentAppUrl) {
+        throw new Error(`Env "${runtime.envName}" does not have an app URL or app port configured.`);
+    }
+    try {
+        return new URL(currentAppUrl).toString();
+    }
+    catch {
+        throw new Error(`Env "${runtime.envName}" has an invalid app URL: ${currentAppUrl}`);
+    }
+}
+async function requestOnlineLicenseKey(serviceUrl, account, password, payload) {
+    const response = await fetch(`${serviceUrl}/license-key`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            account,
+            password,
+            appUrl: payload.appUrl,
+            appName: payload.appName,
+            instanceId: payload.instanceId,
+            type: payload.type,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`License service request failed with status ${response.status}.`);
+    }
+    const data = await response.json();
+    const key = String(data?.data?.key ?? '').trim();
+    if (!key) {
+        throw new Error('License service did not return a license key.');
+    }
+    return key;
+}
+export default class LicenseActivate extends Command {
+    static summary = 'Activate commercial licensing for the selected env';
+    static description = 'Activate a commercial license for the selected env. Provide an existing license key directly, or use `--online` to request and activate one from the online license service.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1 --key <licenseKey>',
+        '<%= config.bin %> <%= command.id %> --env app1 --key-file ./license.txt',
+        '<%= config.bin %> <%= command.id %> --env app1 --online',
+        '<%= config.bin %> <%= command.id %> --env app1 --online --account aa --password bb --desc test24 --yes',
+        '<%= config.bin %> <%= command.id %> --env app1 --json --key-file ./license.txt',
+    ];
+    static flags = {
+        env: licenseEnvFlag,
+        json: licenseJsonFlag,
+        key: Flags.string({
+            description: 'Existing license key to activate',
+        }),
+        'key-file': Flags.string({
+            description: 'Path to a file containing the license key to activate',
+        }),
+        online: Flags.boolean({
+            description: 'Request a license online and activate it',
+            default: false,
+        }),
+        account: Flags.string({
+            description: 'License service account for online activation',
+        }),
+        password: Flags.string({
+            description: 'License service password for online activation',
+        }),
+        desc: Flags.string({
+            description: 'Application name for online activation',
+        }),
+        'pkg-url': licensePkgUrlFlag,
+        yes: Flags.boolean({
+            description: 'Confirm that the submitted application information is true and accurate',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LicenseActivate);
+        const runtime = await requireLicenseRuntime(flags.env);
+        let key = String(flags.key ?? '').trim();
+        let keyFile = String(flags['key-file'] ?? '').trim();
+        let online = Boolean(flags.online);
+        if (!key && !keyFile && !online) {
+            if (!isInteractiveTerminal()) {
+                this.error('Provide --key, --key-file, or --online to continue.');
+            }
+            const mode = await promptActivationMode();
+            if (mode === 'cancel') {
+                this.log('Cancelled license activation.');
+                return;
+            }
+            if (mode === 'online') {
+                online = true;
+            }
+            else {
+                const prompted = await promptLicenseKeyInput();
+                key = String(prompted.key ?? '').trim();
+                keyFile = String(prompted.keyFile ?? '').trim();
+                if (!key && !keyFile) {
+                    this.error('License key input was empty.');
+                }
+            }
+        }
+        if ((key || keyFile) && online) {
+            this.error('Use either an existing key (--key / --key-file) or --online, not both.');
+        }
+        if (online) {
+            const resolvedServiceUrl = await resolveLicenseServiceUrl(flags['pkg-url']);
+            const initialOnline = {
+                account: resolveOnlineInputValue(flags.account),
+                password: resolveOnlineInputValue(flags.password),
+                appName: resolveOnlineInputValue(flags.desc),
+                confirmed: flags.yes ? true : undefined,
+                serviceUrl: resolvedServiceUrl,
+            };
+            let onlineInput = initialOnline;
+            if (!onlineInput.account
+                || !onlineInput.password
+                || !onlineInput.appName
+                || !onlineInput.confirmed) {
+                if (!isInteractiveTerminal()) {
+                    this.error('Online activation requires --account, --password, --desc, and --yes when not using a TTY.');
+                }
+                const prompted = await promptOnlineActivationInput(initialOnline);
+                if (!prompted) {
+                    this.log('Cancelled license activation.');
+                    return;
+                }
+                onlineInput = prompted;
+            }
+            if (!onlineInput.confirmed) {
+                this.error('Online activation requires confirmation that the submitted application information is true and accurate.');
+            }
+            const instanceId = await ensureInstanceId(runtime);
+            const resolvedAppUrl = resolveAppUrlOrThrow(runtime);
+            const resolvedKey = await requestOnlineLicenseKey(onlineInput.serviceUrl, onlineInput.account, onlineInput.password, {
+                appUrl: resolvedAppUrl,
+                appName: onlineInput.appName,
+                instanceId,
+                type: 'internal',
+            });
+            const validation = await validateLicenseKey(runtime, resolvedKey);
+            const ok = !validation.keyStatus
+                && validation.envMatch
+                && validation.domainMatch
+                && validation.licenseStatus === 'active';
+            const licenseKeyPath = ok ? await saveLicenseKey(runtime, resolvedKey) : resolveLicenseKeyFile(runtime);
+            const payload = {
+                ok,
+                env: runtime.envName,
+                kind: runtime.kind,
+                instanceId,
+                mode: 'online',
+                serviceUrl: onlineInput.serviceUrl,
+                appUrl: resolvedAppUrl,
+                appName: onlineInput.appName,
+                key: redactLicenseKey(resolvedKey),
+                licenseKeyPath,
+                validation: sanitizeLicenseOutput(validation),
+            };
+            if (flags.json) {
+                this.log(JSON.stringify(payload, null, 2));
+                if (!ok) {
+                    this.exit(1);
+                }
+                return;
+            }
+            if (!ok) {
+                const reason = validation.keyStatus
+                    ? `license key is ${validation.keyStatus}`
+                    : !validation.envMatch
+                        ? 'license key does not match the current instance environment'
+                        : !validation.domainMatch
+                            ? 'license key does not match the current app domain'
+                            : validation.licenseStatus !== 'active'
+                                ? `license status is ${validation.licenseStatus}`
+                                : 'license validation failed';
+                this.error(`Failed to activate the online license for env "${runtime.envName}": ${reason}.`);
+            }
+            this.log(`Activated the online license for env "${runtime.envName}".`);
+            this.log(`Saved license key at ${licenseKeyPath}`);
+            return;
+        }
+        const resolvedKey = key || String(await readFile(keyFile, 'utf8')).trim();
+        const validation = await validateLicenseKey(runtime, resolvedKey);
+        const ok = !validation.keyStatus
+            && validation.envMatch
+            && validation.domainMatch
+            && validation.licenseStatus === 'active';
+        const licenseKeyPath = ok ? await saveLicenseKey(runtime, resolvedKey) : resolveLicenseKeyFile(runtime);
+        const payload = {
+            ok,
+            env: runtime.envName,
+            kind: runtime.kind,
+            instanceId: await ensureInstanceId(runtime),
+            mode: 'key',
+            key: redactLicenseKey(resolvedKey),
+            keyFile: keyFile || undefined,
+            licenseKeyPath,
+            validation: sanitizeLicenseOutput(validation),
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(payload, null, 2));
+            if (!ok) {
+                this.exit(1);
+            }
+            return;
+        }
+        if (!ok) {
+            const reason = validation.keyStatus
+                ? `license key is ${validation.keyStatus}`
+                : !validation.envMatch
+                    ? 'license key does not match the current instance environment'
+                    : !validation.domainMatch
+                        ? 'license key does not match the current app domain'
+                        : validation.licenseStatus !== 'active'
+                            ? `license status is ${validation.licenseStatus}`
+                            : 'license validation failed';
+            this.error(`Failed to activate the license for env "${runtime.envName}": ${reason}.`);
+        }
+        this.log(`Activated the license for env "${runtime.envName}".`);
+        this.log(`Saved license key at ${licenseKeyPath}`);
+    }
+}

package/dist/commands/license/env.js

@@ -0,0 +1,94 @@
+/**
+ * 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 { getEnvAsync } from '@nocobase/license-kit';
+import { validateTcpPort } from "../../lib/prompt-validators.js";
+import { licenseJsonFlag, withLicenseEnvVars } from './shared.js';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function formatMissingFieldsMessage(missing) {
+    return [
+        'Missing database settings for license environment inspection.',
+        `Required: ${missing.join(', ')}.`,
+        'Pass all required `--db-*` flags explicitly.',
+    ].join('\n');
+}
+export default class LicenseEnv extends Command {
+    static hidden = true;
+    static flags = {
+        'db-dialect': Flags.string({
+            description: 'Database dialect: postgres, kingbase, mysql, or mariadb.',
+            options: ['postgres', 'kingbase', 'mysql', 'mariadb'],
+        }),
+        'db-host': Flags.string({
+            description: 'Database host name or IP address.',
+        }),
+        'db-port': Flags.string({
+            description: 'Database TCP port.',
+        }),
+        'db-database': Flags.string({
+            description: 'Database name.',
+        }),
+        'db-user': Flags.string({
+            description: 'Database username.',
+        }),
+        'db-password': Flags.string({
+            description: 'Database password.',
+        }),
+        json: licenseJsonFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(LicenseEnv);
+        const envVars = {
+            DB_DIALECT: trimValue(flags['db-dialect']),
+            DB_HOST: trimValue(flags['db-host']),
+            DB_PORT: trimValue(flags['db-port']),
+            DB_DATABASE: trimValue(flags['db-database']),
+            DB_USER: trimValue(flags['db-user']),
+            DB_PASSWORD: flags['db-password'] !== undefined ? String(flags['db-password']) : undefined,
+        };
+        const missing = [];
+        if (!envVars.DB_DIALECT) {
+            missing.push('--db-dialect');
+        }
+        if (!envVars.DB_HOST) {
+            missing.push('--db-host');
+        }
+        if (!envVars.DB_PORT) {
+            missing.push('--db-port');
+        }
+        if (!envVars.DB_DATABASE) {
+            missing.push('--db-database');
+        }
+        if (!envVars.DB_USER) {
+            missing.push('--db-user');
+        }
+        if (!envVars.DB_PASSWORD) {
+            missing.push('--db-password');
+        }
+        if (missing.length > 0) {
+            this.error(formatMissingFieldsMessage(missing));
+        }
+        const portError = validateTcpPort(envVars.DB_PORT);
+        if (portError) {
+            this.error(portError);
+        }
+        const env = await withLicenseEnvVars(envVars, async () => await getEnvAsync());
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                env,
+            }, null, 2));
+            return;
+        }
+        this.log(JSON.stringify(env, null, 2));
+    }
+}

package/dist/commands/license/generate-id.js

@@ -0,0 +1,107 @@
+/**
+ * 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 { validateTcpPort } from "../../lib/prompt-validators.js";
+import { generateValidatedInstanceIdFromEnvVars, licenseJsonFlag } from './shared.js';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function formatMissingFieldsMessage(missing) {
+    return [
+        'Missing database settings for instance ID generation.',
+        `Required: ${missing.join(', ')}.`,
+        'Pass all required `--db-*` flags explicitly.',
+    ].join('\n');
+}
+export default class LicenseGenerateId extends Command {
+    static summary = 'Generate a commercial license instance ID from explicit database settings';
+    static description = 'Generate the commercial licensing instance ID from explicit `--db-*` flags. This command only prints the generated ID and does not save it.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --db-dialect postgres --db-host 127.0.0.1 --db-port 5432 --db-database nocobase --db-user nocobase --db-password secret',
+        '<%= config.bin %> <%= command.id %> --db-dialect postgres --db-host 127.0.0.1 --db-port 5432 --db-database nocobase --db-user nocobase --db-password secret --json',
+    ];
+    static flags = {
+        'db-dialect': Flags.string({
+            description: 'Database dialect: postgres, kingbase, mysql, or mariadb.',
+            options: ['postgres', 'kingbase', 'mysql', 'mariadb'],
+            required: false,
+        }),
+        'db-host': Flags.string({
+            description: 'Database host name or IP address.',
+        }),
+        'db-port': Flags.string({
+            description: 'Database TCP port.',
+        }),
+        'db-database': Flags.string({
+            description: 'Database name.',
+        }),
+        'db-user': Flags.string({
+            description: 'Database username.',
+        }),
+        'db-password': Flags.string({
+            description: 'Database password.',
+        }),
+        json: licenseJsonFlag,
+    };
+    async run() {
+        const { flags } = await this.parse(LicenseGenerateId);
+        const dbConfig = {
+            dbDialect: trimValue(flags['db-dialect']),
+            dbHost: trimValue(flags['db-host']),
+            dbPort: trimValue(flags['db-port']),
+            dbDatabase: trimValue(flags['db-database']),
+            dbUser: trimValue(flags['db-user']),
+            dbPassword: flags['db-password'] !== undefined ? String(flags['db-password']) : undefined,
+        };
+        const missing = [];
+        if (!dbConfig.dbDialect) {
+            missing.push('--db-dialect');
+        }
+        if (!dbConfig.dbHost) {
+            missing.push('--db-host');
+        }
+        if (!dbConfig.dbPort) {
+            missing.push('--db-port');
+        }
+        if (!dbConfig.dbDatabase) {
+            missing.push('--db-database');
+        }
+        if (!dbConfig.dbUser) {
+            missing.push('--db-user');
+        }
+        if (!dbConfig.dbPassword) {
+            missing.push('--db-password');
+        }
+        if (missing.length > 0) {
+            this.error(formatMissingFieldsMessage(missing));
+        }
+        const portError = validateTcpPort(dbConfig.dbPort);
+        if (portError) {
+            this.error(portError);
+        }
+        const envVars = {
+            DB_DIALECT: dbConfig.dbDialect,
+            DB_HOST: dbConfig.dbHost,
+            DB_PORT: dbConfig.dbPort,
+            DB_DATABASE: dbConfig.dbDatabase,
+            DB_USER: dbConfig.dbUser,
+            DB_PASSWORD: dbConfig.dbPassword,
+        };
+        const instanceId = await generateValidatedInstanceIdFromEnvVars(envVars);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                instanceId,
+            }, null, 2));
+            return;
+        }
+        this.log(instanceId);
+    }
+}

package/dist/commands/license/id.js

@@ -0,0 +1,52 @@
+/**
+ * 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 { generateAndSaveInstanceId, licenseEnvFlag, licenseJsonFlag, readSavedInstanceId, requireLicenseRuntime, resolveInstanceIdFile, } from './shared.js';
+export default class LicenseId extends Command {
+    static summary = 'Show the instance ID for the selected env';
+    static description = 'Show the commercial licensing instance ID for the selected env, generating and saving it if needed.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --force',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+    ];
+    static flags = {
+        env: licenseEnvFlag,
+        json: licenseJsonFlag,
+        force: Flags.boolean({
+            description: 'Force regenerate the instance ID even if one is already saved',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LicenseId);
+        const runtime = await requireLicenseRuntime(flags.env);
+        const savedBefore = await readSavedInstanceId(runtime);
+        const shouldGenerate = Boolean(flags.force) || !savedBefore;
+        const instanceId = shouldGenerate
+            ? await generateAndSaveInstanceId(runtime)
+            : savedBefore;
+        const filePath = resolveInstanceIdFile(runtime);
+        const generated = shouldGenerate;
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: true,
+                env: runtime.envName,
+                kind: runtime.kind,
+                instanceId,
+                filePath,
+                generated,
+            }, null, 2));
+            return;
+        }
+        this.log(`Instance ID for env "${runtime.envName}": ${instanceId}`);
+        this.log(`${generated ? 'Saved' : 'Loaded'} instance ID at ${filePath}`);
+    }
+}

package/dist/commands/license/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 License extends Command {
+    static summary = 'Manage NocoBase commercial licensing';
+    async run() {
+        await this.parse(License);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'license',
+            ...this.argv,
+        ]);
+    }
+}