@nocobase/cli 2.1.0-beta.8 → 2.1.0

package/dist/commands/license/shared.js

@@ -0,0 +1,423 @@
+/**
+ * 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 { Flags } from '@oclif/core';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getEnvAsync, getInstanceIdAsync, keyDecrypt } from '@nocobase/license-kit';
+import { checkExternalDbConnection, readExternalDbConnectionConfig, } from "../../lib/db-connection-check.js";
+import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "../../lib/docker-image.js";
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { buildRuntimeEnvVars } from '../../lib/runtime-env-vars.js';
+import { resolveLicensePkgUrlFromConfig } from '../../lib/cli-config.js';
+import { deepEqual, omitKeys } from "../../lib/object-utils.js";
+import { commandOutput } from '../../lib/run-npm.js';
+import { appUrl } from '../env/shared.js';
+export function createLicenseEnvFlag(description) {
+    return Flags.string({
+        char: 'e',
+        description,
+    });
+}
+export const licenseYesFlag = Flags.boolean({
+    char: 'y',
+    description: 'Confirm using --env when it targets a different env than the current env',
+    default: false,
+});
+export const licenseJsonFlag = Flags.boolean({
+    description: 'Output the result as JSON',
+    default: false,
+});
+const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
+export const licensePkgUrlFlag = Flags.string({
+    description: 'Commercial package service base URL',
+    hidden: true,
+});
+export async function requireLicenseRuntime(envName) {
+    const runtime = await resolveManagedAppRuntime(envName);
+    if (!runtime) {
+        throw new Error(formatMissingManagedAppEnvMessage(envName));
+    }
+    return runtime;
+}
+export function resolveLicenseDir(runtime) {
+    return path.resolve(runtime.env.storagePath, '.license');
+}
+export function resolveInstanceIdFile(runtime) {
+    return path.resolve(resolveLicenseDir(runtime), 'instance-id');
+}
+export function resolveLicenseKeyFile(runtime) {
+    return path.resolve(resolveLicenseDir(runtime), 'license-key');
+}
+export async function readSavedInstanceId(runtime) {
+    try {
+        const value = await readFile(resolveInstanceIdFile(runtime), 'utf8');
+        const normalized = value.trim();
+        return normalized || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function normalizeDockerPlatform(value) {
+    const text = trimValue(value);
+    if (!text || text === 'auto') {
+        return undefined;
+    }
+    if (text === 'linux/amd64' || text === 'linux/arm64') {
+        return text;
+    }
+    return undefined;
+}
+function resolveDockerLicenseImageRef(runtime) {
+    const config = runtime.env.config ?? {};
+    return resolveDockerImageRef(config.dockerRegistry, config.downloadVersion, {
+        defaultRegistry: DEFAULT_DOCKER_REGISTRY,
+        defaultVersion: DEFAULT_DOCKER_VERSION,
+    });
+}
+function buildDockerLicenseDbFlagArgs(envVars) {
+    return [
+        '--db-dialect',
+        String(envVars.DB_DIALECT ?? ''),
+        '--db-host',
+        String(envVars.DB_HOST ?? ''),
+        '--db-port',
+        String(envVars.DB_PORT ?? ''),
+        '--db-database',
+        String(envVars.DB_DATABASE ?? ''),
+        '--db-user',
+        String(envVars.DB_USER ?? ''),
+        '--db-password',
+        String(envVars.DB_PASSWORD ?? ''),
+    ];
+}
+async function runDockerLicenseJsonCommand(runtime, commandArgs) {
+    const args = [
+        'run',
+        '--rm',
+        '--network',
+        runtime.dockerNetworkName || runtime.workspaceName,
+    ];
+    const dockerPlatform = normalizeDockerPlatform(runtime.env.config?.dockerPlatform);
+    if (dockerPlatform) {
+        args.push('--platform', dockerPlatform);
+    }
+    args.push('--entrypoint', 'nb', resolveDockerLicenseImageRef(runtime), ...commandArgs, '--json');
+    const output = await commandOutput('docker', args, {
+        errorName: 'docker run',
+    });
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        throw new Error(`Failed to parse Docker license command response: ${output}`);
+    }
+}
+function buildLicenseDbConfigFromEnvVars(envVars) {
+    return {
+        builtinDb: false,
+        dbDialect: trimValue(envVars.DB_DIALECT),
+        dbHost: trimValue(envVars.DB_HOST),
+        dbPort: trimValue(envVars.DB_PORT),
+        dbDatabase: trimValue(envVars.DB_DATABASE),
+        dbUser: trimValue(envVars.DB_USER),
+        dbPassword: envVars.DB_PASSWORD,
+    };
+}
+export async function validateLicenseDbConnectionFromEnvVars(envVars) {
+    const connectionConfig = readExternalDbConnectionConfig(buildLicenseDbConfigFromEnvVars(envVars));
+    if (!connectionConfig) {
+        throw new Error('Unsupported or incomplete database settings for instance ID generation.');
+    }
+    const validationError = await checkExternalDbConnection(connectionConfig);
+    if (validationError) {
+        throw new Error(validationError);
+    }
+}
+export async function withLicenseEnvVars(nextEnv, task) {
+    const previous = {};
+    for (const [key, value] of Object.entries(nextEnv)) {
+        previous[key] = process.env[key];
+        process.env[key] = value;
+    }
+    try {
+        return await task();
+    }
+    finally {
+        for (const key of Object.keys(nextEnv)) {
+            const value = previous[key];
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    }
+}
+async function withLicenseEnv(runtime, task) {
+    return await withLicenseEnvVars(await buildRuntimeEnvVars(runtime), task);
+}
+export async function getCurrentLicenseEnv(runtime) {
+    if (runtime.kind === 'docker') {
+        const envVars = await buildRuntimeEnvVars(runtime);
+        const payload = await runDockerLicenseJsonCommand(runtime, [
+            'license',
+            'env',
+            ...buildDockerLicenseDbFlagArgs(envVars),
+        ]);
+        return payload?.env;
+    }
+    return await withLicenseEnv(runtime, async () => await getEnvAsync());
+}
+export async function generateInstanceIdFromEnvVars(envVars) {
+    const instanceId = String(await withLicenseEnvVars(envVars, async () => await getInstanceIdAsync())).trim();
+    if (!instanceId) {
+        throw new Error('Generated instance ID is empty.');
+    }
+    return instanceId;
+}
+export async function generateValidatedInstanceIdFromEnvVars(envVars) {
+    await validateLicenseDbConnectionFromEnvVars(envVars);
+    return await generateInstanceIdFromEnvVars(envVars);
+}
+async function generateInstanceIdForDockerRuntime(runtime) {
+    const envVars = await buildRuntimeEnvVars(runtime);
+    const payload = await runDockerLicenseJsonCommand(runtime, [
+        'license',
+        'generate-id',
+        ...buildDockerLicenseDbFlagArgs(envVars),
+    ]);
+    const instanceId = trimValue(payload.instanceId);
+    if (!instanceId) {
+        throw new Error('Docker instance ID generation did not return an instance ID.');
+    }
+    return instanceId;
+}
+export async function generateInstanceIdForRuntime(runtime) {
+    if (runtime.kind === 'docker') {
+        return await generateInstanceIdForDockerRuntime(runtime);
+    }
+    if (runtime.kind === 'local') {
+        return await generateValidatedInstanceIdFromEnvVars(await buildRuntimeEnvVars(runtime));
+    }
+    throw new Error(`Env "${runtime.envName}" does not support automatic instance ID generation.`);
+}
+export async function saveInstanceId(runtime, instanceId) {
+    const normalized = String(instanceId ?? '').trim();
+    if (!normalized) {
+        throw new Error('Generated instance ID is empty.');
+    }
+    await mkdir(resolveLicenseDir(runtime), { recursive: true });
+    await writeFile(resolveInstanceIdFile(runtime), `${normalized}\n`);
+    return normalized;
+}
+export async function generateAndSaveInstanceId(runtime) {
+    const instanceId = await generateInstanceIdForRuntime(runtime);
+    return await saveInstanceId(runtime, instanceId);
+}
+export async function ensureInstanceId(runtime, options = {}) {
+    if (!options.force) {
+        const saved = await readSavedInstanceId(runtime);
+        if (saved) {
+            return saved;
+        }
+    }
+    return await generateAndSaveInstanceId(runtime);
+}
+export function parseLicenseKey(key) {
+    try {
+        return JSON.parse(keyDecrypt(key));
+    }
+    catch {
+        throw new Error('invalid');
+    }
+}
+export async function saveLicenseKey(runtime, key) {
+    await mkdir(resolveLicenseDir(runtime), { recursive: true });
+    const filePath = resolveLicenseKeyFile(runtime);
+    await writeFile(filePath, key.trim());
+    return filePath;
+}
+export async function readSavedLicenseKey(runtime) {
+    try {
+        const value = await readFile(resolveLicenseKeyFile(runtime), 'utf8');
+        const normalized = value.trim();
+        return normalized || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function matchSingleDomain(licenseDomain, currentDomain) {
+    let hostname = '';
+    let port = '';
+    try {
+        const url = new URL(currentDomain);
+        hostname = url.hostname;
+        port = url.port ? `:${url.port}` : '';
+    }
+    catch {
+        return false;
+    }
+    const fullDomain = hostname + port;
+    if (!licenseDomain.includes('*')) {
+        return fullDomain === licenseDomain;
+    }
+    const base = licenseDomain.replace('*', '');
+    return fullDomain.endsWith(base);
+}
+export function isDomainMatch(currentDomain, keyData) {
+    if (!keyData?.licenseKey?.domain || !currentDomain) {
+        return false;
+    }
+    const licenseDomains = String(keyData.licenseKey.domain)
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    return licenseDomains.some((licenseDomain) => matchSingleDomain(licenseDomain, currentDomain));
+}
+export function isDbMatch(env, keyData) {
+    const currentDb = env?.db;
+    const licenseDb = keyData?.instanceData?.db;
+    if (!currentDb || !licenseDb) {
+        return false;
+    }
+    if (currentDb?.id && licenseDb?.id) {
+        return currentDb.id === licenseDb.id;
+    }
+    return deepEqual(omitKeys(currentDb, ['id']), omitKeys(licenseDb, ['id']));
+}
+export function isSysMatch(env, keyData) {
+    const instance = keyData?.instanceData;
+    if (!env || !instance) {
+        return false;
+    }
+    const normalize = (item) => ({
+        sys: item?.sys ?? null,
+        osVer: item?.osVer ?? null,
+    });
+    return deepEqual(normalize(env), normalize(instance));
+}
+export async function getLicenseStatus(keyData) {
+    if (!keyData) {
+        return 'invalid';
+    }
+    if (keyData.licenseKey?.licenseStatus === 'invalid') {
+        return 'invalid';
+    }
+    const domain = String(keyData.service?.domain ?? '').trim();
+    const accessKeyId = String(keyData.accessKeyId ?? '').trim();
+    const accessKeySecret = String(keyData.accessKeySecret ?? '').trim();
+    if (!domain || !accessKeyId || !accessKeySecret) {
+        return 'active';
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch(`${domain.replace(/\/$/, '')}/api/license_keys:getKeyStatus`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(keyData.service?.headers ?? {}),
+            },
+            body: JSON.stringify({
+                access_key_id: accessKeyId,
+                access_key_secret: accessKeySecret,
+            }),
+            signal: controller.signal,
+        });
+        const payload = await response.json();
+        return payload?.data?.status === 'active' ? 'active' : 'invalid';
+    }
+    catch {
+        return 'active';
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function validateLicenseKey(runtime, key) {
+    let keyData;
+    let keyStatus;
+    try {
+        keyData = parseLicenseKey(key);
+    }
+    catch {
+        keyStatus = 'invalid';
+    }
+    const currentEnv = await getCurrentLicenseEnv(runtime);
+    const currentDomain = appUrl(runtime);
+    const dbMatch = isDbMatch(currentEnv, keyData);
+    const sysMatch = isSysMatch(currentEnv, keyData);
+    const envMatch = dbMatch && sysMatch;
+    const domainMatch = isDomainMatch(currentDomain, keyData);
+    const licenseStatus = await getLicenseStatus(keyData);
+    return {
+        current: {
+            env: currentEnv,
+            domain: currentDomain ? new URL(currentDomain).host : '',
+        },
+        keyData,
+        keyStatus,
+        dbMatch,
+        sysMatch,
+        envMatch,
+        domainMatch,
+        licenseStatus,
+    };
+}
+export function redactLicenseKey(value) {
+    const text = String(value ?? '').trim();
+    if (!text) {
+        return '';
+    }
+    if (text.length <= 8) {
+        return '*'.repeat(text.length);
+    }
+    return `${text.slice(0, 4)}...${text.slice(-4)}`;
+}
+export async function resolveLicenseServiceUrl(value) {
+    return (await resolveLicensePkgUrl(value)).replace(/\/+$/, '');
+}
+export async function resolveLicensePkgUrl(value) {
+    const normalized = String(value ?? '').trim() || await resolveLicensePkgUrlFromConfig();
+    return normalized.replace(/\/+$/, '') + '/';
+}
+function shouldRedactOutputKey(key) {
+    return /accesskeyid|accesskeysecret|secret|token|password|authorization/i.test(key);
+}
+function redactOutputValue(value) {
+    const text = String(value ?? '').trim();
+    if (!text) {
+        return '';
+    }
+    if (text.length <= 8) {
+        return '*'.repeat(text.length);
+    }
+    return `${text.slice(0, 2)}***${text.slice(-2)}`;
+}
+export function sanitizeLicenseOutput(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeLicenseOutput(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            shouldRedactOutputKey(key)
+                ? redactOutputValue(String(nestedValue ?? ''))
+                : sanitizeLicenseOutput(nestedValue),
+        ]));
+    }
+    return value;
+}

package/dist/commands/license/status.js

@@ -0,0 +1,64 @@
+/**
+ * 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 { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { createLicenseEnvFlag, ensureInstanceId, licenseJsonFlag, licenseYesFlag, requireLicenseRuntime } from './shared.js';
+export default class LicenseStatus extends Command {
+    static summary = 'Show commercial license status for the selected env';
+    static description = 'Inspect the selected env and show the current commercial licensing status. Use `--doctor` for extra diagnostic checks once the license backend wiring is implemented.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --doctor',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+    ];
+    static flags = {
+        env: createLicenseEnvFlag('CLI env name to inspect. Defaults to the current env when omitted'),
+        json: licenseJsonFlag,
+        yes: licenseYesFlag,
+        doctor: Flags.boolean({
+            description: 'Run extra diagnostic checks and suggestions',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LicenseStatus);
+        const requestedEnv = flags.env?.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 runtime = await requireLicenseRuntime(flags.env);
+        const payload = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            instanceId: await ensureInstanceId(runtime),
+            licensed: false,
+            doctor: Boolean(flags.doctor),
+            implemented: false,
+            message: 'Commercial license status is not implemented yet in the new CLI.',
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        this.log(`License status for env "${runtime.envName}": not implemented yet`);
+        if (flags.doctor) {
+            this.log('Diagnostic checks for commercial licensing are not implemented yet in the new CLI.');
+        }
+    }
+}

package/dist/commands/logs.js

@@ -0,0 +1,12 @@
+/**
+ * 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 AppLogs from './app/logs.js';
+export default class Logs extends AppLogs {
+    static hidden = true;
+}

package/dist/commands/plugin/disable.js

@@ -0,0 +1,86 @@
+/**
+ * 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, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { announceTargetEnv } from '../../lib/ui.js';
+export default class PluginDisable extends Command {
+    static hidden = false;
+    static args = {
+        packages: Args.string({
+            required: true,
+            multiple: true,
+            description: 'Plugin package name(s) to disable (e.g. `@nocobase/plugin-sample`). Pass one or more names as separate arguments.',
+        }),
+    };
+    static description = 'Disable one or more plugins in the selected env (npm/git runs locally, Docker runs inside the saved app container)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> @nocobase/plugin-sample',
+        '<%= config.bin %> <%= command.id %> @nocobase/plugin-a @nocobase/plugin-b',
+        '<%= config.bin %> <%= command.id %> -e local @nocobase/plugin-sample',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to disable plugins for. 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,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PluginDisable);
+        const requestedEnv = flags.env?.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 packages = args.packages;
+        if (!Array.isArray(packages) || packages.length === 0) {
+            this.error('Pass at least one plugin package name.');
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        announceTargetEnv(runtime.envName);
+        if (runtime.kind === 'local') {
+            try {
+                await runLocalNocoBaseCommand(runtime, ['pm', 'disable', ...packages]);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            return;
+        }
+        if (runtime.kind === 'docker') {
+            try {
+                await runDockerNocoBaseCommand(runtime.containerName, ['pm', 'disable', ...packages]);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            return;
+        }
+        await this.config.runCommand('api:pm:disable', explicitEnvSelection
+            ? ['--await-response', '--filter-by-tk', packages.join(','), '--env', runtime.envName, '--yes']
+            : ['--await-response', '--filter-by-tk', packages.join(',')]);
+    }
+}

package/dist/commands/plugin/enable.js

@@ -0,0 +1,86 @@
+/**
+ * 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, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { announceTargetEnv } from '../../lib/ui.js';
+export default class PluginEnable extends Command {
+    static hidden = false;
+    static args = {
+        packages: Args.string({
+            required: true,
+            multiple: true,
+            description: 'Plugin package name(s) to enable (e.g. `@nocobase/plugin-sample`). Pass one or more names as separate arguments.',
+        }),
+    };
+    static description = 'Enable one or more plugins in the selected env (npm/git runs locally, Docker runs inside the saved app container)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> @nocobase/plugin-sample',
+        '<%= config.bin %> <%= command.id %> @nocobase/plugin-a @nocobase/plugin-b',
+        '<%= config.bin %> <%= command.id %> -e local @nocobase/plugin-sample',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to enable plugins for. 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,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PluginEnable);
+        const requestedEnv = flags.env?.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 packages = args.packages;
+        if (!Array.isArray(packages) || packages.length === 0) {
+            this.error('Pass at least one plugin package name.');
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        announceTargetEnv(runtime.envName);
+        if (runtime.kind === 'local') {
+            try {
+                await runLocalNocoBaseCommand(runtime, ['pm', 'enable', ...packages]);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            return;
+        }
+        if (runtime.kind === 'docker') {
+            try {
+                await runDockerNocoBaseCommand(runtime.containerName, ['pm', 'enable', ...packages]);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            return;
+        }
+        await this.config.runCommand('api:pm:enable', explicitEnvSelection
+            ? ['--await-response', '--filter-by-tk', packages.join(','), '--env', runtime.envName, '--yes']
+            : ['--await-response', '--filter-by-tk', packages.join(',')]);
+    }
+}