@quecue/dev-notify 0.1.3 → 0.1.4

package/dist/cli.js

@@ -4,9 +4,9 @@ import { readFile } from 'node:fs/promises';
 import { realpathSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { appPaths, ConfigError, createConfig, decodeUtf8, loadConfig, ready } from './config.js';
+import { appPaths, ConfigError, createConfig, decodeUtf8, loadConfig, readConfigLanguage, ready } from './config.js';
 import { deliver, makePlan } from './channels.js';
-import { wizard, clearCredentials } from './setup.js';
+import { wizard, clearCredentials, setConfigLanguage } from './setup.js';
 import { terminalPrompts, readText, Cancelled } from './prompts.js';
 import { CredentialError } from './credentials.js';
 import { claudeCodeStatus, claudeSettingsPath, configureClaudeCode } from './claude-code.js';
@@ -15,35 +15,29 @@ import { accessReplies, configureReplies, disableReplies } from './reply-state.j
 import { startBridge, stopBridge, bridgeStatus, runBridge } from './reply-bridge.js';
 import { updatePackage } from './update.js';
 import { postUpdate } from './maintenance.js';
-export const VERSION = '0.1.3';
-const HELP = `dev-notify ${VERSION} — 跨平台开发任务通知
-
-命令：
-  send --title 标题 [--content 正文 | --content-file 文件 | --stdin]
-       [--channel all|telegram|feishu] [--level info|success|warn|error]
-       [--footer 辅助信息] [--dry-run]
-  setup [--no-test] [--no-hooks]
-                            配置渠道及系统凭据；默认同时发送测试并安装
-                            Claude Code 通知 hooks，一次确认完成
-  setup --template [--yes]   只创建无密钥模板；不会覆盖已有配置，也不会安装 hooks
-  credentials clear         移除当前 Node 凭据引用和条目（需要确认）
-  paths                     显示配置路径（不会写入文件）
-  doctor / status           离线检查（不会发送消息）
-  update [--check] [--yes] [--no-post]
-                            检查并更新到 npm 最新版本，并维护 hooks 和桥接
-  integration list          列出可用集成
-  integration claude-code install / status / remove
-                            单独安装、查询或移除用户级 hooks（install/remove 可用 --yes）
-  reply setup               授权可信的 Telegram 私聊用户
-  reply start / status / stop
-                            启动、查询或停止回复桥接
-  reply disable             撤销远程回复授权并停止桥接（需要确认）
-  reply run                 前台运行桥接（排错用，不启用系统自启动）
-
-全局选项：--config 路径、--help、--version
-环境变量：TELEGRAM_BOT_TOKEN、TELEGRAM_CHAT_ID / TELEGRAM_CHAT_IDS、
-          FEISHU_WEBHOOK、FEISHU_SECRET；显式存在时优先。详见 README。
-系统凭据保存在 Windows Credential Manager / macOS Keychain；不会写入明文密钥。`;
+import { localeName, parseLocale, resolveLocale, setLocale, t } from './i18n.js';
+export const VERSION = '0.1.4';
+const helpText = () => t('cli.help', { version: VERSION });
+function rawLang(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--lang')
+            return argv[i + 1];
+        if (argv[i].startsWith('--lang='))
+            return argv[i].slice('--lang='.length);
+    }
+    return undefined;
+}
+function envLanguage(env) {
+    return typeof env.DEV_NOTIFY_LANG === 'string' && env.DEV_NOTIFY_LANG !== '' ? env.DEV_NOTIFY_LANG : undefined;
+}
+async function configuredLanguage(file, env) {
+    try {
+        return await readConfigLanguage(file ?? appPaths(process.platform, env).config);
+    }
+    catch {
+        return undefined;
+    }
+}
 const defaults = {
     env: process.env,
     out: text => console.log(text),
@@ -53,19 +47,20 @@ const defaults = {
     hookStdin: () => readHookInput(),
     confirm: async () => {
         if (!process.stdin.isTTY)
-            throw new ConfigError('当前不是交互终端。自动化场景请使用 setup --template --yes。');
-        return /^(y|yes)$/i.test(await readText('确认创建模板？[y/N] '));
+            throw new ConfigError(t('cli.nonInteractive'));
+        return /^(y|yes)$/i.test(await readText(t('cli.confirmTemplate')));
     },
     send: deliver,
 };
 export async function main(argv = process.argv.slice(2), overrides = {}) {
     const context = { ...defaults, ...overrides };
+    setLocale(parseLocale(rawLang(argv)) ?? parseLocale(envLanguage(context.env)) ?? 'zh');
     const isHook = argv[0] === 'integration' && argv[1] === 'claude-code' && argv[2] === 'hook';
     try {
         let parsed;
         try {
             parsed = parseArgs({ args: argv, allowPositionals: true, strict: true, options: {
-                    help: { type: 'boolean', short: 'h' }, version: { type: 'boolean' }, config: { type: 'string' },
+                    help: { type: 'boolean', short: 'h' }, version: { type: 'boolean' }, config: { type: 'string' }, lang: { type: 'string' },
                     title: { type: 'string' }, content: { type: 'string' }, 'content-file': { type: 'string' }, stdin: { type: 'boolean' },
                     channel: { type: 'string' }, level: { type: 'string' }, footer: { type: 'string' }, 'dry-run': { type: 'boolean' },
                     template: { type: 'boolean' }, yes: { type: 'boolean' },
@@ -73,11 +68,21 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                 } });
         }
         catch {
-            throw new ConfigError('参数无效，请运行 --help 查看用法。');
+            throw new ConfigError(t('cli.invalidArgs'));
         }
         const { values, positionals } = parsed;
+        if (values.lang !== undefined && values.lang !== '' && !parseLocale(values.lang))
+            throw new ConfigError(t('cli.invalidLanguage', { value: values.lang }));
+        if (values.lang === undefined && envLanguage(context.env) !== undefined && !parseLocale(envLanguage(context.env))) {
+            throw new ConfigError(t('cli.invalidLanguage', { value: envLanguage(context.env) }));
+        }
         if (values.help) {
-            context.out(HELP);
+            if (values.lang === undefined && envLanguage(context.env) === undefined) {
+                const configured = await configuredLanguage(values.config ? path.resolve(values.config) : undefined, context.env);
+                if (configured)
+                    setLocale(configured);
+            }
+            context.out(helpText());
             return 0;
         }
         if (values.version) {
@@ -87,13 +92,33 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
         const [command, action, integrationAction] = positionals;
         const allowed = {
             send: ['title', 'content', 'content-file', 'stdin', 'channel', 'level', 'footer', 'dry-run'],
-            setup: ['template', 'yes', 'no-test', 'no-hooks'], paths: [], doctor: [], status: [], integration: ['yes'], credentials: [], reply: [], update: ['check', 'yes', 'no-post'],
+            setup: ['template', 'yes', 'no-test', 'no-hooks'], paths: [], doctor: [], status: [], integration: ['yes'], credentials: [], reply: [], update: ['check', 'yes', 'no-post'], language: [],
         };
-        if (!command || !Object.hasOwn(allowed, command) || positionals.length > (command === 'integration' ? 3 : command === 'credentials' || command === 'reply' ? 2 : 1)
-            || Object.keys(values).some(key => key !== 'config' && !allowed[command].includes(key)))
-            throw new ConfigError('命令或选项组合不正确，请运行 --help 查看用法。');
+        const maxPositionals = command === 'integration' ? 3 : command === 'credentials' || command === 'reply' || command === 'language' ? 2 : 1;
+        if (!command || !Object.hasOwn(allowed, command) || positionals.length > maxPositionals
+            || Object.keys(values).some(key => key !== 'config' && key !== 'lang' && !allowed[command].includes(key)))
+            throw new ConfigError(t('cli.invalidCommand'));
         const paths = appPaths(process.platform, context.env);
         const file = values.config ? path.resolve(values.config) : paths.config;
+        setLocale(resolveLocale(values.lang, context.env, await readConfigLanguage(file)));
+        if (command === 'language') {
+            const requested = positionals[1];
+            if (requested !== undefined) {
+                const target = parseLocale(requested);
+                if (!target)
+                    throw new ConfigError(t('cli.invalidLanguage', { value: requested }));
+                setLocale(target);
+                const changed = await setConfigLanguage(file, target, context.out);
+                context.out(t(changed ? 'cli.languageChanged' : 'cli.languageAlready', { language: localeName(target), code: target }));
+            }
+            else {
+                const effective = resolveLocale(values.lang, context.env, await readConfigLanguage(file));
+                setLocale(effective);
+                context.out(t('cli.languageCurrent', { language: localeName(effective), code: effective }));
+                context.out(t('cli.languageHint'));
+            }
+            return 0;
+        }
         if (command === 'paths') {
             context.out(JSON.stringify({ config: file, data: paths.data }, null, 2));
             return 0;
@@ -108,21 +133,21 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
         }
         if (command === 'integration') {
             if (action === 'list' && !integrationAction) {
-                context.out('claude-code：支持通知、Telegram 回复和结构化问题交互。通知 hooks 与回复权限分开，默认只发送通知，不接收远程输入。');
+                context.out(t('cli.integrationList'));
                 return 0;
             }
             if (action !== 'claude-code' || !['install', 'status', 'remove', 'hook'].includes(integrationAction))
-                throw new ConfigError('请使用 integration list，或 integration claude-code install / status / remove。');
+                throw new ConfigError(t('cli.integrationUsage'));
             if (integrationAction === 'hook') {
                 await dispatchClaudeHook(await context.hookStdin(), file, { ...context, response: value => context.out(JSON.stringify(value)) });
                 return 0;
             }
             if (integrationAction === 'status') {
                 const status = await claudeCodeStatus({ env: context.env });
-                context.out(`Claude Code 用户级设置：${status.file}`);
-                context.out(`本工具 hooks：Stop ${status.stop} 个，Notification ${status.notification} 个，会话生命周期 ${status.lifecycle}/3 个，交互及结果确认 ${status.interaction}/5 个；其他处理器 ${status.others} 个。`);
-                context.out(status.disabled ? '当前文件启用了 disableAllHooks，安装后 hooks 不会生效；请自行解除禁用。'
-                    : '这里只检查用户级文件。是否实际加载还受项目和托管策略影响，请在 Claude Code 的 /hooks 中确认。');
+                context.out(t('cli.integrationStatusFile', { file: status.file }));
+                context.out(t('cli.integrationStatusCounts', { stop: status.stop, notification: status.notification,
+                    lifecycle: status.lifecycle, interaction: status.interaction, others: status.others }));
+                context.out(status.disabled ? t('cli.integrationDisabled') : t('cli.integrationStatusNote'));
                 return status.stop === 1 && status.notification === 1 && status.lifecycle === 3 && status.interaction === 5 && !status.disabled ? 0 : 1;
             }
             const prompts = context.prompts ?? (values.yes
@@ -131,36 +156,36 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
             if (integrationAction === 'install') {
                 const config = await loadConfig(file, true, context.env);
                 if (!ready(config, 'telegram') && !ready(config, 'feishu'))
-                    throw new ConfigError('请先运行 setup 配置至少一个通知渠道，再安装 Claude Code hooks。');
+                    throw new ConfigError(t('cli.setupChannelFirst'));
             }
             return await configureClaudeCode(file, integrationAction, prompts, { env: context.env, confirm: values.yes ? false : undefined }) ? 0 : 130;
         }
         if (command === 'reply') {
             if (!['setup', 'start', 'status', 'stop', 'disable', 'run'].includes(action))
-                throw new ConfigError('请使用 reply setup / start / status / stop / disable / run。');
+                throw new ConfigError(t('cli.replyUsage'));
             if (action === 'setup') {
                 const saved = await configureReplies(file, context.prompts ?? terminalPrompts(), context.env);
                 if (saved)
-                    context.out('授权已保存。请确认 hooks 已安装，然后运行 reply start。旧消息的回复映射不会保留。');
+                    context.out(t('cli.replySaved'));
                 return saved ? 0 : 130;
             }
             if (action === 'disable') {
                 if (!await disableReplies(file, context.prompts ?? terminalPrompts()))
                     return 130;
                 const stopped = await stopBridge(file);
-                context.out(stopped ? '桥接已停止或未运行。' : '已撤销授权并请求停止。正在进行中的调用无法撤回。');
+                context.out(stopped ? t('cli.bridgeStopped') : t('cli.replyDisabled'));
                 return 0;
             }
             if (action === 'stop') {
                 const stopped = await stopBridge(file);
-                context.out(stopped ? '桥接已停止或未运行。授权仍然保留，下次事件可以再次启动；如需彻底关闭，请运行 reply disable。'
-                    : '已发出停止请求，桥接正在退出。可运行 reply status 查看状态。');
+                context.out(stopped ? t('cli.stopStopped') : t('cli.stopRequested'));
                 return stopped ? 0 : 1;
             }
             if (action === 'status') {
                 const access = await accessReplies(file, context.env), status = await bridgeStatus(file);
-                context.out(access ? `远程回复：已授权 ${access.policy.users.length} 个私聊用户；工具权限逐次确认${access.policy.permissions ? '已开启' : '未开启'}。` : '远程回复：尚未启用。');
-                context.out(status.ready ? '桥接：已就绪。' : status.running ? '桥接：进程存在，但还没有就绪。' : '桥接：未运行。');
+                context.out(access ? t('cli.replyStatusAccess', { users: access.policy.users.length,
+                    state: t(access.policy.permissions ? 'cli.replyPermissionOn' : 'cli.replyPermissionOff') }) : t('cli.replyStatusNoAccess'));
+                context.out(status.ready ? t('cli.bridgeReady') : status.running ? t('cli.bridgeStarting') : t('cli.bridgeNotRunning'));
                 if (status.error)
                     context.err(status.error);
                 return access && status.ready ? 0 : 1;
@@ -170,33 +195,33 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                 return 0;
             }
             const ready = await startBridge(file, context.env);
-            context.out(ready ? '回复桥接已就绪。请从新的任务通知进入。' : '桥接还没有就绪。请运行 reply status 或 reply run 查看原因；如果旧版桥接在运行，请先停用它。');
+            context.out(ready ? t('cli.replyStartReady') : t('cli.replyStartNotReady'));
             return ready ? 0 : 1;
         }
         if (command === 'credentials') {
             if (action !== 'clear')
-                throw new ConfigError('credentials 目前只支持 clear，并且需要在交互终端中确认。');
+                throw new ConfigError(t('cli.credentialsUsage'));
             return await clearCredentials(file, context.prompts ?? terminalPrompts()) ? 0 : 130;
         }
         if (command === 'setup') {
             if (!values.template) {
                 if (values.yes)
-                    throw new ConfigError('--yes 只能和 --template 一起使用；保存密钥前仍然需要确认。');
+                    throw new ConfigError(t('cli.yesTemplateOnly'));
                 const prompts = context.prompts ?? terminalPrompts();
                 const notes = [];
                 const test = !values['no-test'];
                 if (test)
-                    notes.push('保存后会向最终生效的接收目标发送一条固定内容的测试通知。');
+                    notes.push(t('cli.setupNoteTest'));
                 let hooks = !values['no-hooks'];
                 if (hooks) {
                     try {
-                        notes.push(`Claude Code 用户级设置：${claudeSettingsPath(context.env)}`);
-                        notes.push('会为该设置文件对应的所有项目安装通知 hooks。最终回复正文可能包含敏感内容，将发送到配置实际生效的渠道。');
-                        notes.push('同时安装会话生命周期和结构化问题 hooks。远程输入只有在运行 reply setup 授权后才会开启。');
+                        notes.push(t('cli.setupNoteHooksPath', { path: claudeSettingsPath(context.env) }));
+                        notes.push(t('cli.setupNoteHooksScope'));
+                        notes.push(t('cli.setupNoteHooksLifecycle'));
                     }
                     catch (error) {
                         hooks = false;
-                        context.out(error instanceof ConfigError ? `跳过 Claude Code hooks：${error.message}` : '跳过 Claude Code hooks：没有找到用户级设置路径。');
+                        context.out(error instanceof ConfigError ? t('cli.skipHooks', { reason: error.message }) : t('cli.skipHooksNoPath'));
                     }
                 }
                 let integrationFailed = false;
@@ -208,9 +233,9 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                             if (!ready(config, channel))
                                 continue;
                             count++;
-                            const plan = makePlan(channel, { title: 'dev-notify 配置测试', content: '这是一条由你确认发送的测试通知。', footer: '', level: 'info' }, config);
+                            const plan = makePlan(channel, { title: t('cli.testTitle'), content: t('cli.testContent'), footer: '', level: 'info' }, config);
                             const result = await context.send(plan, config);
-                            context.out(`${channel}：测试已发送 ${result.sent}/${result.planned} 条`);
+                            context.out(t('cli.testSent', { channel, sent: result.sent, planned: result.planned }));
                             ok = ok && result.ok;
                         }
                         return count > 0 && ok;
@@ -229,31 +254,31 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                     return 130;
                 return integrationFailed ? 1 : 0;
             }
-            context.out(`将创建无密钥模板：${file}。不会联网，也不会修改 hooks。`);
+            context.out(t('cli.templateWillCreate', { file }));
             if (!values.yes && !await context.confirm()) {
-                context.out('已取消，没有写入。');
+                context.out(t('cli.templateCancelled'));
                 return 130;
             }
             await createConfig(file);
-            context.out('模板已创建。请配置环境凭据和接收人。');
+            context.out(t('cli.templateCreated'));
             return 0;
         }
         const config = await loadConfig(file, values.config !== undefined, context.env);
         if (command === 'doctor' || command === 'status') {
-            context.out(`配置路径: ${file}`);
+            context.out(t('cli.configPath', { file }));
             for (const channel of ['telegram', 'feishu'])
-                context.out(`${channel}：${ready(config, channel) ? '配置完整（尚未验证网络）' : '未启用或配置不完整'}`);
-            context.out('凭据：优先使用环境变量，其次系统凭据；本检查不联网，系统可能弹出授权提示。');
+                context.out(t('cli.channelStatus', { channel, status: t(ready(config, channel) ? 'cli.channelReady' : 'cli.channelNotReadyStatus') }));
+            context.out(t('cli.credentialsNote'));
             return ready(config, 'telegram') || ready(config, 'feishu') ? 0 : 1;
         }
         if (!values.title?.trim())
-            throw new ConfigError('send 需要提供非空的 --title。');
+            throw new ConfigError(t('cli.sendTitle'));
         if ([values.content !== undefined, values['content-file'] !== undefined, !!values.stdin].filter(Boolean).length > 1)
-            throw new ConfigError('--content、--content-file 和 --stdin 只能选择一个。');
+            throw new ConfigError(t('cli.sendSources'));
         const level = values.level ?? 'info';
         const channel = values.channel ?? 'all';
         if (!['info', 'success', 'warn', 'error'].includes(level) || !['all', 'telegram', 'feishu'].includes(channel))
-            throw new ConfigError('渠道或通知级别不正确。');
+            throw new ConfigError(t('cli.channelLevel'));
         let content = values.content ?? values.title;
         if (values['content-file'] !== undefined)
             content = decodeUtf8(await readFile(values['content-file']));
@@ -265,7 +290,7 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
         for (const name of selected) {
             if (!ready(config, name)) {
                 if (channel !== 'all')
-                    throw new ConfigError('这个渠道未启用，或配置不完整。');
+                    throw new ConfigError(t('cli.channelNotReady'));
                 continue;
             }
             planned++;
@@ -274,31 +299,31 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                 plan = makePlan(name, message, config);
             }
             catch {
-                context.err(`${name}：无法安全分段。请缩短标题或底部信息，或检查正文格式。`);
+                context.err(t('cli.segmentationFailed', { channel: name }));
                 failed = true;
                 continue;
             }
             if (values['dry-run']) {
-                context.out(`${name}：接收目标 ${plan.recipients}，预计请求 ${plan.items.length} 条（dry-run，没有实际发送）`);
+                context.out(t('cli.dryRun', { channel: name, recipients: plan.recipients, items: plan.items.length }));
                 continue;
             }
             const result = await context.send(plan, config);
-            context.out(`${name}：已发送 ${result.sent}/${result.planned} 条`);
+            context.out(t('cli.sent', { channel: name, sent: result.sent, planned: result.planned }));
             if (!result.ok) {
                 failed = true;
-                context.err(result.error ?? '发送失败。');
+                context.err(result.error ?? t('channels.sendFailed'));
             }
         }
         if (!planned)
-            throw new ConfigError('没有可用渠道，请先配置环境凭据和接收人。');
+            throw new ConfigError(t('cli.noChannels'));
         return failed ? 1 : 0;
     }
     catch (error) {
         if (error instanceof Cancelled) {
-            context.out('已取消。');
+            context.out(t('common.cancelled'));
             return isHook ? 0 : 130;
         }
-        context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : '操作失败。请检查文件、权限或输入；为避免泄露密钥，这里不显示底层异常。');
+        context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : t('common.failure'));
         // Stop hook 的退出码 2 会要求 Claude 继续；通知失败只能报告，不能阻塞或触发重试循环。
         return isHook ? 0 : 2;
     }

package/dist/config.js

@@ -2,10 +2,12 @@ import { readFile, mkdir, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { resolveReference } from './credentials.js';
+import { getLocale, t } from './i18n.js';
 export class ConfigError extends Error {
 }
 export const example = {
     version: 1,
+    language: 'zh',
     telegram: { enabled: true, chat_ids: [], token_env: 'TELEGRAM_BOT_TOKEN' },
     feishu: { enabled: true, webhook_env: 'FEISHU_WEBHOOK', secret_env: 'FEISHU_SECRET' },
 };
@@ -13,7 +15,7 @@ export function appPaths(platform = process.platform, env = process.env, home) {
     const join = platform === 'win32' ? path.win32 : path.posix;
     if (env.DEV_NOTIFY_HOME) {
         if (!join.isAbsolute(env.DEV_NOTIFY_HOME))
-            throw new ConfigError('DEV_NOTIFY_HOME 需要是绝对路径。');
+            throw new ConfigError(t('config.homeAbsolute'));
         return { config: join.join(env.DEV_NOTIFY_HOME, 'config', 'config.json'), data: join.join(env.DEV_NOTIFY_HOME, 'data') };
     }
     home ??= homedir();
@@ -31,36 +33,39 @@ export function appPaths(platform = process.platform, env = process.env, home) {
 }
 export function object(value, allowed, name) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new ConfigError(`${name} 需要是 JSON 对象。`);
+        throw new ConfigError(t('config.objectRequired', { name }));
     const result = value;
     if (Object.keys(result).some(key => !allowed.includes(key)))
-        throw new ConfigError(`${name} 包含不支持的字段；不能直接保存明文密钥。`);
+        throw new ConfigError(t('config.objectUnknown', { name }));
     return result;
 }
 function enabled(section) {
     if (section.enabled === undefined)
         return true;
     if (typeof section.enabled !== 'boolean')
-        throw new ConfigError('enabled 需要是布尔值。');
+        throw new ConfigError(t('config.enabledBoolean'));
     return section.enabled;
 }
 function secret(section, field, fallback, env, stored) {
     const name = section[field] ?? fallback;
     if (typeof name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
-        throw new ConfigError('凭据引用需要是合法的环境变量名称。');
+        throw new ConfigError(t('config.credentialEnvName'));
     if (Object.hasOwn(env, name))
         return (env[name] ?? '').trim();
     return enabled(section) ? stored().trim() : '';
 }
 export function parseConfig(input, env = process.env, resolver = resolveReference) {
-    const data = object(input, ['version', 'telegram', 'feishu', 'credentials'], '配置');
+    const data = object(input, ['version', 'language', 'telegram', 'feishu', 'credentials'], t('config.rootName'));
     if ((data.version ?? 1) !== 1)
-        throw new ConfigError('不支持这个配置版本。');
+        throw new ConfigError(t('config.unsupportedVersion'));
+    const language = data.language ?? 'zh';
+    if (language !== 'zh' && language !== 'en')
+        throw new ConfigError(t('config.invalidLanguage'));
     let reference;
     if (data.credentials !== undefined) {
         const value = object(data.credentials, ['backend', 'id'], 'credentials');
         if (!['system', 'keyring'].includes(String(value.backend)) || typeof value.id !== 'string' || !/^[a-f0-9]{32}$/.test(value.id))
-            throw new ConfigError('系统凭据引用无效。');
+            throw new ConfigError(t('config.invalidReference'));
         reference = value;
     }
     let cached;
@@ -78,18 +83,18 @@ export function parseConfig(input, env = process.env, resolver = resolveReferenc
         ids = `${env.TELEGRAM_CHAT_ID ?? ''},${env.TELEGRAM_CHAT_IDS ?? ''}`.split(',').map(v => v.trim()).filter(Boolean);
     }
     if (!Array.isArray(ids))
-        throw new ConfigError('telegram.chat_ids 需要是数组。');
+        throw new ConfigError(t('config.chatIdsArray'));
     const chatIds = [...new Set(ids.map(value => {
             if (typeof value !== 'string' && !(typeof value === 'number' && Number.isSafeInteger(value)))
-                throw new ConfigError('接收人需要使用数字 chat_id；大整数请写成字符串。');
+                throw new ConfigError(t('config.chatIdNumeric'));
             const id = String(value).trim();
             if (!/^-?[1-9][0-9]*$/.test(id))
-                throw new ConfigError('接收人需要是非零的数字 chat_id。');
+                throw new ConfigError(t('config.chatIdNonZero'));
             return id;
         }))];
     const token = secret(tg, 'token_env', 'TELEGRAM_BOT_TOKEN', env, () => stored('telegram_token'));
     if (token && !/^[0-9]+:[A-Za-z0-9_-]+$/.test(token))
-        throw new ConfigError('Telegram Token 格式不正确。');
+        throw new ConfigError(t('config.telegramToken'));
     const webhook = secret(fs, 'webhook_env', 'FEISHU_WEBHOOK', env, () => stored('feishu_webhook'));
     if (webhook) {
         let valid = false;
@@ -99,9 +104,9 @@ export function parseConfig(input, env = process.env, resolver = resolveReferenc
         }
         catch { /* 不输出含秘密的 URL 异常。 */ }
         if (!valid)
-            throw new ConfigError('飞书 webhook 需要是 open.feishu.cn 的 HTTPS 自定义机器人地址。');
+            throw new ConfigError(t('config.feishuWebhook'));
     }
-    return { telegram: { enabled: tgEnabled, token, chatIds }, feishu: { enabled: fsEnabled, webhook,
+    return { language, telegram: { enabled: tgEnabled, token, chatIds }, feishu: { enabled: fsEnabled, webhook,
             secret: secret(fs, 'secret_env', 'FEISHU_SECRET', env, () => stored('feishu_secret')) } };
 }
 export function ready(config, channel) {
@@ -113,9 +118,21 @@ export function decodeUtf8(data) {
         return new TextDecoder('utf-8', { fatal: true }).decode(data);
     }
     catch {
-        throw new ConfigError('输入需要是有效的 UTF-8 文本。');
+        throw new ConfigError(t('config.utf8'));
     }
 }
+export async function readConfigLanguage(file) {
+    try {
+        const data = JSON.parse(decodeUtf8(await readFile(file)));
+        return parseLocaleFromConfig(data?.language);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseLocaleFromConfig(value) {
+    return value === 'zh' || value === 'en' ? value : undefined;
+}
 export async function loadConfig(file, required = false, env = process.env) {
     let input = {};
     try {
@@ -124,18 +141,18 @@ export async function loadConfig(file, required = false, env = process.env) {
     catch (error) {
         if (error.code === 'ENOENT' && !required)
             return parseConfig({}, env);
-        throw new ConfigError('配置文件缺失、无法读取，或不是合法的 UTF-8 JSON。');
+        throw new ConfigError(t('config.unreadable'));
     }
     return parseConfig(input, env);
 }
-export async function createConfig(file) {
+export async function createConfig(file, language = getLocale()) {
     await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
     try {
-        await writeFile(file, JSON.stringify(example, null, 2) + '\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        await writeFile(file, JSON.stringify({ ...example, language }, null, 2) + '\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
     }
     catch (error) {
         if (error.code === 'EEXIST')
-            throw new ConfigError('配置已经存在，没有覆盖。Node 版不会修改旧版原型的配置。');
-        throw new ConfigError('无法创建配置，请检查路径和权限。');
+            throw new ConfigError(t('config.exists'));
+        throw new ConfigError(t('config.createFailed'));
     }
 }

package/dist/credentials.js

@@ -1,12 +1,13 @@
 // 只访问本工具的随机引用条目，不枚举系统凭据，不通过子进程传递秘密。
 import { createRequire } from 'node:module';
+import { t } from './i18n.js';
 export const SERVICE = 'dev-notify.node.credentials.v1';
 export class CredentialError extends Error {
 }
 const fields = ['telegram_token', 'feishu_webhook', 'feishu_secret'];
 export function validateId(id) {
     if (typeof id !== 'string' || !/^[0-9a-f]{32}$/.test(id))
-        throw new CredentialError('系统凭据引用无效。');
+        throw new CredentialError(t('credentials.invalidReference'));
 }
 export function decodeBundle(raw) {
     try {
@@ -18,7 +19,7 @@ export function decodeBundle(raw) {
         return result;
     }
     catch {
-        throw new CredentialError('系统凭据数据无效，请重新运行 setup。');
+        throw new CredentialError(t('credentials.invalidBundle'));
     }
 }
 export function encodeBundle(values) {
@@ -26,7 +27,7 @@ export function encodeBundle(values) {
     decodeBundle(encoded);
     // Windows Credential Manager 通用凭据 blob 上限 2560 字节，跨平台采用保守值。
     if (encoded.byteLength > 2400)
-        throw new CredentialError('凭据总长度超过 2400 字节，请检查输入；没有保存。');
+        throw new CredentialError(t('credentials.tooLong'));
     return encoded;
 }
 export class KeyringStore {
@@ -42,7 +43,7 @@ export class KeyringStore {
             return raw === null ? null : decodeBundle(Uint8Array.from(raw));
         }
         catch {
-            throw new CredentialError('无法读取系统凭据，或内容无效。请解锁系统凭据存储并允许访问，或重新运行 setup 配置。');
+            throw new CredentialError(t('credentials.readFailed'));
         }
     }
     create(id, values) {
@@ -52,12 +53,12 @@ export class KeyringStore {
         try {
             entry = this.entry(id);
             if (entry.getSecret() !== null)
-                throw new CredentialError('这个随机凭据引用已经存在，没有覆盖，请重试。');
+                throw new CredentialError(t('credentials.exists'));
         }
         catch (error) {
             if (error instanceof CredentialError)
                 throw error;
-            throw new CredentialError('无法访问系统凭据存储，请检查系统权限。');
+            throw new CredentialError(t('credentials.accessFailed'));
         }
         try {
             entry.setSecret(encoded);
@@ -68,9 +69,9 @@ export class KeyringStore {
                 entry.deleteCredential();
             }
             catch {
-                throw new CredentialError(`凭据写入状态未知，清理也失败了。请检查引用 ID：${id}`);
+                throw new CredentialError(t('credentials.writeUnknown', { id }));
             }
-            throw new CredentialError('系统凭据写入失败，配置没有切换。');
+            throw new CredentialError(t('credentials.writeFailed'));
         }
     }
     remove(id) {
@@ -79,27 +80,27 @@ export class KeyringStore {
             this.entry(id).deleteCredential();
         }
         catch {
-            throw new CredentialError('系统凭据删除失败，请检查存储权限。');
+            throw new CredentialError(t('credentials.deleteFailed'));
         }
     }
 }
 const require = createRequire(import.meta.url);
 export function nativeStore(platform = process.platform) {
     if (platform !== 'win32' && platform !== 'darwin')
-        throw new CredentialError('系统凭据仅支持 Windows 和 macOS；其他平台请使用环境变量。');
+        throw new CredentialError(t('credentials.platform'));
     try {
         const binding = require('@napi-rs/keyring');
         return new KeyringStore(binding.Entry);
     }
     catch {
-        throw new CredentialError('原生凭据组件无法加载。请确认 npm 安装保留了 optional 依赖，并且架构匹配；不会降级为明文存储。');
+        throw new CredentialError(t('credentials.nativeLoad'));
     }
 }
 export function resolveReference(reference) {
     if (reference.backend === 'system')
-        throw new CredentialError('这是旧版原型保存的凭据引用。请用 setup 重新输入并保存为 Node 凭据，或显式提供环境变量；不会自动读取或删除旧凭据。');
+        throw new CredentialError(t('credentials.oldReference'));
     const values = nativeStore().read(reference.id);
     if (values === null)
-        throw new CredentialError('系统凭据条目缺失，请运行 setup 重新配置。');
+        throw new CredentialError(t('credentials.missingEntry'));
     return values;
 }