@nocobase/cli 2.1.0-beta.15 → 2.1.0-beta.16

package/dist/generated/command-registry.js

@@ -0,0 +1,133 @@
+/**
+ * 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) {
+    return class RuntimeCommand extends GeneratedApiCommand {
+        static summary = operation.summary;
+        static description = operation.description;
+        static examples = operation.examples;
+        static flags = createGeneratedFlags(operation);
+        static operation = operation;
+    };
+}
+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);
+    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,20 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { 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));
+    }
+}

package/dist/lib/api-client.js

@@ -0,0 +1,243 @@
+/**
+ * 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 { promises as fs } from 'node:fs';
+import { resolveServerRequestTarget } from './env-auth.js';
+const CLI_REQUEST_SOURCE_HEADER = 'x-request-source';
+const CLI_REQUEST_SOURCE_VALUE = 'cli';
+function stripUtf8Bom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+function parseJsonInput(raw, flagName) {
+    const content = stripUtf8Bom(raw);
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON for --${flagName}: ${error?.message ?? 'parse failed'}`);
+    }
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+async function parseResponse(response) {
+    const text = await response.text();
+    let data = text;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch (error) {
+            data = text;
+        }
+    }
+    return {
+        ok: response.ok,
+        status: response.status,
+        data,
+    };
+}
+function parseScalarValue(value, type) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (type === 'boolean') {
+        return value;
+    }
+    if (type === 'integer' || type === 'number') {
+        return Number(value);
+    }
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch (error) {
+            return value;
+        }
+    }
+    return value;
+}
+function hasParameterValue(flags, parameter) {
+    const value = flags[parameter.flagName];
+    if (parameter.type === 'boolean') {
+        return value !== undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+function listProvidedBodyFlags(flags, parameters) {
+    return parameters
+        .filter((parameter) => hasParameterValue(flags, parameter))
+        .map((parameter) => `--${parameter.flagName}`);
+}
+function parseBodyFieldValue(rawValue, parameter) {
+    if (rawValue === undefined) {
+        return undefined;
+    }
+    if (parameter.isArray && !parameter.jsonEncoded) {
+        return Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined;
+    }
+    if (parameter.jsonEncoded || parameter.type === 'object' || parameter.type === 'array') {
+        if (typeof rawValue !== 'string') {
+            return rawValue;
+        }
+        const parsed = parseJsonInput(rawValue, parameter.flagName);
+        if (parameter.type === 'array' && !Array.isArray(parsed)) {
+            throw new Error(`--${parameter.flagName} must be a JSON array`);
+        }
+        if (parameter.type === 'object' && (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object')) {
+            throw new Error(`--${parameter.flagName} must be a JSON object`);
+        }
+        return parsed;
+    }
+    return parseScalarValue(rawValue, parameter.type);
+}
+export async function parseBody(flags, operation) {
+    const inlineBody = flags.body;
+    const bodyFile = flags['body-file'];
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const hasBodyFlags = bodyParameters.some((parameter) => hasParameterValue(flags, parameter));
+    if ((inlineBody || bodyFile) && hasBodyFlags) {
+        const providedBodyFlags = listProvidedBodyFlags(flags, bodyParameters);
+        const rawBodyInput = inlineBody ? '--body' : '--body-file';
+        throw new Error(`Conflicting request body inputs: received ${rawBodyInput} together with body field flags (${providedBodyFlags.join(', ')}). Use either body field flags or --body/--body-file.`);
+    }
+    if (inlineBody) {
+        return parseJsonInput(inlineBody, 'body');
+    }
+    if (bodyFile) {
+        return fs.readFile(bodyFile, 'utf8').then((content) => parseJsonInput(content, 'body-file'));
+    }
+    if (!bodyParameters.length) {
+        return undefined;
+    }
+    const body = {};
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const value = parseBodyFieldValue(rawValue, parameter);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        body[parameter.name] = value;
+    }
+    if (Object.keys(body).length > 0) {
+        return body;
+    }
+    if (operation.hasBody && operation.bodyRequired) {
+        throw new Error('Missing request body. Use body field flags or --body/--body-file.');
+    }
+    return undefined;
+}
+export async function executeApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    const query = new URLSearchParams();
+    let requestPath = options.operation.pathTemplate;
+    for (const parameter of options.operation.parameters) {
+        if (parameter.in === 'body') {
+            continue;
+        }
+        const rawValue = options.flags[parameter.flagName];
+        const value = parameter.isArray
+            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
+            : parseScalarValue(rawValue, parameter.type);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required parameter --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (parameter.in === 'path') {
+            requestPath = requestPath.replace(`{${parameter.name}}`, encodeURIComponent(String(value)));
+            continue;
+        }
+        if (parameter.in === 'query') {
+            if (Array.isArray(value)) {
+                value.forEach((item) => query.append(parameter.name, String(parseScalarValue(item, parameter.type))));
+            }
+            else if (typeof value === 'object') {
+                query.set(parameter.name, JSON.stringify(value));
+            }
+            else {
+                query.set(parameter.name, String(value));
+            }
+            continue;
+        }
+        if (parameter.in === 'header') {
+            headers.set(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+            continue;
+        }
+    }
+    const body = await parseBody(options.flags, options.operation);
+    if (body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${requestPath}`);
+    query.forEach((value, key) => url.searchParams.append(key, value));
+    const response = await fetch(url, {
+        method: options.operation.method.toUpperCase(),
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return parseResponse(response);
+}
+export async function executeRawApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    headers.set(CLI_REQUEST_SOURCE_HEADER, CLI_REQUEST_SOURCE_VALUE);
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+        if (value === undefined || value === null || value === '') {
+            continue;
+        }
+        headers.set(name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    if (options.body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${options.path}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(key, typeof item === 'object' ? JSON.stringify(item) : String(item));
+            }
+            continue;
+        }
+        url.searchParams.set(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    const response = await fetch(url, {
+        method: options.method.toUpperCase(),
+        headers,
+        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+    });
+    return parseResponse(response);
+}

package/dist/lib/app-runtime.js

@@ -0,0 +1,142 @@
+/**
+ * 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 path from 'node:path';
+import { getEnv, loadAuthConfig } from './auth-store.js';
+import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
+const DOCKER_APP_WORKDIR = '/app/nocobase';
+function sanitizeDockerResourceName(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || 'nocobase';
+}
+export function defaultWorkspaceName(cwd = process.cwd()) {
+    return sanitizeDockerResourceName(`nb-${path.basename(cwd)}`);
+}
+export function buildDockerAppContainerName(envName, workspaceName) {
+    const workspace = workspaceName?.trim() || defaultWorkspaceName();
+    return sanitizeDockerResourceName(`${workspace}-${envName}-app`);
+}
+export function buildDockerDbContainerName(envName, dbDialect, workspaceName) {
+    const workspace = workspaceName?.trim() || defaultWorkspaceName();
+    const dialect = dbDialect.trim() || 'postgres';
+    return sanitizeDockerResourceName(`${workspace}-${envName}-${dialect}`);
+}
+function normalizeEnvSource(env) {
+    const source = String(env.config.source ?? '').trim();
+    if (source === 'docker' || source === 'npm' || source === 'git') {
+        return source;
+    }
+    if (env.config.appRootPath) {
+        return 'local';
+    }
+    return undefined;
+}
+export async function resolveManagedAppRuntime(envName) {
+    const config = await loadAuthConfig();
+    const env = await getEnv(envName, { config });
+    if (!env) {
+        return undefined;
+    }
+    const resolvedName = env.name || envName?.trim() || config.currentEnv || 'default';
+    const source = normalizeEnvSource(env);
+    const workspaceName = config.name?.trim() || defaultWorkspaceName();
+    if (source === 'docker') {
+        return {
+            kind: 'docker',
+            env,
+            envName: resolvedName,
+            source,
+            workspaceName,
+            containerName: buildDockerAppContainerName(resolvedName, workspaceName),
+        };
+    }
+    if (env.config.appRootPath) {
+        return {
+            kind: 'local',
+            env,
+            envName: resolvedName,
+            source: source === 'git' ? 'git' : source === 'npm' ? 'npm' : 'local',
+            projectRoot: env.appRootPath,
+            workspaceName,
+        };
+    }
+    return {
+        kind: 'remote',
+        env,
+        envName: resolvedName,
+        source,
+    };
+}
+export function formatMissingManagedAppEnvMessage(envName) {
+    const requested = String(envName ?? '').trim();
+    if (requested) {
+        return [
+            `Env "${requested}" is not configured in this workspace.`,
+            `If you want to create a new NocoBase AI environment, run \`nb init --env ${requested}\` first.`,
+        ].join('\n');
+    }
+    return 'No NocoBase env is configured yet. Run `nb init` to create one first.';
+}
+export async function runLocalNocoBaseCommand(runtime, args, options) {
+    await runNocoBaseCommand(args, {
+        cwd: runtime.projectRoot,
+        env: runtime.env.envVars,
+        stdio: options?.stdio,
+    });
+}
+export async function dockerContainerExists(containerName) {
+    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
+}
+export async function dockerContainerIsRunning(containerName) {
+    try {
+        const output = await commandOutput('docker', ['inspect', '--format', '{{.State.Running}}', containerName], { errorName: 'docker inspect' });
+        return output.trim() === 'true';
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export async function startDockerContainer(containerName, options) {
+    const exists = await dockerContainerExists(containerName);
+    if (!exists) {
+        throw new Error(`Docker app container "${containerName}" does not exist.`);
+    }
+    if (await dockerContainerIsRunning(containerName)) {
+        return 'already-running';
+    }
+    await run('docker', ['start', containerName], {
+        errorName: 'docker start',
+        stdio: options?.stdio,
+    });
+    return 'started';
+}
+export async function stopDockerContainer(containerName, options) {
+    const exists = await dockerContainerExists(containerName);
+    if (!exists) {
+        throw new Error(`Docker app container "${containerName}" does not exist.`);
+    }
+    if (!(await dockerContainerIsRunning(containerName))) {
+        return 'already-stopped';
+    }
+    await run('docker', ['stop', containerName], {
+        errorName: 'docker stop',
+        stdio: options?.stdio,
+    });
+    return 'stopped';
+}
+export async function runDockerNocoBaseCommand(containerName, args) {
+    await startDockerContainer(containerName);
+    await run('docker', ['exec', '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
+        errorName: 'docker exec',
+    });
+}