@nocobase/cli 2.1.0-beta.9 → 2.2.0-alpha.1

package/dist/commands/v1.js

@@ -0,0 +1,210 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Command } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../lib/env-guard.js';
+import { announceTargetEnv } from '../lib/ui.js';
+const SILENT_LIKE_PASSTHROUGH_FLAGS = new Set(['--help', '-h', '--silent']);
+const SILENT_RUNTIME_ENV_VARS = {
+    LOGGER_SILENT: 'true',
+    NODE_NO_WARNINGS: '1',
+};
+const SILENT_STDERR_FILTERS = [
+    /^\(node:\d+\) \[DEP0040\] DeprecationWarning: The `punycode` module is deprecated\..*$/,
+    /^\(Use `node --trace-deprecation .*$/,
+    /^About to overwrite ArrayBuffer\.prototype properties /,
+];
+function parseBridgeArgv(argv) {
+    let requestedEnv;
+    let yes = false;
+    const passthroughArgs = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--') {
+            passthroughArgs.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token === '--env') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `--env`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--env=')) {
+            requestedEnv = token.slice('--env='.length).trim() || undefined;
+            continue;
+        }
+        if (token === '-e') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `-e`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-e') && token.length > 2) {
+            requestedEnv = token.slice(2).trim() || undefined;
+            continue;
+        }
+        if (token === '--yes') {
+            yes = true;
+            continue;
+        }
+        passthroughArgs.push(...argv.slice(index));
+        break;
+    }
+    return {
+        requestedEnv,
+        yes,
+        passthroughArgs,
+    };
+}
+function formatHttpEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'This env only has an API connection, so the v1 bridge is not available here.',
+        'Use a local or Docker env instead.',
+    ].join('\n');
+}
+function formatSshEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'SSH env support is reserved but not implemented yet.',
+        'Use a local or Docker env right now.',
+    ].join('\n');
+}
+function hasSilentLikePassthrough(args) {
+    return args.some((arg) => SILENT_LIKE_PASSTHROUGH_FLAGS.has(arg));
+}
+function shouldFilterSilentStderrLine(line) {
+    const normalized = line.replace(/\r$/, '');
+    return SILENT_STDERR_FILTERS.some((pattern) => pattern.test(normalized));
+}
+function createSilentBridgeOptions() {
+    let pendingStderr = '';
+    const flushBufferedStderr = (force) => {
+        while (true) {
+            const newlineIndex = pendingStderr.indexOf('\n');
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = pendingStderr.slice(0, newlineIndex);
+            pendingStderr = pendingStderr.slice(newlineIndex + 1);
+            if (!shouldFilterSilentStderrLine(line)) {
+                process.stderr.write(`${line}\n`);
+            }
+        }
+        if (force && pendingStderr) {
+            if (!shouldFilterSilentStderrLine(pendingStderr)) {
+                process.stderr.write(pendingStderr);
+            }
+            pendingStderr = '';
+        }
+    };
+    return {
+        commandOptions: {
+            stdio: 'pipe',
+            env: {
+                ...SILENT_RUNTIME_ENV_VARS,
+            },
+            onStdout: (chunk) => {
+                process.stdout.write(chunk);
+            },
+            onStderr: (chunk) => {
+                pendingStderr += chunk;
+                flushBufferedStderr(false);
+            },
+        },
+        flush: () => {
+            flushBufferedStderr(true);
+        },
+    };
+}
+export default class V1 extends Command {
+    static hidden = true;
+    static strict = false;
+    static summary = 'Forward commands to the selected env through the v1 bridge';
+    static description = 'Forward v1-compatible commands to the selected env. Defaults to the current env when `--env` is omitted. Local envs run `nocobase-v1`, and Docker envs run inside the saved app container. Bridge flags (`--env`, `--yes`) must appear before the forwarded command. Use `--` when the forwarded command needs the same flag names.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> build',
+        '<%= config.bin %> <%= command.id %> --env local pm list',
+        '<%= config.bin %> <%= command.id %> --env docker-local -- pm enable @nocobase/plugin-sample --yes',
+    ];
+    async run() {
+        const originalArgv = [...this.argv];
+        await this.parse({ strict: false, flags: {}, args: {} }, []);
+        this.argv = originalArgv;
+        let parsed;
+        try {
+            parsed = parseBridgeArgv(this.argv);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+        const { requestedEnv, yes, passthroughArgs } = parsed;
+        if (passthroughArgs.length === 0) {
+            this.error('Pass at least one v1 command to forward.');
+        }
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const silentLike = hasSilentLikePassthrough(passthroughArgs);
+        const silentBridge = silentLike ? createSilentBridgeOptions() : undefined;
+        if (!silentLike) {
+            announceTargetEnv(runtime.envName);
+        }
+        if (runtime.kind === 'local') {
+            try {
+                await runLocalNocoBaseCommand(runtime, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'docker') {
+            try {
+                await runDockerNocoBaseCommand(runtime.containerName, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'http') {
+            this.error(formatHttpEnvError(runtime.envName));
+        }
+        this.error(formatSshEnvError(runtime.envName));
+    }
+}

package/dist/generated/command-registry.js

@@ -0,0 +1,134 @@
+/**
+ * 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.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { Command, loadHelpClass } from '@oclif/core';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { collectCommandModulePaths, commandRelativePathToRegistryKey, } from "../lib/command-discovery.js";
+import { getCurrentEnvName, getEnv } from "../lib/auth-store.js";
+import { createGeneratedFlags, GeneratedApiCommand } from "../lib/generated-command.js";
+import { toKebabCase } from "../lib/naming.js";
+import { loadRuntimeSync } from "../lib/runtime-store.js";
+const registryFilePath = fileURLToPath(import.meta.url);
+const commandsRoot = join(dirname(registryFilePath), '../commands');
+const commandModuleExtension = registryFilePath.endsWith('.ts') ? '.ts' : '.js';
+async function loadCommandsFromDirectory() {
+    const absolutePaths = await collectCommandModulePaths(commandsRoot, commandModuleExtension);
+    const entries = await Promise.all(absolutePaths.map(async (absolutePath) => {
+        const rel = relative(commandsRoot, absolutePath).replace(/\\/g, '/');
+        const key = commandRelativePathToRegistryKey(rel);
+        const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(absolutePath).href));
+        return [key, mod.default];
+    }));
+    return Object.fromEntries(entries);
+}
+function readEnvName(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--env') {
+            return argv[index + 1];
+        }
+        if (token === '-e') {
+            return argv[index + 1];
+        }
+        if (token.startsWith('--env=')) {
+            return token.slice('--env='.length);
+        }
+    }
+    return undefined;
+}
+function createRuntimeCommand(operation, runtimeVersion) {
+    return class RuntimeCommand extends GeneratedApiCommand {
+        static summary = operation.summary;
+        static description = operation.description;
+        static examples = operation.examples;
+        static flags = createGeneratedFlags(operation);
+        static operation = operation;
+        static runtimeVersion = runtimeVersion;
+    };
+}
+function createRuntimeIndexCommand(commandId, metadata) {
+    const summary = metadata.summary || `Work with ${commandId}`;
+    const description = metadata.description && metadata.description !== summary ? metadata.description : undefined;
+    return class RuntimeIndexCommand extends Command {
+        static summary = summary;
+        static description = description;
+        async run() {
+            await this.parse(RuntimeIndexCommand);
+            const Help = await loadHelpClass(this.config);
+            await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+                this.id ?? commandId.replaceAll(' ', ':'),
+                ...this.argv,
+            ]);
+        }
+    };
+}
+function getRuntimeTopicEntries(operation) {
+    const commandSegments = operation.commandId.split(' ');
+    const topLevelCommandId = commandSegments[0];
+    const modulePrefix = toKebabCase(operation.moduleDisplayName || operation.moduleName || '');
+    const isTopLevelResource = Boolean(topLevelCommandId && modulePrefix && topLevelCommandId !== modulePrefix);
+    const entries = [];
+    if (!topLevelCommandId) {
+        return entries;
+    }
+    if (isTopLevelResource) {
+        entries.push([
+            topLevelCommandId,
+            {
+                summary: operation.resourceDescription || operation.resourceDisplayName,
+                description: operation.resourceDescription,
+            },
+        ]);
+        return entries;
+    }
+    entries.push([
+        topLevelCommandId,
+        {
+            summary: operation.moduleDescription || operation.moduleDisplayName || operation.moduleName,
+            description: operation.moduleDescription,
+        },
+    ]);
+    const resourceCommandId = commandSegments.slice(0, 2).join(' ');
+    if (commandSegments[1]) {
+        entries.push([
+            resourceCommandId,
+            {
+                summary: operation.resourceDescription || operation.resourceDisplayName,
+                description: operation.resourceDescription,
+            },
+        ]);
+    }
+    return entries;
+}
+const registry = {
+    ...(await loadCommandsFromDirectory()),
+};
+const envName = readEnvName(process.argv.slice(2)) ?? (await getCurrentEnvName());
+const env = await getEnv(envName);
+const runtime = loadRuntimeSync(env?.runtime?.version);
+for (const operation of runtime?.commands ?? []) {
+    const commandSegments = operation.commandId.split(' ');
+    const commandKey = commandSegments.join(':');
+    registry[`api:${commandKey}`] = createRuntimeCommand(operation, runtime?.version);
+    for (const [topicCommandId, metadata] of getRuntimeTopicEntries(operation)) {
+        const topicKey = `api:${topicCommandId.split(' ').join(':')}`;
+        if (!registry[topicKey]) {
+            registry[topicKey] = createRuntimeIndexCommand(`api ${topicCommandId}`, metadata);
+        }
+    }
+}
+export default registry;

package/dist/help/runtime-help.js

@@ -0,0 +1,23 @@
+/**
+ * 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 { Help } from '@oclif/core';
+export function isTopicIndexCommand(commandId, topics) {
+    if (!commandId) {
+        return false;
+    }
+    return topics.some((topic) => topic.name.startsWith(`${commandId}:`));
+}
+export default class RuntimeHelp extends Help {
+    get sortedCommands() {
+        return super.sortedCommands.filter((command) => !isTopicIndexCommand(command.id, this.config.topics));
+    }
+    get sortedTopics() {
+        return super.sortedTopics.filter((topic) => !topic.hidden);
+    }
+}