@nocobase/cli 2.1.0-alpha.21 → 2.1.0-alpha.22

package/dist/commands/install.js

@@ -15,6 +15,7 @@ import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { exit } from 'node:process';
 import { runPromptCatalog, } from "../lib/prompt-catalog.js";
+import { applyCliLocale, localeText, translateCli, } from "../lib/cli-locale.js";
 import { findAvailableTcpPort, validateAvailableTcpPort, validateTcpPort, validateEnvKey, } from "../lib/prompt-validators.js";
 import { formatMissingManagedAppEnvMessage } from '../lib/app-runtime.js';
 import { run, runNocoBaseCommand } from '../lib/run-npm.js';
@@ -33,11 +34,17 @@ const DEFAULT_INSTALL_DB_PORTS = {
     mariadb: '3306',
     kingbase: '54321',
 };
+const DEFAULT_INSTALL_BUILTIN_DB_IMAGES = {
+    postgres: 'postgres:16',
+    mysql: 'mysql:8',
+    mariadb: 'mariadb:11',
+    kingbase: 'registry.cn-shanghai.aliyuncs.com/nocobase/kingbase:v009r001c001b0030_single_x86',
+};
 const DEFAULT_INSTALL_DB_DATABASE = 'nocobase';
 const DEFAULT_INSTALL_DB_USER = 'nocobase';
 const DEFAULT_INSTALL_DB_PASSWORD = 'nocobase';
 const DEFAULT_INSTALL_ROOT_USERNAME = 'nocobase';
-const DEFAULT_INSTALL_ROOT_EMAIL = 'admin@example.com';
+const DEFAULT_INSTALL_ROOT_EMAIL = 'admin@nocobase.com';
 const DEFAULT_INSTALL_ROOT_PASSWORD = 'admin123';
 const DEFAULT_INSTALL_ROOT_NICKNAME = 'Super Admin';
 const CONFIG_SCOPE = 'project';
@@ -117,21 +124,47 @@ const INSTALL_LANGUAGE_OPTIONS = Object.entries(INSTALL_LANGUAGE_CODES).map(([va
     value,
     label: `${label} (${value})`,
 }));
+const installText = (key, values) => localeText(`commands.install.${key}`, values);
 function argvHasToken(argv, tokens) {
     return tokens.some((t) => argv.includes(t));
 }
 function isInstallDbDialect(value) {
     return INSTALL_DB_DIALECTS.includes(value);
 }
+function supportsBuiltinDbDialect(value) {
+    const dialect = String(value ?? '').trim();
+    return Object.prototype.hasOwnProperty.call(DEFAULT_INSTALL_BUILTIN_DB_IMAGES, dialect);
+}
 export function defaultDbPortForDialect(value) {
     const dialect = String(value ?? 'postgres').trim();
     return DEFAULT_INSTALL_DB_PORTS[isInstallDbDialect(dialect) ? dialect : 'postgres'];
 }
+function defaultBuiltinDbImageForDialect(value) {
+    const dialect = String(value ?? 'postgres').trim();
+    return supportsBuiltinDbDialect(dialect)
+        ? DEFAULT_INSTALL_BUILTIN_DB_IMAGES[dialect]
+        : DEFAULT_INSTALL_BUILTIN_DB_IMAGES.postgres;
+}
+function defaultDbDatabaseForDialect(value) {
+    return String(value ?? '').trim() === 'kingbase'
+        ? 'kingbase'
+        : DEFAULT_INSTALL_DB_DATABASE;
+}
 function defaultDbHostForBuiltinDb(values) {
     return Boolean(values.builtinDb)
         ? DEFAULT_INSTALL_BUILTIN_DB_HOST
         : DEFAULT_INSTALL_DB_HOST;
 }
+function validateBuiltinDbEnabled(value, values) {
+    if (!Boolean(value)) {
+        return undefined;
+    }
+    const dialect = String(values.dbDialect ?? 'postgres').trim() || 'postgres';
+    if (supportsBuiltinDbDialect(dialect)) {
+        return undefined;
+    }
+    return translateCli('commands.install.validation.builtinDbUnsupported', { dialect });
+}
 function defaultInstallAppRootPath(envName) {
     const name = String(envName ?? DEFAULT_INSTALL_ENV_NAME).trim() || DEFAULT_INSTALL_ENV_NAME;
     return `./${name}/source/`;
@@ -264,6 +297,9 @@ export default class Install extends Command {
             description: 'Database dialect for the app',
             options: ['postgres', 'mysql', 'mariadb', 'kingbase'],
         }),
+        'builtin-db-image': Flags.string({
+            description: 'Docker image for the built-in database container (default follows the selected database)',
+        }),
         'db-host': Flags.string({
             description: 'Database host for the app',
         }),
@@ -289,8 +325,8 @@ export default class Install extends Command {
     static envPrompts = {
         env: {
             type: 'text',
-            message: 'What would you like to call this app?',
-            placeholder: DEFAULT_INSTALL_ENV_NAME,
+            message: installText('prompts.env.message'),
+            placeholder: installText('prompts.env.placeholder'),
             required: true,
             validate: validateEnvKey,
         },
@@ -298,7 +334,7 @@ export default class Install extends Command {
     static appPrompts = {
         lang: {
             type: 'select',
-            message: 'Which language would you like to use?',
+            message: installText('prompts.lang.message'),
             options: INSTALL_LANGUAGE_OPTIONS,
             initialValue: DEFAULT_INSTALL_LANG,
             yesInitialValue: DEFAULT_INSTALL_LANG,
@@ -311,39 +347,33 @@ export default class Install extends Command {
         // },
         appRootPath: {
             type: 'text',
-            message: 'Where should this app be stored?',
-            placeholder: './<env>/source/',
+            message: installText('prompts.appRootPath.message'),
+            placeholder: installText('prompts.appRootPath.placeholder'),
             initialValue: (values) => defaultInstallAppRootPath(values.env ?? values.appName),
         },
         appPort: {
             type: 'text',
-            message: 'Which port should this app use?',
-            placeholder: DEFAULT_INSTALL_APP_PORT,
+            message: installText('prompts.appPort.message'),
+            placeholder: installText('prompts.appPort.placeholder'),
             validate: validateAvailableTcpPort,
         },
         storagePath: {
             type: 'text',
-            message: 'Where should uploads and local files be stored?',
-            placeholder: './<env>/storage/',
+            message: installText('prompts.storagePath.message'),
+            placeholder: installText('prompts.storagePath.placeholder'),
             initialValue: (values) => defaultInstallStoragePath(values.env ?? values.appName),
         },
         fetchSource: {
             type: 'boolean',
-            message: 'Download NocoBase automatically if the app directory is empty?',
+            message: installText('prompts.fetchSource.message'),
             initialValue: true,
             yesInitialValue: true,
         },
     };
     static dbPrompts = {
-        builtinDb: {
-            type: 'boolean',
-            message: "Would you like to use the built-in database?",
-            initialValue: true,
-            yesInitialValue: true,
-        },
         dbDialect: {
             type: 'select',
-            message: 'Which database would you like to use?',
+            message: installText('prompts.dbDialect.message'),
             options: [
                 { value: 'postgres', label: 'PostgreSQL' },
                 { value: 'mysql', label: 'MySQL' },
@@ -354,10 +384,26 @@ export default class Install extends Command {
             yesInitialValue: 'postgres',
             required: true,
         },
+        builtinDb: {
+            type: 'boolean',
+            message: installText('prompts.builtinDb.message'),
+            initialValue: true,
+            yesInitialValue: true,
+            validate: validateBuiltinDbEnabled,
+        },
+        builtinDbImage: {
+            type: 'text',
+            message: installText('prompts.builtinDbImage.message'),
+            placeholder: installText('prompts.builtinDbImage.placeholder'),
+            initialValue: (values) => defaultBuiltinDbImageForDialect(values.dbDialect),
+            hidden: (values) => !Boolean(values.builtinDb)
+                || !supportsBuiltinDbDialect(values.dbDialect),
+            required: true,
+        },
         dbHost: {
             type: 'text',
-            message: 'What is the database host?',
-            placeholder: DEFAULT_INSTALL_DB_HOST,
+            message: installText('prompts.dbHost.message'),
+            placeholder: installText('prompts.dbHost.placeholder'),
             initialValue: (values) => defaultDbHostForBuiltinDb(values),
             yesInitialValue: DEFAULT_INSTALL_BUILTIN_DB_HOST,
             required: true,
@@ -365,8 +411,8 @@ export default class Install extends Command {
         },
         dbPort: {
             type: 'text',
-            message: 'What is the database port?',
-            placeholder: DEFAULT_INSTALL_DB_PORTS.postgres,
+            message: installText('prompts.dbPort.message'),
+            placeholder: installText('prompts.dbPort.placeholder'),
             initialValue: (values) => defaultDbPortForDialect(values.dbDialect),
             required: true,
             validate: validateTcpPort,
@@ -375,21 +421,20 @@ export default class Install extends Command {
         },
         dbDatabase: {
             type: 'text',
-            message: 'What is the database name?',
-            initialValue: DEFAULT_INSTALL_DB_DATABASE,
-            yesInitialValue: DEFAULT_INSTALL_DB_DATABASE,
+            message: installText('prompts.dbDatabase.message'),
+            initialValue: (values) => defaultDbDatabaseForDialect(values.dbDialect),
             required: true,
         },
         dbUser: {
             type: 'text',
-            message: 'What is the database username?',
+            message: installText('prompts.dbUser.message'),
             initialValue: DEFAULT_INSTALL_DB_USER,
             yesInitialValue: DEFAULT_INSTALL_DB_USER,
             required: true,
         },
         dbPassword: {
             type: 'password',
-            message: 'What is the database password?',
+            message: installText('prompts.dbPassword.message'),
             initialValue: DEFAULT_INSTALL_DB_PASSWORD,
             yesInitialValue: DEFAULT_INSTALL_DB_PASSWORD,
             required: true,
@@ -398,30 +443,30 @@ export default class Install extends Command {
     static rootUserPrompts = {
         rootUsername: {
             type: 'text',
-            message: 'Choose the initial admin username',
-            placeholder: DEFAULT_INSTALL_ROOT_USERNAME,
-            initialValue: DEFAULT_INSTALL_ROOT_USERNAME,
+            message: installText('prompts.rootUsername.message'),
+            placeholder: installText('prompts.rootUsername.placeholder'),
             yesInitialValue: DEFAULT_INSTALL_ROOT_USERNAME,
+            required: true,
         },
         rootEmail: {
             type: 'text',
-            message: 'What is the initial admin email?',
-            placeholder: DEFAULT_INSTALL_ROOT_EMAIL,
-            initialValue: DEFAULT_INSTALL_ROOT_EMAIL,
+            message: installText('prompts.rootEmail.message'),
+            placeholder: installText('prompts.rootEmail.placeholder'),
             yesInitialValue: DEFAULT_INSTALL_ROOT_EMAIL,
+            required: true,
         },
         rootPassword: {
             type: 'password',
-            message: 'Choose the initial admin password',
-            initialValue: DEFAULT_INSTALL_ROOT_PASSWORD,
+            message: installText('prompts.rootPassword.message'),
             yesInitialValue: DEFAULT_INSTALL_ROOT_PASSWORD,
+            required: true,
         },
         rootNickname: {
             type: 'text',
-            message: 'What display name should the initial admin use?',
-            placeholder: DEFAULT_INSTALL_ROOT_NICKNAME,
-            initialValue: DEFAULT_INSTALL_ROOT_NICKNAME,
+            message: installText('prompts.rootNickname.message'),
+            placeholder: installText('prompts.rootNickname.placeholder'),
             yesInitialValue: DEFAULT_INSTALL_ROOT_NICKNAME,
+            required: true,
         },
     };
     /**
@@ -520,6 +565,12 @@ export default class Install extends Command {
                 preset.dbDialect = t;
             }
         }
+        if (flags['builtin-db-image'] !== undefined) {
+            const v = String(flags['builtin-db-image'] ?? '').trim();
+            if (v) {
+                preset.builtinDbImage = v;
+            }
+        }
         if (flags['db-host'] !== undefined) {
             const v = String(flags['db-host'] ?? '').trim();
             if (v) {
@@ -563,6 +614,7 @@ export default class Install extends Command {
         return pickPresetKeys(Install.buildPresetValuesFromFlags(flags), [
             'builtinDb',
             'dbDialect',
+            'builtinDbImage',
             'dbHost',
             'dbPort',
             'dbDatabase',
@@ -603,6 +655,7 @@ export default class Install extends Command {
         const dbDatabase = Install.toOptionalPromptString(config.dbDatabase);
         const dbUser = Install.toOptionalPromptString(config.dbUser);
         const dbPassword = Install.toOptionalPromptString(config.dbPassword);
+        const builtinDbImage = Install.toOptionalPromptString(config.builtinDbImage);
         const auth = config.auth;
         const appPreset = {
             ...(appRootPath ? { appRootPath } : {}),
@@ -630,6 +683,7 @@ export default class Install extends Command {
         const dbPreset = {
             ...(typeof config.builtinDb === 'boolean' ? { builtinDb: config.builtinDb } : {}),
             ...(dbDialect ? { dbDialect } : {}),
+            ...(builtinDbImage ? { builtinDbImage } : {}),
             ...(dbHost ? { dbHost } : {}),
             ...(dbPort ? { dbPort } : {}),
             ...(dbDatabase ? { dbDatabase } : {}),
@@ -719,7 +773,7 @@ export default class Install extends Command {
         if (params.flags['app-port'] === undefined) {
             initialValues.appPort = await Install.resolveAvailableDefaultPort(DEFAULT_INSTALL_APP_PORT, {
                 label: 'Default app port',
-                warn: true,
+                warn: params.warnOnPortFallback ?? true,
             });
         }
         return initialValues;
@@ -745,7 +799,7 @@ export default class Install extends Command {
         return {
             dbPort: await Install.resolveAvailableDefaultPort(defaultPort, {
                 label: `Default ${dialect} port`,
-                warn: true,
+                warn: params.warnOnPortFallback ?? true,
             }),
         };
     }
@@ -900,6 +954,7 @@ export default class Install extends Command {
         const dbDialect = String(params.dbDialect ?? 'postgres').trim() || 'postgres';
         const dbPort = String(params.dbPort ?? defaultDbPortForDialect(dbDialect)).trim()
             || defaultDbPortForDialect(dbDialect);
+        const defaultDbDatabase = defaultDbDatabaseForDialect(dbDialect);
         const networkName = Install.buildBuiltinDbNetworkName(params.envName, params.workspaceName);
         const containerName = Install.buildBuiltinDbContainerName(params.envName, dbDialect, params.workspaceName);
         const dbHostInput = String(params.dbHost ?? '').trim();
@@ -915,6 +970,7 @@ export default class Install extends Command {
                 ? dbHostInput
                 : containerName);
         if (dbDialect === 'postgres') {
+            const image = String(params.builtinDbImage ?? '').trim() || DEFAULT_INSTALL_BUILTIN_DB_IMAGES.postgres;
             const dataDir = path.resolve(params.storagePath, 'db', 'postgres');
             const args = [
                 'run',
@@ -937,14 +993,14 @@ export default class Install extends Command {
             if (Install.shouldPublishBuiltinDbPort(params.source)) {
                 args.push('-p', `${dbPort}:5432`);
             }
-            args.push('postgres:16', 'postgres', '-c', 'wal_level=logical');
+            args.push(image, 'postgres', '-c', 'wal_level=logical');
             return {
                 source: String(params.source ?? '').trim() || undefined,
                 dbDialect,
                 dbHost,
                 dbPort,
-                dbDatabase: String(params.dbDatabase ?? DEFAULT_INSTALL_DB_DATABASE).trim()
-                    || DEFAULT_INSTALL_DB_DATABASE,
+                dbDatabase: String(params.dbDatabase ?? defaultDbDatabase).trim()
+                    || defaultDbDatabase,
                 dbUser: String(params.dbUser ?? DEFAULT_INSTALL_DB_USER).trim()
                     || DEFAULT_INSTALL_DB_USER,
                 dbPassword: String(params.dbPassword ?? DEFAULT_INSTALL_DB_PASSWORD)
@@ -952,14 +1008,16 @@ export default class Install extends Command {
                 networkName,
                 containerName,
                 dataDir,
-                image: 'postgres:16',
+                builtinDbImage: image,
+                image,
                 args,
             };
         }
         if (dbDialect === 'mysql') {
+            const image = String(params.builtinDbImage ?? '').trim() || DEFAULT_INSTALL_BUILTIN_DB_IMAGES.mysql;
             const dataDir = path.resolve(params.storagePath, 'db', 'mysql');
             const dbUser = String(params.dbUser ?? DEFAULT_INSTALL_DB_USER).trim() || DEFAULT_INSTALL_DB_USER;
-            const dbDatabase = String(params.dbDatabase ?? DEFAULT_INSTALL_DB_DATABASE).trim() || DEFAULT_INSTALL_DB_DATABASE;
+            const dbDatabase = String(params.dbDatabase ?? defaultDbDatabase).trim() || defaultDbDatabase;
             const dbPassword = String(params.dbPassword ?? DEFAULT_INSTALL_DB_PASSWORD) || DEFAULT_INSTALL_DB_PASSWORD;
             const args = [
                 'run',
@@ -984,7 +1042,7 @@ export default class Install extends Command {
             if (Install.shouldPublishBuiltinDbPort(params.source)) {
                 args.push('-p', `${dbPort}:3306`);
             }
-            args.push('mysql:8');
+            args.push(image);
             return {
                 source: String(params.source ?? '').trim() || undefined,
                 dbDialect,
@@ -996,14 +1054,16 @@ export default class Install extends Command {
                 networkName,
                 containerName,
                 dataDir,
-                image: 'mysql:8',
+                builtinDbImage: image,
+                image,
                 args,
             };
         }
         if (dbDialect === 'mariadb') {
+            const image = String(params.builtinDbImage ?? '').trim() || DEFAULT_INSTALL_BUILTIN_DB_IMAGES.mariadb;
             const dataDir = path.resolve(params.storagePath, 'db', 'mariadb');
             const dbUser = String(params.dbUser ?? DEFAULT_INSTALL_DB_USER).trim() || DEFAULT_INSTALL_DB_USER;
-            const dbDatabase = String(params.dbDatabase ?? DEFAULT_INSTALL_DB_DATABASE).trim() || DEFAULT_INSTALL_DB_DATABASE;
+            const dbDatabase = String(params.dbDatabase ?? defaultDbDatabase).trim() || defaultDbDatabase;
             const dbPassword = String(params.dbPassword ?? DEFAULT_INSTALL_DB_PASSWORD) || DEFAULT_INSTALL_DB_PASSWORD;
             const args = [
                 'run',
@@ -1028,7 +1088,58 @@ export default class Install extends Command {
             if (Install.shouldPublishBuiltinDbPort(params.source)) {
                 args.push('-p', `${dbPort}:3306`);
             }
-            args.push('mariadb:11');
+            args.push(image);
+            return {
+                source: String(params.source ?? '').trim() || undefined,
+                dbDialect,
+                dbHost,
+                dbPort,
+                dbDatabase,
+                dbUser,
+                dbPassword,
+                networkName,
+                containerName,
+                dataDir,
+                builtinDbImage: image,
+                image,
+                args,
+            };
+        }
+        if (dbDialect === 'kingbase') {
+            const image = String(params.builtinDbImage ?? '').trim() || DEFAULT_INSTALL_BUILTIN_DB_IMAGES.kingbase;
+            const dataDir = path.resolve(params.storagePath, 'db', 'kingbase');
+            const dbUser = String(params.dbUser ?? DEFAULT_INSTALL_DB_USER).trim() || DEFAULT_INSTALL_DB_USER;
+            const dbDatabase = String(params.dbDatabase ?? defaultDbDatabase).trim() || defaultDbDatabase;
+            const dbPassword = String(params.dbPassword ?? DEFAULT_INSTALL_DB_PASSWORD) || DEFAULT_INSTALL_DB_PASSWORD;
+            const args = [
+                'run',
+                '-d',
+                '--name',
+                containerName,
+                '--restart',
+                'always',
+                '--network',
+                networkName,
+                '--platform',
+                'linux/amd64',
+                '--privileged',
+                '-e',
+                'ENABLE_CI=no',
+                '-e',
+                `DB_USER=${dbUser}`,
+                '-e',
+                `DB_PASSWORD=${dbPassword}`,
+                '-e',
+                'DB_MODE=pg',
+                '-e',
+                'NEED_START=yes',
+                '-v',
+                `${dataDir}:/home/kingbase/userdata`,
+            ];
+            if (Install.shouldPublishBuiltinDbPort(params.source)) {
+                args.push('-p', `${dbPort}:54321`);
+            }
+            args.push(image, '/usr/sbin/init');
             return {
                 source: String(params.source ?? '').trim() || undefined,
                 dbDialect,
@@ -1040,11 +1151,12 @@ export default class Install extends Command {
                 networkName,
                 containerName,
                 dataDir,
-                image: 'mariadb:11',
+                builtinDbImage: image,
+                image,
                 args,
             };
         }
-        throw new Error(`Built-in database does not support "${dbDialect}" yet. Please choose PostgreSQL, MySQL, or MariaDB.`);
+        throw new Error(`Built-in database does not support "${dbDialect}" yet. Please choose PostgreSQL, MySQL, MariaDB, or KingbaseES.`);
     }
     async ensureDockerNetwork(name) {
         p.log.step(`Checking Docker network: ${name}`);
@@ -1138,6 +1250,7 @@ export default class Install extends Command {
             dbDatabase: params.dbResults.dbDatabase,
             dbUser: params.dbResults.dbUser,
             dbPassword: params.dbResults.dbPassword,
+            builtinDbImage: params.dbResults.builtinDbImage,
         });
         p.log.step(`Preparing built-in ${plan.dbDialect} database`);
         await this.ensureDockerNetwork(plan.networkName);
@@ -1519,6 +1632,7 @@ export default class Install extends Command {
         Install.pushArgIfValue(argv, '--timezone', params.appResults.timeZone);
         Install.pushBooleanArgIfSet(argv, '--builtin-db', params.dbResults.builtinDb);
         Install.pushArgIfValue(argv, '--db-dialect', params.dbResults.dbDialect);
+        Install.pushArgIfValue(argv, '--builtin-db-image', params.dbResults.builtinDbImage);
         Install.pushArgIfValue(argv, '--db-host', params.dbResults.dbHost);
         Install.pushArgIfValue(argv, '--db-port', params.dbResults.dbPort);
         Install.pushArgIfValue(argv, '--db-database', params.dbResults.dbDatabase);
@@ -1624,6 +1738,7 @@ export default class Install extends Command {
     }
     async run() {
         const parsedResult = await this.parse(Install);
+        applyCliLocale(parsedResult.flags.locale);
         const flags = parsedResult.flags;
         const parsed = {
             ...flags,

package/dist/commands/prompts-stages.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { runPromptCatalog, } from "../lib/prompt-catalog.js";
+import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, } from "../lib/cli-locale.js";
 import { runPromptCatalogWebUI } from "../lib/prompt-web-ui.js";
 import PromptsTest from "./prompts-test.js";
 function buildWebUiStagesFromTestPrompts(c) {
@@ -67,6 +68,10 @@ export default class PromptsStages extends Command {
             description: 'Accept defaults only in the terminal (no Clack after submit); same semantics as `prompts-test` when used with the submitted or default preset.',
             default: false,
         }),
+        locale: Flags.string({
+            description: CLI_LOCALE_FLAG_DESCRIPTION,
+            options: CLI_LOCALE_FLAG_OPTIONS,
+        }),
         file: Flags.string({
             char: 'f',
             description: 'Merged into initialValues.file (default for the text prompt when set)',
@@ -96,6 +101,7 @@ export default class PromptsStages extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(PromptsStages);
+        applyCliLocale(flags.locale);
         let presetValues = this.buildPresetValuesFromParsed(args, flags);
         if (flags.ui) {
             presetValues = await runPromptCatalogWebUI({

package/dist/commands/prompts-test.js

@@ -9,6 +9,7 @@
 import * as p from '@clack/prompts';
 import { Args, Command, Flags } from '@oclif/core';
 import { runPromptCatalog, } from "../lib/prompt-catalog.js";
+import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, } from "../lib/cli-locale.js";
 import { runPromptCatalogWebUI, } from "../lib/prompt-web-ui.js";
 export default class PromptsTest extends Command {
     static hidden = true;
@@ -33,6 +34,10 @@ export default class PromptsTest extends Command {
             description: 'Accept defaults only (no prompts); uses `yesInitialValues` merged over `initialValues`, then per-block `yesInitialValue`. Same as non-TTY.',
             default: false,
         }),
+        locale: Flags.string({
+            description: CLI_LOCALE_FLAG_DESCRIPTION,
+            options: CLI_LOCALE_FLAG_OPTIONS,
+        }),
         file: Flags.string({
             char: 'f',
             description: 'Merged into initialValues.file (default for the text prompt when set)',
@@ -127,6 +132,7 @@ export default class PromptsTest extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(PromptsTest);
+        applyCliLocale(flags.locale);
         let presetValues = this.buildPresetValuesFromParsed(args, flags);
         if (flags.ui) {
             presetValues = await runPromptCatalogWebUI(PromptsTest.prompts, {

package/dist/lib/api-client.js

@@ -1,5 +1,27 @@
+/**
+ * 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(/\/+$/, '');
 }
@@ -59,6 +81,28 @@ function listProvidedBodyFlags(flags, 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'];
@@ -70,10 +114,10 @@ export async function parseBody(flags, operation) {
         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 JSON.parse(inlineBody);
+        return parseJsonInput(inlineBody, 'body');
     }
     if (bodyFile) {
-        return fs.readFile(bodyFile, 'utf8').then((content) => JSON.parse(content));
+        return fs.readFile(bodyFile, 'utf8').then((content) => parseJsonInput(content, 'body-file'));
     }
     if (!bodyParameters.length) {
         return undefined;
@@ -81,9 +125,7 @@ export async function parseBody(flags, operation) {
     const body = {};
     for (const parameter of bodyParameters) {
         const rawValue = flags[parameter.flagName];
-        const value = parameter.isArray && !parameter.jsonEncoded
-            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
-            : parseScalarValue(rawValue, parameter.type);
+        const value = parseBodyFieldValue(rawValue, parameter);
         if (parameter.required && (value === undefined || value === '')) {
             throw new Error(`Missing required body field --${parameter.flagName}`);
         }
@@ -103,6 +145,7 @@ export async function parseBody(flags, operation) {
 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}`);
     }
@@ -162,6 +205,7 @@ export async function executeApiRequest(options) {
 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}`);
     }