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

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}`);
     }

package/dist/lib/cli-locale.js

@@ -0,0 +1,115 @@
+/**
+ * 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 { readFileSync } from 'node:fs';
+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) {
+    const raw = String(value ?? '').trim();
+    if (!raw) {
+        return undefined;
+    }
+    const normalized = raw.replace(/\..*$/, '').replace(/_/g, '-').toLowerCase();
+    if (normalized === 'zh' || normalized.startsWith('zh-')) {
+        return 'zh-CN';
+    }
+    if (normalized === 'en' || normalized.startsWith('en-')) {
+        return 'en-US';
+    }
+    return undefined;
+}
+function loadLocaleMessages(locale) {
+    if (localeCache[locale]) {
+        return localeCache[locale];
+    }
+    const fileUrl = new URL(`../locale/${locale}.json`, import.meta.url);
+    const parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    localeCache[locale] = parsed;
+    return parsed;
+}
+function getPathValue(input, path) {
+    let current = input;
+    for (const part of path.split('.')) {
+        if (!current || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, part)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function interpolateTemplate(template, values) {
+    return template.replace(/{{\s*([\w.]+)\s*}}/g, (_match, key) => {
+        const value = getPathValue(values, key);
+        return value === undefined || value === null ? '' : String(value);
+    });
+}
+export function detectCliLocale() {
+    const candidates = [
+        process.env.NB_LOCALE,
+        process.env.LC_ALL,
+        process.env.LC_MESSAGES,
+        process.env.LANG,
+        Intl.DateTimeFormat().resolvedOptions().locale,
+    ];
+    for (const candidate of candidates) {
+        const locale = normalizeCliLocale(candidate);
+        if (locale) {
+            return locale;
+        }
+    }
+    return DEFAULT_CLI_LOCALE;
+}
+export function resolveCliLocale(preferred) {
+    return normalizeCliLocale(preferred) ?? detectCliLocale();
+}
+export function applyCliLocale(preferred) {
+    const locale = resolveCliLocale(preferred);
+    process.env.NB_LOCALE = locale;
+    return locale;
+}
+export function createCliTranslate(preferred) {
+    const locale = resolveCliLocale(preferred);
+    return (key, values, fallback) => {
+        const messages = loadLocaleMessages(locale);
+        const template = getPathValue(messages, key);
+        if (typeof template !== 'string') {
+            return interpolateTemplate(fallback ?? key, values);
+        }
+        return interpolateTemplate(template, values);
+    };
+}
+export function translateCli(key, values, options) {
+    return createCliTranslate(options?.locale)(key, values, options?.fallback);
+}
+export function localeText(key, values, fallback) {
+    return {
+        key,
+        ...(values ? { values } : {}),
+        ...(fallback ? { fallback } : {}),
+    };
+}
+export function isLocalizedTextDef(value) {
+    return Boolean(value
+        && typeof value === 'object'
+        && typeof value.key === 'string');
+}
+export function resolveLocalizedText(text, options) {
+    if (text === undefined) {
+        return options?.fallback ?? '';
+    }
+    if (typeof text === 'string') {
+        return text;
+    }
+    return translateCli(text.key, text.values, {
+        locale: options?.locale,
+        fallback: text.fallback ?? options?.fallback,
+    });
+}

package/dist/lib/env-auth.js

@@ -483,7 +483,7 @@ export function buildOauthCompletionHtml() {
         statusMark: '✓',
         heading: 'Authentication complete',
         description: 'Your sign-in finished successfully. You can return to the terminal and continue there.',
-        tip: 'This page will try to close automatically in a moment.',
+        tip: 'This page will close automatically in 10 seconds.',
         footer: 'You can close this page after returning to the terminal.',
         extraScriptHtml: `  <script>
     setTimeout(function () {
@@ -494,7 +494,7 @@ export function buildOauthCompletionHtml() {
           el.textContent = 'If this tab stays open, you can close it manually.';
         }
       }, 400);
-    }, 1000);
+    }, 10000);
   </script>`,
     });
 }

package/dist/lib/prompt-catalog.js

@@ -8,16 +8,30 @@
  */
 import * as p from '@clack/prompts';
 import { exit, stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { createCliTranslate, resolveCliLocale, resolveLocalizedText, } from "./cli-locale.js";
 export function selectOptionValues(options) {
     return options.map((o) => (typeof o === 'string' ? o : o.value));
 }
-function clackSelectOptions(options) {
+function resolvePromptText(text, locale, fallback = '') {
+    return resolveLocalizedText(text, { locale, fallback });
+}
+function clackSelectOptions(options, locale) {
     return options.map((o) => typeof o === 'string'
         ? { value: o, label: o }
-        : { value: o.value, label: o.label ?? o.value, ...(o.hint !== undefined ? { hint: o.hint } : {}) });
+        : {
+            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 enabledSelectOptionValues(options) {
+    return options
+        .filter((o) => typeof o === 'string' || o.disabled !== true)
+        .map((o) => (typeof o === 'string' ? o : o.value));
 }
-function defaultOnCancel() {
-    p.cancel('Cancelled.');
+function defaultOnCancel(locale) {
+    p.cancel(createCliTranslate(locale)('promptCatalog.common.cancelled'));
     exit(0);
 }
 function defaultOnMissingNonInteractive(message) {
@@ -55,21 +69,22 @@ function mergedBoolean(key, def, iv, useYesInitial) {
 }
 function mergedSelect(key, def, iv, useYesInitial) {
     const valueList = selectOptionValues(def.options);
+    const enabledValueList = enabledSelectOptionValues(def.options);
     if (hasIvKey(iv, key)) {
         const s = String(iv[key]);
-        if (valueList.includes(s)) {
+        if (enabledValueList.includes(s)) {
             return s;
         }
         return undefined;
     }
-    if (useYesInitial && def.yesInitialValue !== undefined && valueList.includes(def.yesInitialValue)) {
+    if (useYesInitial && def.yesInitialValue !== undefined && enabledValueList.includes(def.yesInitialValue)) {
         return def.yesInitialValue;
     }
     const d = def.initialValue;
-    if (d !== undefined && valueList.includes(d)) {
+    if (d !== undefined && enabledValueList.includes(d)) {
         return d;
     }
-    return valueList[0];
+    return enabledValueList[0];
 }
 function mergedInteger(key, def, iv, useYesInitial) {
     if (hasIvKey(iv, key)) {
@@ -121,7 +136,8 @@ export function isPromptBlockSkipped(def, values) {
  * If **`preset`** defines **`key`**, validate and set **`out[key]`**, return **`true`** (caller should `continue`).
  * No-op for non-input block types.
  */
-function tryApplyPreset(key, def, preset, out, hooks) {
+function tryApplyPreset(key, def, preset, out, hooks, locale) {
+    const t = createCliTranslate(locale);
     if (!hasIvKey(preset, key)) {
         return false;
     }
@@ -134,7 +150,7 @@ function tryApplyPreset(key, def, preset, out, hooks) {
         case 'text': {
             const s = String(raw ?? '');
             if (def.required && isBlankText(s)) {
-                hooks.onMissingNonInteractive(`"${key}" is required; set a non-empty values.${key} or omit it to prompt.`);
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
             }
             out[key] = s;
             return true;
@@ -147,7 +163,7 @@ function tryApplyPreset(key, def, preset, out, hooks) {
             const valueList = selectOptionValues(def.options);
             const s = String(raw ?? '');
             if (!valueList.includes(s)) {
-                hooks.onMissingNonInteractive(`Invalid values.${key}: "${s}". Expected one of: ${valueList.join(', ')}`);
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidSelect', { key, value: s, options: valueList.join(', ') }));
             }
             out[key] = s;
             return true;
@@ -155,7 +171,7 @@ function tryApplyPreset(key, def, preset, out, hooks) {
         case 'password': {
             const s = String(raw ?? '');
             if (def.required && isBlankText(s)) {
-                hooks.onMissingNonInteractive(`"${key}" is required; set a non-empty values.${key} or omit it to prompt.`);
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
             }
             out[key] = s;
             return true;
@@ -168,13 +184,13 @@ function tryApplyPreset(key, def, preset, out, hooks) {
             const s = String(raw ?? '').trim();
             if (s === '') {
                 if (def.required) {
-                    hooks.onMissingNonInteractive(`"${key}" is required; set values.${key} or omit it to prompt.`);
+                    hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
                 }
                 out[key] = def.initialValue ?? 0;
                 return true;
             }
             if (!/^-?\d+$/.test(s)) {
-                hooks.onMissingNonInteractive(`Invalid values.${key}: must be an integer.`);
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidInteger', { key }));
             }
             out[key] = Number.parseInt(s, 10);
             return true;
@@ -200,12 +216,14 @@ function tryApplyPreset(key, def, preset, out, hooks) {
  * Input blocks may set **`validate(value, values)`** (sync or async): return a string to fail; used after required/type checks, and by the local web form on submit. When **`validate`** is set, interactive TTY steps re-ask on failure (`log.error` + retry) except for simple fields without a custom `validate` (fast path).
  */
 export async function runPromptCatalog(catalog, options = {}) {
+    const locale = resolveCliLocale(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 = {
-        onCancel: options.hooks?.onCancel ?? defaultOnCancel,
+        onCancel: options.hooks?.onCancel ?? (() => defaultOnCancel(locale)),
         onMissingNonInteractive: options.hooks?.onMissingNonInteractive ?? defaultOnMissingNonInteractive,
     };
     const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !options.yes);
@@ -213,7 +231,7 @@ export async function runPromptCatalog(catalog, options = {}) {
     const out = {};
     for (const [key, def] of Object.entries(catalog)) {
         // Apply `values` presets before `hidden` / `when` so CLI/env fixes still win without UI.
-        if (tryApplyPreset(key, def, preset, out, hooks)) {
+        if (tryApplyPreset(key, def, preset, out, hooks, locale)) {
             const errV = await runPromptFieldValidate(def, out[key], out);
             if (errV) {
                 hooks.onMissingNonInteractive(errV);
@@ -224,11 +242,11 @@ export async function runPromptCatalog(catalog, options = {}) {
             continue;
         }
         if (def.type === 'intro') {
-            p.intro(def.title);
+            p.intro(resolvePromptText(def.title, locale));
             continue;
         }
         if (def.type === 'outro') {
-            p.outro(def.message);
+            p.outro(resolvePromptText(def.message, locale));
             continue;
         }
         if (def.type === 'run') {
@@ -236,10 +254,14 @@ export async function runPromptCatalog(catalog, options = {}) {
             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(`Non-interactive: "${key}" is required; set initialValues.${key}, yesInitialValues.${key}, yesInitialValue on the block, or initialValue.`);
+                    hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.textRequired', { key }));
                 }
                 out[key] = merged;
                 const errT = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
@@ -253,16 +275,16 @@ export async function runPromptCatalog(catalog, options = {}) {
                 let last = merged;
                 for (;;) {
                     const raw = await p.text({
-                        message: def.message,
+                        message,
                         initialValue: last,
-                        ...(def.placeholder !== undefined ? { placeholder: def.placeholder } : {}),
+                        ...(placeholder !== undefined ? { placeholder } : {}),
                     });
                     if (p.isCancel(raw)) {
                         hooks.onCancel();
                     }
                     const s = typeof raw === 'string' ? raw : last;
                     if (def.required && isBlankText(s)) {
-                        p.log.error('Required');
+                        p.log.error(t('promptCatalog.common.required'));
                         last = s;
                         continue;
                     }
@@ -278,10 +300,10 @@ export async function runPromptCatalog(catalog, options = {}) {
                 continue;
             }
             const raw = await p.text({
-                message: def.message,
+                message,
                 initialValue: merged,
-                ...(def.placeholder !== undefined ? { placeholder: def.placeholder } : {}),
-                validate: def.required ? (value) => (isBlankText(value) ? 'Required' : undefined) : undefined,
+                ...(placeholder !== undefined ? { placeholder } : {}),
+                validate: def.required ? (value) => (isBlankText(value) ? t('promptCatalog.common.required') : undefined) : undefined,
             });
             if (p.isCancel(raw)) {
                 hooks.onCancel();
@@ -290,6 +312,7 @@ export async function runPromptCatalog(catalog, options = {}) {
             continue;
         }
         if (def.type === 'boolean') {
+            const message = resolvePromptText(def.message, locale, key);
             if (!interactive) {
                 const b = mergedBoolean(key, def, resolveIv, useYesInitial);
                 out[key] = b;
@@ -303,7 +326,7 @@ export async function runPromptCatalog(catalog, options = {}) {
             if (def.validate) {
                 for (;;) {
                     const raw = await p.confirm({
-                        message: def.message,
+                        message,
                         initialValue: merged,
                     });
                     if (p.isCancel(raw)) {
@@ -321,7 +344,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                 continue;
             }
             const raw = await p.confirm({
-                message: def.message,
+                message,
                 initialValue: merged,
             });
             if (p.isCancel(raw)) {
@@ -331,9 +354,10 @@ export async function runPromptCatalog(catalog, options = {}) {
             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(`Select "${key}" is required but has no options.`);
+                hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.selectRequiredNoOptions', { key }));
             }
             if (!interactive) {
                 const merged = mergedSelect(key, def, resolveIv, useYesInitial);
@@ -344,8 +368,8 @@ export async function runPromptCatalog(catalog, options = {}) {
                             ? String(promptIv[key])
                             : undefined;
                     hooks.onMissingNonInteractive(bad !== undefined
-                        ? `Invalid value for ${key}: ${bad}. Expected one of: ${valueList.join(', ')}`
-                        : `Non-interactive: set initialValues.${key}, yesInitialValues.${key}, or select.initialValue / yesInitialValue / options on the catalog block.`);
+                        ? 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 });
@@ -360,15 +384,15 @@ export async function runPromptCatalog(catalog, options = {}) {
                 valueList[0];
             if (uiInitial === undefined || !valueList.includes(uiInitial)) {
                 const hint = def.required
-                    ? `Select "${key}" is required; set initialValues.${key} or select.initialValue / options on the catalog block.`
-                    : `Select "${key}" has no valid default; set initialValues.${key} or options on the catalog block.`;
+                    ? t('promptCatalog.nonInteractive.selectRequiredInteractive', { key })
+                    : t('promptCatalog.nonInteractive.selectMissingInteractiveDefault', { key });
                 hooks.onMissingNonInteractive(hint);
             }
             if (def.validate) {
                 for (;;) {
                     const raw = await p.select({
-                        message: def.message,
-                        options: clackSelectOptions(def.options),
+                        message,
+                        options: clackSelectOptions(def.options, locale),
                         initialValue: uiInitial,
                     });
                     if (p.isCancel(raw)) {
@@ -386,8 +410,8 @@ export async function runPromptCatalog(catalog, options = {}) {
                 continue;
             }
             const raw = await p.select({
-                message: def.message,
-                options: clackSelectOptions(def.options),
+                message,
+                options: clackSelectOptions(def.options, locale),
                 initialValue: uiInitial,
             });
             if (p.isCancel(raw)) {
@@ -397,11 +421,12 @@ export async function runPromptCatalog(catalog, options = {}) {
             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(`Non-interactive: "${key}" is required; set initialValues.${key}, yesInitialValues.${key}, or initialValue / yesInitialValue on the block.`);
+                        hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequired', { key }));
                     }
                     out[key] = '';
                     const errPE = await runPromptFieldValidate(def, '', { ...out, [key]: '' });
@@ -411,7 +436,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                     continue;
                 }
                 if (def.required && isBlankText(merged)) {
-                    hooks.onMissingNonInteractive(`Non-interactive: "${key}" is required; set a non-empty initialValues / yesInitialValues / initialValue / yesInitialValue.`);
+                    hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequiredNonEmpty', { key }));
                 }
                 out[key] = merged;
                 const errP = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
@@ -423,15 +448,15 @@ export async function runPromptCatalog(catalog, options = {}) {
             if (def.validate) {
                 for (;;) {
                     const raw = await p.password({
-                        message: def.message,
-                        validate: def.required ? (value) => (isBlankText(value) ? 'Required' : undefined) : undefined,
+                        message,
+                        validate: def.required ? (value) => (isBlankText(value) ? t('promptCatalog.common.required') : undefined) : undefined,
                     });
                     if (p.isCancel(raw)) {
                         hooks.onCancel();
                     }
                     const s = typeof raw === 'string' ? raw : '';
                     if (def.required && isBlankText(s)) {
-                        p.log.error('Required');
+                        p.log.error(t('promptCatalog.common.required'));
                         continue;
                     }
                     const errP = await runPromptFieldValidate(def, s, { ...out, [key]: s });
@@ -445,8 +470,8 @@ export async function runPromptCatalog(catalog, options = {}) {
                 continue;
             }
             const raw = await p.password({
-                message: def.message,
-                validate: def.required ? (value) => (isBlankText(value) ? 'Required' : undefined) : undefined,
+                message,
+                validate: def.required ? (value) => (isBlankText(value) ? t('promptCatalog.common.required') : undefined) : undefined,
             });
             if (p.isCancel(raw)) {
                 hooks.onCancel();
@@ -455,11 +480,15 @@ export async function runPromptCatalog(catalog, options = {}) {
             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(`Non-interactive: "${key}" is required; set initialValues.${key}, yesInitialValues.${key}, or initialValue / yesInitialValue on the block.`);
+                        hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.integerRequired', { key }));
                     }
                     const z = def.initialValue ?? 0;
                     out[key] = z;
@@ -482,16 +511,16 @@ export async function runPromptCatalog(catalog, options = {}) {
                 let last = lineDefault;
                 for (;;) {
                     const raw = await p.text({
-                        message: def.message,
+                        message,
                         initialValue: last,
-                        ...(def.placeholder !== undefined ? { placeholder: def.placeholder } : {}),
+                        ...(placeholder !== undefined ? { placeholder } : {}),
                         validate: (value) => {
-                            const t = value.trim();
-                            if (t === '') {
-                                return def.required ? 'Required' : undefined;
+                            const trimmed = value.trim();
+                            if (trimmed === '') {
+                                return def.required ? t('promptCatalog.common.required') : undefined;
                             }
-                            if (!/^-?\d+$/.test(t)) {
-                                return 'Must be an integer';
+                            if (!/^-?\d+$/.test(trimmed)) {
+                                return t('promptCatalog.common.mustBeInteger');
                             }
                             return undefined;
                         },
@@ -523,16 +552,16 @@ export async function runPromptCatalog(catalog, options = {}) {
                 continue;
             }
             const raw = await p.text({
-                message: def.message,
+                message,
                 initialValue: lineDefault,
-                ...(def.placeholder !== undefined ? { placeholder: def.placeholder } : {}),
+                ...(placeholder !== undefined ? { placeholder } : {}),
                 validate: (value) => {
-                    const t = value.trim();
-                    if (t === '') {
-                        return def.required ? 'Required' : undefined;
+                    const trimmed = value.trim();
+                    if (trimmed === '') {
+                        return def.required ? t('promptCatalog.common.required') : undefined;
                     }
-                    if (!/^-?\d+$/.test(t)) {
-                        return 'Must be an integer';
+                    if (!/^-?\d+$/.test(trimmed)) {
+                        return t('promptCatalog.common.mustBeInteger');
                     }
                     return undefined;
                 },