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

package/dist/commands/install.js

@@ -17,11 +17,14 @@ import { exit } from 'node:process';
 import { runPromptCatalog, } from "../lib/prompt-catalog.js";
 import { applyCliLocale, localeText, resolveCliLocale, translateCli, } from "../lib/cli-locale.js";
 import { resolveConfiguredEnvPath, resolveDefaultConfigScope, resolveEnvRoot, resolveEnvRelativePath, } from '../lib/cli-home.js';
+import { defaultDockerContainerPrefix, defaultDockerNetworkName, } from '../lib/app-runtime.js';
+import { resolveDockerContainerPrefix, resolveDockerNetworkName, } from '../lib/cli-config.js';
 import { findAvailableTcpPort, validateAvailableTcpPort, validateTcpPort, validateEnvKey, } from "../lib/prompt-validators.js";
+import { validateExternalDbConfig } from "../lib/db-connection-check.js";
 import { formatMissingManagedAppEnvMessage } from '../lib/app-runtime.js';
 import { run, runNocoBaseCommand } from '../lib/run-npm.js';
 import { startTask, stopTask, updateTask } from '../lib/ui.js';
-import { ensureWorkspaceName, getEnv, loadAuthConfig, upsertEnv } from '../lib/auth-store.js';
+import { getEnv, upsertEnv } from '../lib/auth-store.js';
 import { buildStoredEnvConfig } from '../lib/env-config.js';
 import Download, { defaultDockerRegistryForLang, } from './download.js';
 import EnvAdd from "./env/add.js";
@@ -180,6 +183,16 @@ function validateBuiltinDbEnabled(value, values) {
     }
     return translateCli('commands.install.validation.builtinDbUnsupported', { dialect });
 }
+async function validateExternalDbPromptField(value, values) {
+    const builtinDb = values.builtinDb === undefined ? true : Boolean(values.builtinDb);
+    if (builtinDb) {
+        return undefined;
+    }
+    if (typeof value === 'string' && value.trim() === '') {
+        return undefined;
+    }
+    return await validateExternalDbConfig(values);
+}
 function defaultInstallAppRootPath(envName) {
     const name = String(envName ?? DEFAULT_INSTALL_ENV_NAME).trim() || DEFAULT_INSTALL_ENV_NAME;
     return `./${name}/source/`;
@@ -447,6 +460,7 @@ export default class Install extends Command {
             initialValue: (values) => defaultDbHostForBuiltinDb(values),
             yesInitialValue: DEFAULT_INSTALL_BUILTIN_DB_HOST,
             required: true,
+            validate: validateExternalDbPromptField,
             hidden: (values) => Boolean(values.builtinDb),
         },
         dbPort: {
@@ -464,6 +478,7 @@ export default class Install extends Command {
             message: installText('prompts.dbDatabase.message'),
             initialValue: (values) => defaultDbDatabaseForDialect(values.dbDialect),
             required: true,
+            validate: validateExternalDbPromptField,
         },
         dbUser: {
             type: 'text',
@@ -471,6 +486,7 @@ export default class Install extends Command {
             initialValue: DEFAULT_INSTALL_DB_USER,
             yesInitialValue: DEFAULT_INSTALL_DB_USER,
             required: true,
+            validate: validateExternalDbPromptField,
         },
         dbPassword: {
             type: 'password',
@@ -478,6 +494,7 @@ export default class Install extends Command {
             initialValue: DEFAULT_INSTALL_DB_PASSWORD,
             yesInitialValue: DEFAULT_INSTALL_DB_PASSWORD,
             required: true,
+            validate: validateExternalDbPromptField,
         },
     };
     static rootUserPrompts = {
@@ -741,6 +758,9 @@ export default class Install extends Command {
         const builtinDb = values.builtinDb === undefined ? true : Boolean(values.builtinDb);
         const source = String(values.source ?? '').trim();
         if (!builtinDb || source === 'docker') {
+            if (!builtinDb) {
+                return await validateExternalDbConfig({ ...values, dbPort: value });
+            }
             return undefined;
         }
         return await Install.validateResumeAwareTcpPort(value, values, 'db');
@@ -765,6 +785,23 @@ export default class Install extends Command {
         });
         return reusesManagedPort ? undefined : portError;
     }
+    static async ensureExternalDbReadyForInstall(dbResults) {
+        const builtinDb = dbResults.builtinDb === undefined ? true : Boolean(dbResults.builtinDb);
+        if (builtinDb) {
+            return;
+        }
+        const dialect = String(dbResults.dbDialect ?? 'postgres').trim() || 'postgres';
+        const host = String(dbResults.dbHost ?? '').trim();
+        const port = String(dbResults.dbPort ?? '').trim();
+        const database = String(dbResults.dbDatabase ?? '').trim();
+        const address = host && port ? `${host}:${port}` : host || port || '(unknown address)';
+        const target = database ? `${address}/${database}` : address;
+        p.log.step(`Checking external ${dialect} database: ${target}`);
+        const validationError = await validateExternalDbConfig(dbResults);
+        if (validationError) {
+            throw new Error(validationError);
+        }
+    }
     static async readResumePortValidationContext(values) {
         if (!Boolean(values.resume)) {
             return undefined;
@@ -777,24 +814,23 @@ export default class Install extends Command {
         const builtinDb = values.builtinDb === undefined ? undefined : Boolean(values.builtinDb);
         const dbDialect = Install.toOptionalPromptString(values.dbDialect);
         const appRootPath = Install.toOptionalPromptString(values.appRootPath);
-        const workspaceName = Install.toOptionalPromptString(values.workspaceName)
-            ?? await Install.resolveResumeWorkspaceName(envName);
+        const dockerNetworkName = await Install.resolveResumeDockerNetworkName();
+        const dockerContainerPrefix = await Install.resolveResumeDockerContainerPrefix();
         return {
             envName,
-            ...(workspaceName ? { workspaceName } : {}),
+            ...(dockerNetworkName ? { dockerNetworkName } : {}),
+            ...(dockerContainerPrefix ? { dockerContainerPrefix } : {}),
             ...(source ? { source } : {}),
             ...(builtinDb !== undefined ? { builtinDb } : {}),
             ...(dbDialect ? { dbDialect } : {}),
             ...(appRootPath ? { appRootPath } : {}),
         };
     }
-    static async resolveResumeWorkspaceName(envName) {
-        if (!envName) {
-            return undefined;
-        }
-        const config = await loadAuthConfig({ scope: resolveDefaultConfigScope() });
-        const stored = String(config.name ?? '').trim();
-        return stored || Install.defaultWorkspaceName();
+    static async resolveResumeDockerNetworkName() {
+        return await resolveDockerNetworkName({ scope: resolveDefaultConfigScope() });
+    }
+    static async resolveResumeDockerContainerPrefix() {
+        return await resolveDockerContainerPrefix({ scope: resolveDefaultConfigScope() });
     }
     static async isResumeManagedPortReuse(params) {
         if (params.target === 'app') {
@@ -802,13 +838,13 @@ export default class Install extends Command {
                 && params.context.appRootPath) {
                 return await Install.isLocalPm2ProcessUsingPort(params.context.appRootPath, params.port);
             }
-            const containerName = Install.buildDockerAppContainerName(params.context.envName, params.context.workspaceName);
+            const containerName = Install.buildDockerAppContainerName(params.context.envName, params.context.dockerContainerPrefix);
             return await Install.isDockerContainerPublishingPort(containerName, params.port);
         }
         if (!params.context.builtinDb || params.context.source === 'docker') {
             return false;
         }
-        const containerName = Install.buildBuiltinDbContainerName(params.context.envName, params.context.dbDialect ?? 'postgres', params.context.workspaceName);
+        const containerName = Install.buildBuiltinDbContainerName(params.context.envName, params.context.dbDialect ?? 'postgres', params.context.dockerContainerPrefix);
         return await Install.isDockerContainerPublishingPort(containerName, params.port);
     }
     static async isDockerContainerPublishingPort(containerName, port) {
@@ -1148,27 +1184,33 @@ export default class Install extends Command {
             .replace(/^-+|-+$/g, '');
         return normalized || 'nocobase';
     }
-    static defaultWorkspaceName() {
-        return Install.sanitizeDockerResourceName(`nb-${path.basename(resolveEnvRoot(resolveDefaultConfigScope()))}`);
+    static defaultDockerNetworkName() {
+        return Install.sanitizeDockerResourceName(defaultDockerNetworkName());
     }
-    static buildBuiltinDbResourcePrefix(envName, workspaceName) {
-        void envName;
-        const storedName = String(workspaceName ?? '').trim();
+    static defaultDockerContainerPrefix() {
+        return Install.sanitizeDockerResourceName(defaultDockerContainerPrefix(resolveEnvRoot(resolveDefaultConfigScope())));
+    }
+    static buildBuiltinDbContainerPrefix(containerPrefix) {
+        const storedName = String(containerPrefix ?? '').trim();
         return storedName
             ? Install.sanitizeDockerResourceName(storedName)
-            : Install.defaultWorkspaceName();
+            : Install.defaultDockerContainerPrefix();
     }
-    static async ensureWorkspaceName() {
-        return await ensureWorkspaceName(Install.defaultWorkspaceName(), { scope: resolveDefaultConfigScope() });
+    static buildManagedDockerNetworkName(networkName) {
+        const storedName = String(networkName ?? '').trim();
+        return storedName
+            ? Install.sanitizeDockerResourceName(storedName)
+            : Install.defaultDockerNetworkName();
     }
-    static buildBuiltinDbNetworkName(envName, workspaceName) {
-        return Install.buildBuiltinDbResourcePrefix(envName, workspaceName);
+    static buildBuiltinDbNetworkName(envName, networkName) {
+        void envName;
+        return Install.buildManagedDockerNetworkName(networkName);
     }
-    static buildBuiltinDbContainerName(envName, dbDialect, workspaceName) {
-        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbResourcePrefix(envName, workspaceName)}-${envName}-${dbDialect}`);
+    static buildBuiltinDbContainerName(envName, dbDialect, containerPrefix) {
+        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbContainerPrefix(containerPrefix)}-${envName}-${dbDialect}`);
     }
-    static buildDockerAppContainerName(envName, workspaceName) {
-        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbResourcePrefix(envName, workspaceName)}-${envName}-app`);
+    static buildDockerAppContainerName(envName, containerPrefix) {
+        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbContainerPrefix(containerPrefix)}-${envName}-app`);
     }
     static buildInitAppEnvVars(params) {
         const out = {};
@@ -1194,8 +1236,8 @@ export default class Install extends Command {
         const dbPort = String(params.dbPort ?? defaultDbPortForDialect(dbDialect)).trim()
             || defaultDbPortForDialect(dbDialect);
         const defaultDbDatabase = defaultDbDatabaseForDialect(dbDialect);
-        const networkName = Install.buildBuiltinDbNetworkName(params.envName, params.workspaceName);
-        const containerName = Install.buildBuiltinDbContainerName(params.envName, dbDialect, params.workspaceName);
+        const networkName = Install.buildBuiltinDbNetworkName(params.envName, params.dockerNetworkName ?? params.workspaceName);
+        const containerName = Install.buildBuiltinDbContainerName(params.envName, dbDialect, params.dockerContainerPrefix ?? params.workspaceName);
         const dbHostInput = String(params.dbHost ?? '').trim();
         const dbHost = Install.shouldPublishBuiltinDbPort(params.source)
             ? (dbHostInput
@@ -1485,6 +1527,8 @@ export default class Install extends Command {
         const plan = Install.buildBuiltinDbPlan({
             envName: params.envName,
             workspaceName: params.workspaceName,
+            dockerNetworkName: params.dockerNetworkName,
+            dockerContainerPrefix: params.dockerContainerPrefix,
             storagePath,
             source: params.downloadResults.source,
             dbDialect: params.dbResults.dbDialect,
@@ -1532,7 +1576,7 @@ export default class Install extends Command {
         const dbPassword = String(params.dbResults.dbPassword ?? DEFAULT_INSTALL_DB_PASSWORD) || DEFAULT_INSTALL_DB_PASSWORD;
         const appKey = crypto.randomBytes(32).toString('hex');
         const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-        const containerName = Install.buildDockerAppContainerName(params.envName, params.workspaceName);
+        const containerName = Install.buildDockerAppContainerName(params.envName, params.dockerContainerPrefix ?? params.workspaceName);
         const initEnvVars = Install.buildInitAppEnvVars({
             appResults: params.appResults,
             rootResults: params.rootResults,
@@ -1580,11 +1624,12 @@ export default class Install extends Command {
     }
     async installDockerApp(params) {
         const networkName = params.builtinDbPlan?.networkName
-            ?? Install.buildBuiltinDbNetworkName(params.envName, params.workspaceName);
+            ?? Install.buildBuiltinDbNetworkName(params.envName, params.dockerNetworkName ?? params.workspaceName);
         await this.ensureDockerNetwork(networkName);
         const plan = Install.buildDockerAppPlan({
             envName: params.envName,
             workspaceName: params.workspaceName,
+            dockerContainerPrefix: params.dockerContainerPrefix,
             appResults: params.appResults,
             downloadResults: params.downloadResults,
             dbResults: params.dbResults,
@@ -2041,9 +2086,13 @@ export default class Install extends Command {
         const source = String(downloadResultsValue(downloadResults, 'source') ?? '').trim();
         const usesDockerResources = Boolean(dbResults.builtinDb)
             || (Boolean(appResults.fetchSource) && source === 'docker');
-        const workspaceName = usesDockerResources
-            ? await Install.ensureWorkspaceName()
+        const dockerNetworkName = usesDockerResources
+            ? await resolveDockerNetworkName({ scope: resolveDefaultConfigScope() })
+            : undefined;
+        const dockerContainerPrefix = usesDockerResources
+            ? await resolveDockerContainerPrefix({ scope: resolveDefaultConfigScope() })
             : undefined;
+        await Install.ensureExternalDbReadyForInstall(dbResults);
         if (!parsed.resume) {
             await this.saveInstalledEnv({
                 envName,
@@ -2053,12 +2102,14 @@ export default class Install extends Command {
                 rootResults,
                 envAddResults,
             });
+            p.log.info(`Saved install config for env "${envName}"`);
         }
         let builtinDbPlan;
         if (Boolean(dbResults.builtinDb)) {
             builtinDbPlan = await this.startBuiltinDb({
                 envName,
-                workspaceName,
+                dockerNetworkName,
+                dockerContainerPrefix,
                 appResults,
                 downloadResults,
                 dbResults,
@@ -2082,7 +2133,8 @@ export default class Install extends Command {
                 });
                 dockerAppPlan = await this.installDockerApp({
                     envName,
-                    workspaceName,
+                    dockerNetworkName,
+                    dockerContainerPrefix,
                     appResults,
                     downloadResults,
                     dbResults,

package/dist/commands/license/activate.js

@@ -0,0 +1,360 @@
+/**
+ * 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 { announceTargetEnv, 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);
+        if (!flags.json) {
+            announceTargetEnv(runtime.envName);
+        }
+        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}`);
+    }
+}