@nocobase/cli 2.1.0-beta.43 → 2.1.0-beta.44.test.1

package/dist/commands/license/activate.js

@@ -7,199 +7,98 @@
  * 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 { translateCli } from '../../lib/cli-locale.js';
 import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
 import { input, password as promptPassword, select } from "../../lib/inquirer.js";
-import { createLicenseEnvFlag, ensureInstanceId, licenseJsonFlag, licensePkgUrlFlag, licenseYesFlag, redactLicenseKey, requireLicenseRuntime, resolveLicenseKeyFile, resolveLicenseServiceUrl, saveLicenseKey, sanitizeLicenseOutput, validateLicenseKey, } from './shared.js';
+import { createLicenseEnvFlag, ensureInstanceId, licenseJsonFlag, licenseYesFlag, redactLicenseKey, requireLicenseRuntime, resolveLicenseKeyFile, 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 licenseActivateText = (key, values, fallback) => translateCli(`commands.license.activate.${key}`, values, { fallback });
+function resolveHostnameNoticeValue(runtime) {
+    const currentAppUrl = String(appUrl(runtime) ?? '').trim();
+    if (!currentAppUrl) {
+        return;
+    }
     try {
-        return await select({
-            message: 'How do you want to activate the license?',
-            choices: [
-                { value: 'online', name: 'Request and activate a license online' },
-                { value: 'key', name: 'Use an existing license key' },
-                { value: 'cancel', name: 'Cancel' },
-            ],
-            default: 'online',
-        });
+        const url = new URL(currentAppUrl);
+        return url.host || undefined;
     }
     catch {
-        return 'cancel';
+        return currentAppUrl;
     }
 }
+function formatInstanceIdNotice(instanceId, hostname) {
+    return [
+        '',
+        ...(hostname
+            ? [pc.cyan(pc.bold(licenseActivateText('interactive.notice.hostnameLabel'))), `  ${pc.bold(hostname)}`, '']
+            : []),
+        pc.cyan(pc.bold(licenseActivateText('interactive.notice.instanceIdLabel'))),
+        `  ${pc.bold(instanceId)}`,
+        pc.dim(`  ${licenseActivateText(hostname ? 'interactive.notice.copyHintWithHostname' : 'interactive.notice.copyHintWithoutHostname')}`),
+        '',
+    ].join('\n');
+}
 async function promptLicenseKeyInput() {
     let answer;
     try {
         answer = await select({
-            message: 'How do you want to provide the license key?',
+            message: licenseActivateText('interactive.prompts.provideMethod.message'),
             choices: [
-                { value: 'key', name: 'Paste the license key' },
-                { value: 'file', name: 'Read the key from a file' },
+                { value: 'key', name: licenseActivateText('interactive.prompts.provideMethod.keyOption') },
+                { value: 'file', name: licenseActivateText('interactive.prompts.provideMethod.fileOption') },
             ],
             default: 'key',
         });
     }
     catch {
-        return {};
+        return;
     }
     if (answer === 'key') {
         try {
-            const key = await input({
-                message: 'License key',
-                validate: (value) => String(value ?? '').trim() ? true : 'License key is required.',
+            const key = await promptPassword({
+                message: licenseActivateText('interactive.prompts.key.message'),
+                mask: false,
+                transformer: (value) => licenseActivateText('interactive.prompts.key.transformer', { count: value.length }),
+                validate: (value) => String(value ?? '').trim() ? true : licenseActivateText('interactive.prompts.key.required'),
             });
             return { key: String(key ?? '').trim() || undefined };
         }
         catch {
-            return {};
+            return;
         }
     }
     try {
         const keyFile = await input({
-            message: 'Path to the license key file',
-            validate: (value) => String(value ?? '').trim() ? true : 'License key file path is required.',
+            message: licenseActivateText('interactive.prompts.keyFile.message'),
+            validate: (value) => String(value ?? '').trim() ? true : licenseActivateText('interactive.prompts.keyFile.required'),
         });
         return { keyFile: String(keyFile ?? '').trim() || undefined };
     }
     catch {
-        return {};
-    }
-}
-async function promptOnlineActivationInput(initial, defaultAppName) {
-    let account = String(initial.account ?? '').trim();
-    if (!account) {
-        try {
-            const answer = await input({
-                message: 'Service account',
-                validate: (value) => String(value ?? '').trim() ? true : 'Service account is required.',
-            });
-            account = String(answer ?? '').trim();
-        }
-        catch {
-            return;
-        }
-    }
-    if (!account) {
-        return;
-    }
-    let password = String(initial.password ?? '').trim();
-    if (!password) {
-        try {
-            const answer = await promptPassword({
-                message: 'Service password',
-                mask: '•',
-                validate: (value) => String(value ?? '').trim() ? true : 'Service password is required.',
-            });
-            password = String(answer ?? '').trim();
-        }
-        catch {
-            return;
-        }
-    }
-    if (!password) {
         return;
     }
-    let appName = String(initial.appName ?? '').trim();
-    if (!appName) {
-        try {
-            const resolvedDefaultAppName = String(defaultAppName ?? '').trim();
-            const answer = await input({
-                message: 'Application name',
-                default: resolvedDefaultAppName || undefined,
-                validate: (value) => String(value ?? '').trim() ? true : 'Application name is required.',
-            });
-            appName = String(answer ?? '').trim();
-        }
-        catch {
-            return;
-        }
-    }
-    if (!appName) {
-        return;
-    }
-    return {
-        account,
-        password,
-        appName,
-        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 summary = 'Activate an existing commercial license key for the selected env';
+    static description = 'Activate an existing commercial license key for the selected env.';
     static examples = [
+        '<%= config.bin %> <%= command.id %>',
         '<%= 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',
-        '<%= 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: createLicenseEnvFlag('CLI env name to activate a license for. Defaults to the current env when omitted'),
         json: licenseJsonFlag,
         key: Flags.string({
-            description: 'Existing license key to activate',
+            description: 'Existing commercial 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',
+            description: 'Path to a file containing the existing commercial license key to activate',
         }),
-        desc: Flags.string({
-            description: 'Application name for online activation',
-        }),
-        'pkg-url': licensePkgUrlFlag,
         yes: licenseYesFlag,
     };
     async run() {
@@ -222,113 +121,33 @@ export default class LicenseActivate extends Command {
         }
         let key = String(flags.key ?? '').trim();
         let keyFile = String(flags['key-file'] ?? '').trim();
-        let online = Boolean(flags.online);
-        if (!key && !keyFile && !online) {
+        let interactiveKeyFlowInstanceId;
+        if (!key && !keyFile) {
             if (!isInteractiveTerminal()) {
-                this.error('Provide --key, --key-file, or --online to continue.');
+                this.error(licenseActivateText('errors.provideKeyOrKeyFile'));
             }
-            const mode = await promptActivationMode();
-            if (mode === 'cancel') {
+            interactiveKeyFlowInstanceId = await ensureInstanceId(runtime);
+            const hostname = resolveHostnameNoticeValue(runtime);
+            this.log(formatInstanceIdNotice(interactiveKeyFlowInstanceId, hostname));
+            const prompted = await promptLicenseKeyInput();
+            if (!prompted) {
                 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.');
-                }
+            key = String(prompted.key ?? '').trim();
+            keyFile = String(prompted.keyFile ?? '').trim();
+            if (!key && !keyFile) {
+                this.error(licenseActivateText('errors.emptyInput'));
             }
         }
-        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),
-                serviceUrl: resolvedServiceUrl,
-            };
-            let onlineInput = initialOnline;
-            if (!onlineInput.account
-                || !onlineInput.password
-                || !onlineInput.appName) {
-                if (!isInteractiveTerminal()) {
-                    this.error('Online activation requires --account, --password, and --desc when not using a TTY.');
-                }
-                const prompted = await promptOnlineActivationInput(initialOnline, runtime.envName);
-                if (!prompted) {
-                    return;
-                }
-                onlineInput = prompted;
-            }
-            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 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),
+            instanceId: interactiveKeyFlowInstanceId ?? (await ensureInstanceId(runtime)),
             mode: 'key',
             key: redactLicenseKey(resolvedKey),
             keyFile: keyFile || undefined,
@@ -344,17 +163,17 @@ export default class LicenseActivate extends Command {
         }
         if (!ok) {
             const reason = validation.keyStatus
-                ? `license key is ${validation.keyStatus}`
+                ? licenseActivateText('errors.reasons.keyStatus', { status: validation.keyStatus })
                 : !validation.envMatch
-                    ? 'license key does not match the current instance environment'
+                    ? licenseActivateText('errors.reasons.envMismatch')
                     : !validation.domainMatch
-                        ? 'license key does not match the current app domain'
+                        ? licenseActivateText('errors.reasons.domainMismatch')
                         : validation.licenseStatus !== 'active'
-                            ? `license status is ${validation.licenseStatus}`
-                            : 'license validation failed';
-            this.error(`Failed to activate the license for env "${runtime.envName}": ${reason}.`);
+                            ? licenseActivateText('errors.reasons.licenseStatus', { status: validation.licenseStatus })
+                            : licenseActivateText('errors.reasons.validationFailed');
+            this.error(licenseActivateText('errors.activationFailed', { envName: runtime.envName, reason }));
         }
-        this.log(`Activated the license for env "${runtime.envName}".`);
-        this.log(`Saved license key at ${licenseKeyPath}`);
+        this.log(licenseActivateText('messages.activated', { envName: runtime.envName }));
+        this.log(licenseActivateText('messages.savedLicenseKey', { licenseKeyPath }));
     }
 }

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

@@ -7,7 +7,7 @@
  * 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 { access, mkdir, readFile, rm } from 'node:fs/promises';
 import { Readable } from 'node:stream';
 import { createGunzip } from 'node:zlib';
 import * as tar from 'tar';
@@ -34,6 +34,10 @@ async function pathExists(target) {
         return false;
     }
 }
+function trimString(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
 async function loginPkg(baseURL, keyData) {
     const username = String(keyData.accessKeyId ?? '').trim();
     const password = String(keyData.accessKeySecret ?? '').trim();
@@ -98,15 +102,16 @@ async function packageMetadata(baseURL, token, pluginName) {
         if (!response.ok) {
             return undefined;
         }
-        return await response.json();
+        return (await response.json());
     }
     catch {
         return undefined;
     }
 }
 function resolveTarball(metadata, requestedVersion) {
-    if (metadata.versions?.[requestedVersion]) {
-        return [requestedVersion, metadata.versions[requestedVersion].dist.tarball];
+    const requestedTarball = trimString(metadata.versions?.[requestedVersion]?.dist?.tarball);
+    if (requestedTarball) {
+        return [requestedVersion, requestedTarball];
     }
     let version = requestedVersion;
     if (version.includes('rc')) {
@@ -129,16 +134,36 @@ function resolveTarball(metadata, requestedVersion) {
     else if (requestedVersion.includes('alpha')) {
         version = metadata['dist-tags']?.alpha || metadata['dist-tags']?.next;
     }
-    if (!metadata.versions?.[version]) {
+    const tarball = trimString(metadata.versions?.[version]?.dist?.tarball);
+    if (!tarball) {
         return undefined;
     }
-    return [version, metadata.versions[version].dist.tarball];
+    return [version, tarball];
 }
-async function downloadPlugin(baseURL, token, pluginName, requestedVersion, storagePath) {
+async function readDownloadedPluginVersion(outputDir) {
+    const packageJsonPath = path.resolve(outputDir, 'package.json');
+    let content;
+    try {
+        content = await readFile(packageJsonPath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        return trimString(parsed.version);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function planPluginDownload(baseURL, token, pluginName, requestedVersion, storagePath) {
     const metadata = await packageMetadata(baseURL, token, pluginName);
+    const outputDir = path.resolve(storagePath, pluginName);
     if (!metadata) {
         return {
             action: 'skipped',
+            outputDir,
             warning: `Commercial plugin package "${pluginName}" does not exist in the package registry.`,
         };
     }
@@ -146,12 +171,36 @@ async function downloadPlugin(baseURL, token, pluginName, requestedVersion, stor
     if (!tarball) {
         return {
             action: 'skipped',
+            outputDir,
             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'));
+    const packageJsonPath = path.resolve(outputDir, 'package.json');
+    const localVersion = await readDownloadedPluginVersion(outputDir);
+    if (localVersion === resolvedVersion) {
+        return {
+            action: 'skipped',
+            outputDir,
+        };
+    }
+    const existedBefore = await pathExists(packageJsonPath);
+    return {
+        action: existedBefore ? 'updated' : 'installed',
+        outputDir,
+        resolvedVersion,
+        tarballUrl,
+    };
+}
+async function downloadPlugin(baseURL, token, pluginName, requestedVersion, storagePath) {
+    const plan = await planPluginDownload(baseURL, token, pluginName, requestedVersion, storagePath);
+    if (plan.action === 'skipped') {
+        return {
+            action: 'skipped',
+            ...(plan.warning ? { warning: plan.warning } : {}),
+        };
+    }
+    const { action, outputDir, resolvedVersion, tarballUrl } = plan;
     try {
         await rm(outputDir, { recursive: true, force: true });
         await mkdir(outputDir, { recursive: true });
@@ -174,7 +223,7 @@ async function downloadPlugin(baseURL, token, pluginName, requestedVersion, stor
                 .on('error', reject);
         });
         return {
-            action: existedBefore ? 'updated' : 'installed',
+            action,
         };
     }
     catch (error) {
@@ -246,14 +295,16 @@ export async function syncLicensedPlugins(runtime, options) {
     }
     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';
+            const { action, outputDir, warning } = await planPluginDownload(baseURL, token, pluginName, options.version, storagePath);
             result[action].push(pluginName);
+            if (warning) {
+                result.warnings.push(warning);
+            }
             await emitDetail({
                 packageName: pluginName,
                 action,
                 outputDir,
+                ...(warning ? { warning } : {}),
             });
             continue;
         }

package/dist/commands/plugin/import.js

@@ -0,0 +1,108 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { importPluginSource } from '../../lib/plugin-import.js';
+import { announceTargetEnv } from '../../lib/ui.js';
+export default class PluginImport extends Command {
+    static hidden = false;
+    static args = {
+        archive: Args.string({
+            required: true,
+            description: 'Plugin source to import. Accepts a local .tgz path, a remote http(s) URL, or an npm package spec.',
+        }),
+    };
+    static summary = 'Import a packaged plugin into storage/plugins for the selected env';
+    static description = 'Download or read a packaged plugin source and extract it into the selected env storage/plugins directory without enabling it.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> https://github.com/nocobase/plugin-auth-cas/releases/download/v1.4.0/plugin-auth-cas-1.4.0.tgz',
+        '<%= config.bin %> <%= command.id %> /your/path/plugin-auth-cas-1.4.0.tgz',
+        '<%= config.bin %> <%= command.id %> @nocobase/plugin-acl@beta',
+        '<%= config.bin %> <%= command.id %> @nocobase/plugin-acl@beta --npm-registry=https://registry.npmjs.org',
+        '<%= config.bin %> <%= command.id %> --env app1 ./plugin-auth-cas-1.4.0.tgz',
+        '<%= config.bin %> <%= command.id %> --storage-path ./storage ./plugin-auth-cas-1.4.0.tgz',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to import the plugin into. Defaults to the current env when omitted',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
+        }),
+        'storage-path': Flags.string({
+            description: 'Override the env storage root path. Imported plugins are written into <storage-path>/plugins',
+        }),
+        'npm-registry': Flags.string({
+            description: 'npm registry to use when the import source is an npm package spec.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PluginImport);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const storagePathOverride = flags['storage-path']?.trim() || undefined;
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes: flags.yes,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        const archiveSource = args.archive?.trim();
+        if (!archiveSource) {
+            this.error('Pass a plugin archive path, URL, or npm package spec.');
+        }
+        const shouldResolveTargetEnv = Boolean(requestedEnv || !storagePathOverride);
+        const runtime = await resolveManagedAppRuntime(shouldResolveTargetEnv ? requestedEnv : undefined);
+        if (shouldResolveTargetEnv && !runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime && shouldResolveTargetEnv && runtime.kind === 'http') {
+            this.error([
+                `Can't import plugins for "${runtime.envName}" yet.`,
+                'HTTP envs do not expose a writable storage/plugins path to the CLI.',
+                'Use a local or Docker env for plugin imports right now.',
+            ].join('\n'));
+        }
+        if (runtime && shouldResolveTargetEnv && runtime.kind === 'ssh') {
+            this.error([
+                `Can't import plugins for "${runtime.envName}" yet.`,
+                'SSH env support is reserved but not implemented yet.',
+                'Use a local or Docker env for plugin imports right now.',
+            ].join('\n'));
+        }
+        if (runtime && shouldResolveTargetEnv) {
+            announceTargetEnv(runtime.envName);
+        }
+        const runtimeForDefaults = runtime && runtime.kind !== 'http' && runtime.kind !== 'ssh' ? runtime : undefined;
+        const npmRegistry = flags['npm-registry']?.trim() || String(runtimeForDefaults?.env.config.npmRegistry ?? '').trim() || undefined;
+        const storagePath = storagePathOverride || runtimeForDefaults?.env.storagePath;
+        const result = await importPluginSource(archiveSource, {
+            storagePath,
+            npmRegistry,
+        });
+        const label = result.action === 'updated' ? 'Updated' : 'Imported';
+        const versionSuffix = result.packageVersion ? `@${result.packageVersion}` : '';
+        this.log(`${label} ${result.packageName}${versionSuffix} into ${result.outputDir}`);
+        this.log(`Plugin storage path: ${result.storagePluginsPath}`);
+        if (runtime && shouldResolveTargetEnv) {
+            this.log(`Restart the app before enabling or using the plugin: \`nb app restart --env ${runtime.envName}\`.`);
+        }
+        else {
+            this.log('Restart the app that uses this plugin storage path before enabling or using the plugin.');
+        }
+    }
+}