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

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,24 @@
  */
 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) } : {}),
+        });
 }
-function defaultOnCancel() {
-    p.cancel('Cancelled.');
+function defaultOnCancel(locale) {
+    p.cancel(createCliTranslate(locale)('promptCatalog.common.cancelled'));
     exit(0);
 }
 function defaultOnMissingNonInteractive(message) {
@@ -121,7 +129,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 +143,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 +156,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 +164,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 +177,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 +209,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 +224,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 +235,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 +247,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 +268,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 +293,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 +305,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 +319,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 +337,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 +347,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 +361,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 +377,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 +403,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 +414,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 +429,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 +441,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 +463,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 +473,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 +504,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 +545,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;
                 },

package/dist/lib/prompt-validators.js

@@ -8,6 +8,7 @@
  */
 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';
@@ -21,10 +22,10 @@ export function validateApiBaseUrl(value) {
         url = new URL(raw);
     }
     catch {
-        return `Enter a valid URL, for example ${API_BASE_URL_EXAMPLE}.`;
+        return translateCli('validators.apiBaseUrl.invalid', { example: API_BASE_URL_EXAMPLE });
     }
     if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        return `URL must start with http:// or https://, for example ${API_BASE_URL_EXAMPLE}.`;
+        return translateCli('validators.apiBaseUrl.invalidProtocol', { example: API_BASE_URL_EXAMPLE });
     }
     return undefined;
 }
@@ -34,7 +35,7 @@ export function validateEnvKey(value) {
         return undefined;
     }
     if (!ENV_KEY_PATTERN.test(raw)) {
-        return 'Use letters and numbers only.';
+        return translateCli('validators.envKey.invalid');
     }
     return undefined;
 }
@@ -59,7 +60,7 @@ export function validateTcpPort(value) {
     }
     const port = parseTcpPort(raw);
     if (port === undefined) {
-        return `Enter a valid TCP port between 1 and 65535, for example ${TCP_PORT_EXAMPLE}.`;
+        return translateCli('validators.tcpPort.invalid', { example: TCP_PORT_EXAMPLE });
     }
     return undefined;
 }
@@ -138,7 +139,7 @@ async function allocateAvailableTcpPort() {
                 : undefined;
             if (!port) {
                 server.close(() => {
-                    reject(new Error('Failed to allocate an available TCP port.'));
+                    reject(new Error(translateCli('validators.tcpPort.allocateFailed')));
                 });
                 return;
             }
@@ -160,7 +161,7 @@ export async function findAvailableTcpPort() {
             return candidate;
         }
     }
-    throw new Error('Failed to allocate an available TCP port that is not already published by Docker.');
+    throw new Error(translateCli('validators.tcpPort.allocateNotDockerPublished'));
 }
 export async function validateAvailableTcpPort(value) {
     const raw = String(value ?? '').trim();
@@ -174,11 +175,11 @@ export async function validateAvailableTcpPort(value) {
     const port = parseTcpPort(raw);
     const available = await canListenOnTcpPort(port);
     if (!available) {
-        return `Port ${port} is already in use. Choose another port.`;
+        return translateCli('validators.tcpPort.alreadyInUse', { port });
     }
     const dockerPorts = await getDockerPublishedTcpPorts();
     if (dockerPorts.has(port)) {
-        return `Port ${port} is already in use by a Docker container. Choose another port.`;
+        return translateCli('validators.tcpPort.alreadyInUseByDocker', { port });
     }
     return undefined;
 }