@nocobase/cli 2.1.0-alpha.4 → 2.1.0-alpha.40

package/dist/lib/prompt-catalog-terminal.js

@@ -0,0 +1,375 @@
+/**
+ * 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 pc from 'picocolors';
+import { exit, stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { createCliTranslate } from "./cli-locale.js";
+import { confirm, select, input, password } from "./inquirer.js";
+import { createPromptCatalogHooks, hasIvKey, isBlankText, isPromptBlockSkipped, mergedBoolean, mergedInteger, mergedPassword, mergedSelect, mergedText, resolvePromptCatalogLocale, resolvePromptText, runPromptFieldValidate, selectOptionValues, tryApplyPreset, } from "./prompt-catalog-core.js";
+function adaptInquirerValidate(validate) {
+    if (!validate) {
+        return undefined;
+    }
+    return async (value) => {
+        const result = await validate(value);
+        return result === undefined ? true : result;
+    };
+}
+function inquirerSelectOptions(options, locale) {
+    return options.map((o) => typeof o === 'string'
+        ? { value: o, label: o }
+        : {
+            value: o.value,
+            label: resolvePromptText(o.label, locale, o.value),
+            ...(o.hint !== undefined ? { hint: resolvePromptText(o.hint, locale) } : {}),
+            ...(o.disabled !== undefined ? { disabled: o.disabled } : {}),
+        });
+}
+function createInquirerRenderer() {
+    return {
+        intro(message) {
+            console.log(message);
+        },
+        outro(message) {
+            console.log(message);
+        },
+        error(message) {
+            console.error(pc.red(`✖ ${message}`));
+        },
+        text(options) {
+            return input({
+                message: options.message,
+                default: options.initialValue,
+                placeholder: options.placeholder,
+                validate: adaptInquirerValidate(options.validate),
+            });
+        },
+        confirm(options) {
+            return confirm({
+                message: options.message,
+                default: options.initialValue,
+            });
+        },
+        select(options) {
+            return select({
+                message: options.message,
+                choices: options.options.map((option) => ({
+                    value: option.value,
+                    name: option.label,
+                    ...(option.hint !== undefined ? { description: option.hint } : {}),
+                    ...(option.disabled !== undefined ? { disabled: option.disabled } : {}),
+                })),
+                default: options.initialValue,
+            });
+        },
+        password(options) {
+            return password({
+                message: options.message,
+                mask: options.mask ?? '•',
+                validate: adaptInquirerValidate(options.validate),
+            });
+        },
+        isCancel(error) {
+            return error instanceof Error && error.name === 'ExitPromptError';
+        },
+    };
+}
+function defaultOnCancel(locale) {
+    void locale;
+    exit(0);
+}
+function defaultOnMissingNonInteractive(message) {
+    console.error(message);
+    exit(1);
+}
+function createTerminalHooks(locale, overrides) {
+    return createPromptCatalogHooks(locale, overrides, {
+        onCancel: () => defaultOnCancel(locale),
+        onMissingNonInteractive: defaultOnMissingNonInteractive,
+    });
+}
+async function callPrompt(run, renderer, hooks) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (renderer.isCancel(error)) {
+            hooks.onCancel();
+        }
+        throw error;
+    }
+}
+export async function runPromptCatalog(catalog, options = {}) {
+    const locale = resolvePromptCatalogLocale(options.locale);
+    const t = createCliTranslate(locale);
+    const promptIv = options.initialValues ?? {};
+    const yesIv = options.yesInitialValues ?? {};
+    const resolveIv = options.yes ? { ...promptIv, ...yesIv } : promptIv;
+    const useYesInitial = Boolean(options.yes);
+    const hooks = createTerminalHooks(locale, options.hooks);
+    const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !options.yes);
+    const preset = options.values ?? {};
+    const out = {};
+    const renderer = createInquirerRenderer();
+    for (const [key, def] of Object.entries(catalog)) {
+        if (isPromptBlockSkipped(def, out)) {
+            continue;
+        }
+        if (tryApplyPreset(key, def, preset, out, hooks, locale)) {
+            const errV = await runPromptFieldValidate(def, out[key], out);
+            if (errV) {
+                hooks.onMissingNonInteractive(errV);
+            }
+            continue;
+        }
+        if (def.type === 'intro') {
+            renderer.intro(resolvePromptText(def.title, locale));
+            continue;
+        }
+        if (def.type === 'outro') {
+            renderer.outro(resolvePromptText(def.message, locale));
+            continue;
+        }
+        if (def.type === 'run') {
+            await def.run(out, options.command);
+            continue;
+        }
+        if (def.type === 'text') {
+            const message = resolvePromptText(def.message, locale, key);
+            const placeholder = def.placeholder !== undefined
+                ? resolvePromptText(def.placeholder, locale)
+                : undefined;
+            if (!interactive) {
+                const merged = mergedText(key, def, resolveIv, useYesInitial, out);
+                if (def.required && isBlankText(merged)) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.textRequired', { key }));
+                }
+                out[key] = merged;
+                const errT = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errT) {
+                    hooks.onMissingNonInteractive(errT);
+                }
+                continue;
+            }
+            const merged = mergedText(key, def, promptIv, false, out);
+            const raw = await callPrompt(() => renderer.text({
+                message,
+                initialValue: merged,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: (value) => {
+                    if (def.required && isBlankText(value)) {
+                        return t('promptCatalog.common.required');
+                    }
+                    if (!def.validate) {
+                        return undefined;
+                    }
+                    const currentValue = typeof value === 'string' ? value : String(value ?? '');
+                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    return result;
+                },
+            }), renderer, hooks);
+            out[key] = typeof raw === 'string' ? raw : merged;
+            continue;
+        }
+        if (def.type === 'boolean') {
+            const message = resolvePromptText(def.message, locale, key);
+            if (!interactive) {
+                const b = mergedBoolean(key, def, resolveIv, useYesInitial);
+                out[key] = b;
+                const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                if (errB) {
+                    hooks.onMissingNonInteractive(errB);
+                }
+                continue;
+            }
+            const merged = mergedBoolean(key, def, promptIv, false);
+            if (def.validate) {
+                for (;;) {
+                    const raw = await callPrompt(() => renderer.confirm({ message, initialValue: merged }), renderer, hooks);
+                    const b = Boolean(raw);
+                    const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                    if (errB) {
+                        renderer.error(errB);
+                        continue;
+                    }
+                    out[key] = b;
+                    break;
+                }
+                continue;
+            }
+            const raw = await callPrompt(() => renderer.confirm({ message, initialValue: merged }), renderer, hooks);
+            out[key] = Boolean(raw);
+            continue;
+        }
+        if (def.type === 'select') {
+            const message = resolvePromptText(def.message, locale, key);
+            const valueList = selectOptionValues(def.options);
+            if (def.required && def.options.length === 0) {
+                hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.selectRequiredNoOptions', { key }));
+            }
+            if (!interactive) {
+                const merged = mergedSelect(key, def, resolveIv, useYesInitial);
+                if (merged === undefined || !valueList.includes(merged)) {
+                    const bad = hasIvKey(resolveIv, key) && !valueList.includes(String(resolveIv[key]))
+                        ? String(resolveIv[key])
+                        : hasIvKey(promptIv, key) && !valueList.includes(String(promptIv[key]))
+                            ? String(promptIv[key])
+                            : undefined;
+                    hooks.onMissingNonInteractive(bad !== undefined
+                        ? t('promptCatalog.nonInteractive.selectInvalidValue', { key, value: bad, options: valueList.join(', ') })
+                        : t('promptCatalog.nonInteractive.selectMissingDefault', { key }));
+                }
+                out[key] = merged;
+                const errS = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errS) {
+                    hooks.onMissingNonInteractive(errS);
+                }
+                continue;
+            }
+            const merged = mergedSelect(key, def, promptIv, false);
+            const uiInitial = merged ??
+                (def.initialValue && valueList.includes(def.initialValue) ? def.initialValue : undefined) ??
+                valueList[0];
+            if (uiInitial === undefined || !valueList.includes(uiInitial)) {
+                const hint = def.required
+                    ? t('promptCatalog.nonInteractive.selectRequiredInteractive', { key })
+                    : t('promptCatalog.nonInteractive.selectMissingInteractiveDefault', { key });
+                hooks.onMissingNonInteractive(hint);
+            }
+            if (def.validate) {
+                for (;;) {
+                    const raw = await callPrompt(() => renderer.select({
+                        message,
+                        options: inquirerSelectOptions(def.options, locale),
+                        initialValue: uiInitial,
+                    }), renderer, hooks);
+                    const picked = raw;
+                    const errS = await runPromptFieldValidate(def, picked, { ...out, [key]: picked });
+                    if (errS) {
+                        renderer.error(errS);
+                        continue;
+                    }
+                    out[key] = picked;
+                    break;
+                }
+                continue;
+            }
+            const raw = await callPrompt(() => renderer.select({
+                message,
+                options: inquirerSelectOptions(def.options, locale),
+                initialValue: uiInitial,
+            }), renderer, hooks);
+            out[key] = raw;
+            continue;
+        }
+        if (def.type === 'password') {
+            const message = resolvePromptText(def.message, locale, key);
+            if (!interactive) {
+                const merged = mergedPassword(key, def, resolveIv, useYesInitial);
+                if (merged === undefined) {
+                    if (def.required) {
+                        hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequired', { key }));
+                    }
+                    out[key] = '';
+                    const errPE = await runPromptFieldValidate(def, '', { ...out, [key]: '' });
+                    if (errPE) {
+                        hooks.onMissingNonInteractive(errPE);
+                    }
+                    continue;
+                }
+                if (def.required && isBlankText(merged)) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequiredNonEmpty', { key }));
+                }
+                out[key] = merged;
+                const errP = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errP) {
+                    hooks.onMissingNonInteractive(errP);
+                }
+                continue;
+            }
+            const raw = await callPrompt(() => renderer.password({
+                message,
+                mask: def.mask,
+                validate: (value) => {
+                    if (def.required && isBlankText(value)) {
+                        return t('promptCatalog.common.required');
+                    }
+                    if (!def.validate) {
+                        return undefined;
+                    }
+                    const currentValue = typeof value === 'string' ? value : String(value ?? '');
+                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    return result;
+                },
+            }), renderer, hooks);
+            out[key] = typeof raw === 'string' ? raw : '';
+            continue;
+        }
+        if (def.type === 'integer') {
+            const message = resolvePromptText(def.message, locale, key);
+            const placeholder = def.placeholder !== undefined
+                ? resolvePromptText(def.placeholder, locale)
+                : undefined;
+            if (!interactive) {
+                const merged = mergedInteger(key, def, resolveIv, useYesInitial);
+                if (merged === undefined) {
+                    if (def.required) {
+                        hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.integerRequired', { key }));
+                    }
+                    const z = def.initialValue ?? 0;
+                    out[key] = z;
+                    const errI = await runPromptFieldValidate(def, z, { ...out, [key]: z });
+                    if (errI) {
+                        hooks.onMissingNonInteractive(errI);
+                    }
+                    continue;
+                }
+                out[key] = merged;
+                const errI2 = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                if (errI2) {
+                    hooks.onMissingNonInteractive(errI2);
+                }
+                continue;
+            }
+            const merged = mergedInteger(key, def, promptIv, false);
+            const lineDefault = merged !== undefined ? String(merged) : String(def.initialValue ?? 0);
+            const raw = await callPrompt(() => renderer.text({
+                message,
+                initialValue: lineDefault,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: async (value) => {
+                    const trimmed = value.trim();
+                    if (trimmed === '') {
+                        if (def.required) {
+                            return t('promptCatalog.common.required');
+                        }
+                        if (def.validate) {
+                            const z = def.initialValue ?? 0;
+                            return runPromptFieldValidate(def, z, { ...out, [key]: z });
+                        }
+                        return undefined;
+                    }
+                    if (!/^-?\\d+$/.test(trimmed)) {
+                        return t('promptCatalog.common.mustBeInteger');
+                    }
+                    if (!def.validate) {
+                        return undefined;
+                    }
+                    const n = Number.parseInt(trimmed, 10);
+                    return runPromptFieldValidate(def, n, { ...out, [key]: n });
+                },
+            }), renderer, hooks);
+            if (typeof raw === 'string' && raw.trim() === '' && !def.required) {
+                out[key] = def.initialValue ?? 0;
+                continue;
+            }
+            out[key] = Number.parseInt(String(raw).trim(), 10);
+        }
+    }
+    return out;
+}

package/{src/index.js → dist/lib/prompt-catalog.js}

@@ -6,9 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-
-const util = require('./util');
-
-module.exports = {
-  ...util,
-};
+export * from "./prompt-catalog-core.js";
+export { runPromptCatalog } from "./prompt-catalog-terminal.js";

package/dist/lib/prompt-validators.js

@@ -0,0 +1,240 @@
+/**
+ * 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 { spawn } from 'node:child_process';
+import net from 'node:net';
+import { translateCli } from "./cli-locale.js";
+const API_BASE_URL_EXAMPLE = 'http://localhost:13000/api';
+const ENV_KEY_PATTERN = /^[A-Za-z0-9]+$/;
+const TCP_PORT_EXAMPLE = '13000';
+const API_BASE_URL_REQUEST_TIMEOUT_MS = 5_000;
+function buildHealthCheckUrl(apiBaseUrl) {
+    return `${apiBaseUrl.replace(/\/+$/, '')}/__health_check`;
+}
+function isMaintainingHealthCheckResponse(status, body) {
+    if (status !== 503 || !body || typeof body !== 'object') {
+        return false;
+    }
+    const error = body.error;
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const record = error;
+    return record.status === 503 && record.maintaining === true && record.code === 'APP_COMMANDING';
+}
+export async function validateApiBaseUrl(value) {
+    const raw = String(value ?? '').trim();
+    if (raw === '') {
+        return undefined;
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return translateCli('validators.apiBaseUrl.invalid', { example: API_BASE_URL_EXAMPLE });
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return translateCli('validators.apiBaseUrl.invalidProtocol', { example: API_BASE_URL_EXAMPLE });
+    }
+    if (/\/__health_check\/?$/i.test(url.pathname)) {
+        return translateCli('validators.apiBaseUrl.healthCheckPathNotAllowed');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, API_BASE_URL_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(buildHealthCheckUrl(url.toString()), {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        if (response.status === 200) {
+            return undefined;
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            body = undefined;
+        }
+        if (isMaintainingHealthCheckResponse(response.status, body)) {
+            return translateCli('validators.apiBaseUrl.maintaining');
+        }
+        return translateCli('validators.apiBaseUrl.healthCheckFailed', { status: response.status });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return translateCli('validators.apiBaseUrl.timeout', {
+                seconds: Math.ceil(API_BASE_URL_REQUEST_TIMEOUT_MS / 1000),
+            });
+        }
+        return translateCli('validators.apiBaseUrl.unreachable', {
+            details: error instanceof Error ? error.message : String(error),
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    return undefined;
+}
+export function validateEnvKey(value) {
+    const raw = String(value ?? '').trim();
+    if (raw === '') {
+        return undefined;
+    }
+    if (!ENV_KEY_PATTERN.test(raw)) {
+        return translateCli('validators.envKey.invalid');
+    }
+    return undefined;
+}
+function parseTcpPort(value) {
+    const raw = String(value ?? '').trim();
+    if (raw === '') {
+        return undefined;
+    }
+    if (!/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return undefined;
+    }
+    return port;
+}
+export function validateTcpPort(value) {
+    const raw = String(value ?? '').trim();
+    if (raw === '') {
+        return undefined;
+    }
+    const port = parseTcpPort(raw);
+    if (port === undefined) {
+        return translateCli('validators.tcpPort.invalid', { example: TCP_PORT_EXAMPLE });
+    }
+    return undefined;
+}
+async function canListenOnTcpPort(port) {
+    return await new Promise((resolve) => {
+        const server = net.createServer();
+        const resolveAndCleanup = (result) => {
+            server.removeAllListeners();
+            if (server.listening) {
+                server.close(() => resolve(result));
+            }
+            else {
+                resolve(result);
+            }
+        };
+        server.once('error', () => {
+            resolveAndCleanup(false);
+        });
+        server.once('listening', () => {
+            resolveAndCleanup(true);
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+function parseDockerPublishedTcpPorts(output) {
+    const ports = new Set();
+    for (const line of output.split(/\r?\n/)) {
+        for (const segment of line.split(',')) {
+            const match = segment.trim().match(/^(?:.+:)?(\d+)->\d+(?:-\d+)?\/tcp$/i);
+            if (!match) {
+                continue;
+            }
+            const port = Number.parseInt(match[1], 10);
+            if (Number.isInteger(port) && port >= 1 && port <= 65535) {
+                ports.add(port);
+            }
+        }
+    }
+    return ports;
+}
+async function getDockerPublishedTcpPorts() {
+    return await new Promise((resolve) => {
+        let settled = false;
+        const stdoutChunks = [];
+        const finish = (ports) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(ports);
+        };
+        const child = spawn('docker', ['ps', '--format', '{{.Ports}}']);
+        child.stdout?.on('data', (chunk) => {
+            stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+        });
+        child.once('error', () => {
+            finish(new Set());
+        });
+        child.once('close', (code) => {
+            if (code !== 0) {
+                finish(new Set());
+                return;
+            }
+            finish(parseDockerPublishedTcpPorts(Buffer.concat(stdoutChunks).toString('utf8')));
+        });
+    });
+}
+async function allocateAvailableTcpPort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = address && typeof address === 'object'
+                ? address.port
+                : undefined;
+            if (!port) {
+                server.close(() => {
+                    reject(new Error(translateCli('validators.tcpPort.allocateFailed')));
+                });
+                return;
+            }
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(String(port));
+            });
+        });
+    });
+}
+export async function findAvailableTcpPort() {
+    const dockerPorts = await getDockerPublishedTcpPorts();
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        const candidate = await allocateAvailableTcpPort();
+        if (!dockerPorts.has(Number.parseInt(candidate, 10))) {
+            return candidate;
+        }
+    }
+    throw new Error(translateCli('validators.tcpPort.allocateNotDockerPublished'));
+}
+export async function validateAvailableTcpPort(value) {
+    const raw = String(value ?? '').trim();
+    if (raw === '') {
+        return undefined;
+    }
+    const formatError = validateTcpPort(raw);
+    if (formatError) {
+        return formatError;
+    }
+    const port = parseTcpPort(raw);
+    const dockerPorts = await getDockerPublishedTcpPorts();
+    if (dockerPorts.has(port)) {
+        return translateCli('validators.tcpPort.alreadyInUseByDocker', { port });
+    }
+    const available = await canListenOnTcpPort(port);
+    if (!available) {
+        return translateCli('validators.tcpPort.alreadyInUse', { port });
+    }
+    return undefined;
+}