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

package/dist/lib/cli-locale.js

@@ -9,12 +9,13 @@
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { resolveCliHomeDir } from './cli-home.js';
 export const SUPPORTED_CLI_LOCALES = ['en-US', 'zh-CN'];
 export const CLI_LOCALE_FLAG_OPTIONS = [...SUPPORTED_CLI_LOCALES];
 export const CLI_LOCALE_FLAG_DESCRIPTION = 'Language for CLI prompts and the local setup UI.';
 const DEFAULT_CLI_LOCALE = 'en-US';
 const localeCache = {};
-function normalizeCliLocale(value) {
+export function normalizeCliLocale(value) {
     const raw = String(value ?? '').trim();
     if (!raw) {
         return undefined;
@@ -28,6 +29,17 @@ function normalizeCliLocale(value) {
     }
     return undefined;
 }
+function readConfiguredCliLocale() {
+    try {
+        const configPath = path.join(resolveCliHomeDir(), 'config.json');
+        const content = readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(content);
+        return normalizeCliLocale(parsed.settings?.locale === undefined ? undefined : String(parsed.settings.locale));
+    }
+    catch {
+        return undefined;
+    }
+}
 function loadLocaleMessages(locale) {
     if (localeCache[locale]) {
         return localeCache[locale];
@@ -65,9 +77,11 @@ function interpolateTemplate(template, values) {
         return value === undefined || value === null ? '' : String(value);
     });
 }
-export function detectCliLocale() {
+export function detectCliLocale(configuredLocale) {
+    const resolvedConfiguredLocale = configuredLocale ?? readConfiguredCliLocale();
     const candidates = [
         process.env.NB_LOCALE,
+        resolvedConfiguredLocale,
         process.env.LC_ALL,
         process.env.LC_MESSAGES,
         process.env.LANG,
@@ -81,8 +95,8 @@ export function detectCliLocale() {
     }
     return DEFAULT_CLI_LOCALE;
 }
-export function resolveCliLocale(preferred) {
-    return normalizeCliLocale(preferred) ?? detectCliLocale();
+export function resolveCliLocale(preferred, options) {
+    return normalizeCliLocale(preferred) ?? detectCliLocale(options?.configuredLocale);
 }
 export function applyCliLocale(preferred) {
     const locale = resolveCliLocale(preferred);
@@ -111,9 +125,7 @@ export function localeText(key, values, fallback) {
     };
 }
 export function isLocalizedTextDef(value) {
-    return Boolean(value
-        && typeof value === 'object'
-        && typeof value.key === 'string');
+    return Boolean(value && typeof value === 'object' && typeof value.key === 'string');
 }
 export function resolveLocalizedText(text, options) {
     if (text === undefined) {

package/dist/lib/db-connection-check.js

@@ -10,6 +10,7 @@ import { translateCli } from "./cli-locale.js";
 import { validateTcpPort } from "./prompt-validators.js";
 const DB_CONNECTION_TIMEOUT_MS = 5_000;
 const externalDbValidationCache = new Map();
+const mysqlLowerCaseTableNamesCache = new Map();
 function trimPromptValue(value) {
     return String(value ?? '').trim();
 }
@@ -117,6 +118,36 @@ async function checkMysqlFamilyConnection(config) {
         await Promise.resolve(connection.end()).catch(() => undefined);
     }
 }
+async function readMysqlFamilyLowerCaseTableNames(config) {
+    const { default: mysql } = await import('mysql2/promise');
+    const connection = await mysql.createConnection({
+        host: config.host,
+        port: config.port,
+        user: config.user,
+        password: config.password,
+        database: config.database,
+        connectTimeout: DB_CONNECTION_TIMEOUT_MS,
+    });
+    try {
+        const [rows] = await connection.query(`SHOW VARIABLES LIKE 'lower_case_table_names'`);
+        if (!Array.isArray(rows)) {
+            return undefined;
+        }
+        for (const row of rows) {
+            if (!row || typeof row !== 'object') {
+                continue;
+            }
+            const value = String(row.Value ?? '').trim();
+            if (value === '0' || value === '1' || value === '2') {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    finally {
+        await Promise.resolve(connection.end()).catch(() => undefined);
+    }
+}
 async function performExternalDbConnectionCheck(config) {
     try {
         switch (config.dialect) {
@@ -146,6 +177,19 @@ export async function checkExternalDbConnection(config) {
     externalDbValidationCache.set(cacheKey, pending);
     return await pending;
 }
+async function readMysqlLowerCaseTableNamesMode(config) {
+    if (config.dialect !== 'mysql' && config.dialect !== 'mariadb') {
+        return undefined;
+    }
+    const cacheKey = buildValidationCacheKey(config);
+    const cached = mysqlLowerCaseTableNamesCache.get(cacheKey);
+    if (cached) {
+        return await cached;
+    }
+    const pending = readMysqlFamilyLowerCaseTableNames(config);
+    mysqlLowerCaseTableNamesCache.set(cacheKey, pending);
+    return await pending;
+}
 export async function validateExternalDbConfig(values) {
     const config = readExternalDbConnectionConfig(values);
     if (!config) {
@@ -153,6 +197,23 @@ export async function validateExternalDbConfig(values) {
     }
     return await checkExternalDbConnection(config);
 }
+export async function validateMysqlLowerCaseTableNamesCompatibility(values) {
+    const config = readExternalDbConnectionConfig(values);
+    if (!config || (config.dialect !== 'mysql' && config.dialect !== 'mariadb')) {
+        return undefined;
+    }
+    try {
+        const mode = await readMysqlLowerCaseTableNamesMode(config);
+        if (mode === '1' && values.dbUnderscored !== true) {
+            return translateCli('validators.dbConnection.lowerCaseTableNamesRequiresUnderscored');
+        }
+        return undefined;
+    }
+    catch (error) {
+        return formatDbConnectionError(config, error);
+    }
+}
 export function clearExternalDbValidationCache() {
     externalDbValidationCache.clear();
+    mysqlLowerCaseTableNamesCache.clear();
 }

package/dist/lib/docker-log-stream.js

@@ -0,0 +1,45 @@
+/**
+ * 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';
+const DEFAULT_DOCKER_LOG_TAIL = 50;
+export function startDockerLogFollower(containerName, options) {
+    const tail = Math.max(0, options?.tail ?? DEFAULT_DOCKER_LOG_TAIL);
+    const child = spawn('docker', ['logs', '--tail', String(tail), '--follow', containerName], {
+        stdio: 'inherit',
+    });
+    let settled = false;
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    const settle = () => {
+        if (!settled) {
+            settled = true;
+            resolveClosed();
+        }
+    };
+    child.once('error', settle);
+    child.once('close', settle);
+    return {
+        stop: async () => {
+            if (settled) {
+                return;
+            }
+            try {
+                if (!child.kill()) {
+                    settle();
+                }
+            }
+            catch {
+                settle();
+            }
+            await closed;
+        },
+    };
+}

package/dist/lib/env-auth.js

@@ -34,6 +34,28 @@ export function getOauthResource(issuerOrBaseUrl) {
 export function getDefaultOauthScope() {
     return DEFAULT_OAUTH_SCOPE;
 }
+function formatApiAuthError(prefix, data, fallbackStatus) {
+    if (typeof data === 'string' && data.trim()) {
+        return `${prefix}: ${data}`;
+    }
+    const errors = Array.isArray(data?.errors) ? data.errors : [];
+    if (errors.length > 0) {
+        const details = errors
+            .map((entry) => {
+            const code = entry?.code ? `[${entry.code}] ` : '';
+            return `${code}${entry?.message ?? 'Authentication failed.'}`;
+        })
+            .join('; ');
+        return `${prefix}: ${details}`;
+    }
+    if (typeof data?.error?.message === 'string' && data.error.message.trim()) {
+        return `${prefix}: ${data.error.message}`;
+    }
+    if (typeof fallbackStatus === 'number') {
+        return `${prefix}: HTTP ${fallbackStatus}`;
+    }
+    return prefix;
+}
 export function isOauthAccessTokenExpired(auth, now = Date.now()) {
     if (!auth.expiresAt) {
         return false;
@@ -607,19 +629,19 @@ async function createLoopbackServer(state) {
         });
         let resolveWaiter;
         let rejectWaiter;
-        const waitForCode = () => new Promise((resolveCode, rejectCode) => {
+        const waitForCode = () => new Promise((resolve, reject) => {
             resolveWaiter = (code) => {
                 void close();
-                resolveCode(code);
+                resolve(code);
             };
             rejectWaiter = (error) => {
                 void close();
-                rejectCode(error);
+                reject(error);
             };
         });
         const close = async () => {
-            await new Promise((resolveClose) => {
-                server.close(() => resolveClose());
+            await new Promise((resolve) => {
+                server.close(() => resolve());
             });
         };
         server.on('error', (error) => {
@@ -750,7 +772,7 @@ export async function resolveAccessToken(options) {
     }
     const baseUrl = options.baseUrl ?? env.baseUrl;
     if (!baseUrl) {
-        throw new Error(`Env "${envName}" is missing a base URL. Run \`nb env add ${envName} --api-base-url <url>\`.`);
+        throw new Error(`Env "${envName}" is missing a base URL. Update it with \`nb env update ${envName} --api-base-url <url>\` first.`);
     }
     printVerbose(`Refreshing OAuth session for env "${envName}"`);
     return refreshOauthAccessToken({
@@ -771,10 +793,72 @@ export async function resolveServerRequestTarget(options) {
         scope: options.scope,
     });
     if (!baseUrl) {
-        throw new Error('Missing base URL. Use --api-base-url or configure one with `nb env add`.');
+        throw new Error([
+            env ? `Env "${envName}" is missing a base URL.` : `Env "${envName}" is not configured.`,
+            env
+                ? `Use --api-base-url or update env "${envName}" with \`nb env update ${envName} --api-base-url <url>\`.`
+                : `Use --api-base-url or run \`nb init --ui --env ${envName}\` first.`,
+        ].join('\n'));
     }
     return { baseUrl, token };
 }
+export async function authenticateEnvWithBasic(options) {
+    const envName = options.envName ?? (await getCurrentEnvName({ scope: options.scope }));
+    const env = await getEnv(envName, { scope: options.scope });
+    const baseUrl = env?.baseUrl;
+    if (!baseUrl) {
+        throw new Error([
+            env
+                ? `Environment "${envName}" does not have an API base URL yet.`
+                : `Environment "${envName}" has not been set up yet.`,
+            env
+                ? `Run \`nb env update ${envName} --api-base-url <url>\` to finish setting it up.`
+                : `Run \`nb init --ui --env ${envName}\` first.`,
+        ]
+            .filter(Boolean)
+            .join('\n'));
+    }
+    const loginUrl = `${normalizeBaseUrl(baseUrl)}/auth:signIn`;
+    let response;
+    try {
+        response = await fetchWithOauthRetry(loginUrl, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                'x-authenticator': 'basic',
+            },
+            body: JSON.stringify({
+                account: options.username,
+                password: options.password,
+            }),
+        }, {
+            operation: 'Signing in with basic credentials',
+            onRetry: (message) => updateTask(message),
+        });
+    }
+    catch (error) {
+        throw new Error(formatOauthFetchFailure('Failed to sign in with basic credentials.', {
+            envName,
+            baseUrl,
+            url: loginUrl,
+            rawMessage: error?.message,
+        }));
+    }
+    const data = await parseJsonResponse(response);
+    if (!response.ok) {
+        throw new Error(formatApiAuthError('Basic sign-in failed', data, response.status));
+    }
+    const token = typeof data?.data?.token === 'string' && data.data.token.trim()
+        ? data.data.token.trim()
+        : typeof data?.token === 'string' && data.token.trim()
+            ? data.token.trim()
+            : '';
+    if (!token) {
+        throw new Error('Basic sign-in succeeded but no token was returned.');
+    }
+    return token;
+}
 export async function authenticateEnvWithOauth(options) {
     const envName = options.envName ?? (await getCurrentEnvName({ scope: options.scope }));
     const env = await getEnv(envName, { scope: options.scope });
@@ -785,8 +869,8 @@ export async function authenticateEnvWithOauth(options) {
                 ? `Environment "${envName}" does not have an API base URL yet.`
                 : `Environment "${envName}" has not been set up yet.`,
             env
-                ? `Run \`nb env add ${envName} --api-base-url <url>\` to finish setting it up.`
-                : `Run \`nb env add ${envName}\` first.`,
+                ? `Run \`nb env update ${envName} --api-base-url <url>\` to finish setting it up.`
+                : `Run \`nb init --ui --env ${envName}\` first.`,
         ]
             .filter(Boolean)
             .join('\n'));
@@ -833,10 +917,13 @@ export async function authenticateEnvWithOauth(options) {
         const code = await new Promise((resolve, reject) => {
             const timeout = setTimeout(() => reject(new Error(`OAuth sign-in timed out after 5 minutes. Run \`nb env auth ${envName}\` to try again.`)), OAUTH_LOGIN_TIMEOUT_MS);
             timeout.unref?.();
-            callback.waitForCode().then((value) => {
+            callback
+                .waitForCode()
+                .then((value) => {
                 clearTimeout(timeout);
                 resolve(value);
-            }, (error) => {
+            })
+                .catch((error) => {
                 clearTimeout(timeout);
                 reject(error);
             });

package/dist/lib/env-config.js

@@ -19,6 +19,7 @@ const STRING_ENV_CONFIG_KEYS = [
     'appPort',
     'appKey',
     'timezone',
+    'authUsername',
     'dbDialect',
     'builtinDbImage',
     'dbHost',
@@ -83,11 +84,11 @@ export function buildStoredEnvConfig(input) {
         }
     }
     const authType = trimConfigValue(input.authType);
-    if (authType === 'token' || authType === 'oauth') {
+    if (authType === 'basic' || authType === 'token' || authType === 'oauth') {
         envConfig.authType = authType;
     }
     const accessToken = trimConfigValue(input.accessToken);
-    if (authType === 'token' && accessToken) {
+    if ((authType === 'basic' || authType === 'token') && accessToken) {
         envConfig.accessToken = accessToken;
     }
     return envConfig;

package/dist/lib/env-guard.js

@@ -43,7 +43,7 @@ export async function ensureCrossEnvConfirmed(options) {
     }
     const currentEnv = normalizeEnvName(await getCurrentEnvName());
     const interactiveTerminal = isInteractiveTerminal();
-    const bypassInteractivePrompt = interactiveTerminal && Boolean(options.yes);
+    const bypassInteractivePrompt = Boolean(options.yes);
     if (!currentEnv || currentEnv === requestedEnv || bypassInteractivePrompt) {
         return true;
     }

package/dist/lib/generated-command.js

@@ -16,8 +16,10 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { executeApiRequest } from './api-client.js';
+import { findApiCommandCompatViolation, formatApiCommandCompatViolation } from './api-command-compat.js';
 import { ensureCrossEnvConfirmed } from './env-guard.js';
 import { applyPostProcessor } from './post-processors.js';
+import { readInstalledManagedSkillsVersion } from './skills-manager.js';
 import { registerPostProcessors } from '../post-processors/index.js';
 function buildParameterFlag(parameter, options) {
     const hints = [parameter.in];
@@ -142,6 +144,7 @@ export function createGeneratedFlags(operation) {
 }
 export class GeneratedApiCommand extends Command {
     static operation;
+    static runtimeVersion;
     async run() {
         registerPostProcessors();
         const ctor = this.constructor;
@@ -154,7 +157,21 @@ export class GeneratedApiCommand extends Command {
         if (!confirmed) {
             return;
         }
+        const cliVersion = String(this.config.pjson.version ?? '').trim();
+        const skillsVersion = await readInstalledManagedSkillsVersion();
+        const compatViolation = findApiCommandCompatViolation({
+            packageJson: this.config.pjson,
+            commandId: ctor.operation.commandId,
+            cliVersion,
+            appVersion: ctor.runtimeVersion,
+            skillsVersion,
+        });
+        if (compatViolation) {
+            this.error(formatApiCommandCompatViolation(compatViolation));
+        }
         const response = await executeApiRequest({
+            cliVersion,
+            skillsVersion,
             envName: flags.env,
             baseUrl: flags['api-base-url'],
             role: flags.role,

package/dist/lib/prompt-validators.js

@@ -13,6 +13,7 @@ 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;
+const TCP_PORT_PROBE_HOSTS = ['127.0.0.1', '0.0.0.0', '::1'];
 function buildHealthCheckUrl(apiBaseUrl) {
     return `${apiBaseUrl.replace(/\/+$/, '')}/__health_check`;
 }
@@ -119,7 +120,7 @@ export function validateTcpPort(value) {
     }
     return undefined;
 }
-async function canListenOnTcpPort(port) {
+async function canListenOnTcpPortHost(port, host) {
     return await new Promise((resolve) => {
         const server = net.createServer();
         const resolveAndCleanup = (result) => {
@@ -131,15 +132,28 @@ async function canListenOnTcpPort(port) {
                 resolve(result);
             }
         };
-        server.once('error', () => {
+        server.once('error', (error) => {
+            if (error.code === 'EADDRNOTAVAIL' || error.code === 'EAFNOSUPPORT') {
+                resolveAndCleanup(undefined);
+                return;
+            }
             resolveAndCleanup(false);
         });
         server.once('listening', () => {
             resolveAndCleanup(true);
         });
-        server.listen(port, '127.0.0.1');
+        server.listen(port, host);
     });
 }
+async function canListenOnTcpPort(port) {
+    for (const host of TCP_PORT_PROBE_HOSTS) {
+        const result = await canListenOnTcpPortHost(port, host);
+        if (result === false) {
+            return false;
+        }
+    }
+    return true;
+}
 function parseDockerPublishedTcpPorts(output) {
     const ports = new Set();
     for (const line of output.split(/\r?\n/)) {
@@ -210,9 +224,10 @@ async function allocateAvailableTcpPort() {
 }
 export async function findAvailableTcpPort() {
     const dockerPorts = await getDockerPublishedTcpPorts();
-    for (let attempt = 0; attempt < 10; attempt += 1) {
+    for (let attempt = 0; attempt < 20; attempt += 1) {
         const candidate = await allocateAvailableTcpPort();
-        if (!dockerPorts.has(Number.parseInt(candidate, 10))) {
+        const port = Number.parseInt(candidate, 10);
+        if (!dockerPorts.has(port) && (await canListenOnTcpPort(port))) {
             return candidate;
         }
     }
@@ -228,6 +243,9 @@ export async function validateAvailableTcpPort(value) {
         return formatError;
     }
     const port = parseTcpPort(raw);
+    if (port === undefined) {
+        return translateCli('validators.tcpPort.invalid', { example: TCP_PORT_EXAMPLE });
+    }
     const dockerPorts = await getDockerPublishedTcpPorts();
     if (dockerPorts.has(port)) {
         return translateCli('validators.tcpPort.alreadyInUseByDocker', { port });