@quecue/dev-notify 0.1.2 → 0.1.4

package/dist/reply-interactions.js

@@ -1,13 +1,14 @@
 import { randomBytes } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { stateTransaction, targetEpoch } from './reply-state.js';
 import { replyHint } from './reply-telegram.js';
 import { finishInteraction } from './reply-outcomes.js';
-export const INTERACTION_MS = 5 * 60 * 1000;
+export const INTERACTION_MS = 10 * 60 * 1000;
 export function questionsFrom(input) {
     if (!Array.isArray(input.questions) || input.questions.length < 1 || input.questions.length > 4)
-        throw new ConfigError('问题结构无效，请在本机回答。');
+        throw new ConfigError(t('reply.invalidQuestions'));
     const questions = input.questions;
     const seen = new Set();
     for (const q of questions) {
@@ -15,7 +16,7 @@ export function questionsFrom(input) {
             || typeof q.header !== 'string' || (q.multiSelect !== undefined && typeof q.multiSelect !== 'boolean') || !Array.isArray(q.options)
             || q.options.length < 2 || q.options.length > 4 || q.options.some(o => !o || typeof o.label !== 'string' || !o.label.trim()
             || typeof o.description !== 'string') || new Set(q.options.map(o => o.label)).size !== q.options.length) {
-            throw new ConfigError('问题结构无效，请在本机回答。');
+            throw new ConfigError(t('reply.invalidQuestions'));
         }
         seen.add(q.question);
     }
@@ -23,7 +24,7 @@ export function questionsFrom(input) {
 }
 export async function createInteraction(access, target, kind, input, call) {
     if (kind === 'permission' && access.policy.permissions !== true)
-        throw new ConfigError('未授权远程处理工具权限。');
+        throw new ConfigError(t('reply.permissionsNotAuthorized'));
     const questions = kind === 'question' ? questionsFrom(input) : [];
     const value = { id: randomBytes(16).toString('hex'), session: target.session, epoch: targetEpoch(target),
         updated: Date.now(), expires: Date.now() + INTERACTION_MS, kind, input: structuredClone(input), questions,
@@ -31,18 +32,18 @@ export async function createInteraction(access, target, kind, input, call) {
     await stateTransaction(access, state => {
         const current = state.sessions[target.session];
         if (!current || targetEpoch(current) !== value.epoch)
-            throw new ConfigError('会话目标发生了变化。');
+            throw new ConfigError(t('reply.targetChanged'));
         if (call) {
             const bound = state.calls[call];
             if (!bound || bound.ended || bound.request || bound.epoch !== value.epoch)
-                throw new ConfigError('调用已经结束或已绑定，没有创建远程问题。');
+                throw new ConfigError(t('reply.callUnavailable'));
             bound.request = value.id;
         }
         // 不同 tool_use_id 可并行；无绑定的单元级调用仍只保留一个活动交互。
         if (!call)
             for (const old of Object.values(state.requests))
                 if (old.session === target.session && !old.result) {
-                    finishInteraction(old, { kind: old.claimed ? 'unknown' : 'not-applied', text: '问题已切换，旧请求不再接受答案。' });
+                    finishInteraction(old, { kind: old.claimed ? 'unknown' : 'not-applied', reason: 'switched', text: t('reply.questionSwitched') });
                 }
         state.requests[value.id] = value;
         state.entries['token:' + value.id] = { session: target.session, epoch: value.epoch, request: value.id, updated: Date.now() };
@@ -56,51 +57,51 @@ export function interactionMarkup(value) {
     const prefix = `dn:q:${value.id}:${value.index}:`;
     const buttons = [];
     if (value.kind === 'permission') {
-        buttons.push([{ text: '✅ 本次允许', callback_data: prefix + 'a' }, { text: '⛔ 拒绝', callback_data: prefix + 'd' }]);
-        buttons.push([{ text: '✍️ 自定义拒绝说明', callback_data: prefix + 'c' }]);
+        buttons.push([{ text: t('reply.allowButton'), callback_data: prefix + 'a' }, { text: t('reply.denyButton'), callback_data: prefix + 'd' }]);
+        buttons.push([{ text: t('reply.customDenyButton'), callback_data: prefix + 'c' }]);
     }
     else {
         const q = value.questions[value.index];
         q.options.forEach((option, index) => buttons.push([{ text: (value.selected.includes(index) ? '☑ ' : '') + Array.from(option.label).slice(0, 60).join(''), callback_data: prefix + 'o' + index }]));
         if (q.multiSelect)
-            buttons.push([{ text: '提交所选项', callback_data: prefix + 's' }]);
-        buttons.push([{ text: '✍️ 自定义输入', callback_data: prefix + 'c' }]);
+            buttons.push([{ text: t('reply.submitSelected'), callback_data: prefix + 's' }]);
+        buttons.push([{ text: t('reply.customInput'), callback_data: prefix + 'c' }]);
     }
-    buttons.push([{ text: '关闭远程答题（本机仍可操作）', callback_data: prefix + 'l' }]);
+    buttons.push([{ text: t('reply.closeRemote'), callback_data: prefix + 'l' }]);
     return { inline_keyboard: buttons };
 }
 export function interactionContent(value) {
     if (value.kind === 'permission')
-        return '工具：' + String(value.input.tool_name || '未知') + '\n\n' + JSON.stringify(value.input.tool_input ?? {}, null, 2)
-            + '\n\n这里处理本次的允许、拒绝或自定义拒绝说明。Claude 没有提供完整的本地按钮列表，因此这里也不会创建永久权限规则。';
+        return t('reply.toolLabel', { tool: String(value.input.tool_name || t('reply.unknownTool')) }) + '\n\n' + JSON.stringify(value.input.tool_input ?? {}, null, 2)
+            + '\n\n' + t('reply.permissionNote');
     const q = value.questions[value.index];
-    return `问题 ${value.index + 1}/${value.questions.length}：${q.question}\n\n`
+    return t('reply.questionHeading', { index: value.index + 1, total: value.questions.length, question: q.question }) + '\n\n'
         + q.options.map((o, i) => `${i + 1}. ${o.label}\n${o.description}${o.preview ? '\n' + o.preview : ''}`).join('\n\n')
-        + (q.multiSelect ? '\n\n可多选，选好后点击「提交所选项」；也可自定义输入。' : '\n\n点击选项直接回答，或选择自定义输入。')
-        + '\n本机原生窗口也可以同时作答；Claude 先收到的完整答案生效。远程窗口有效期为 5 分钟，不会自动选择。';
+        + (q.multiSelect ? t('reply.multiSelectHint') : t('reply.singleSelectHint'))
+        + t('reply.localWindowNote');
 }
 // 飞书卡片没有回调按钮，只展示全部题目和跳转入口；逐题编号并空行分隔，避免题目与选项粘连。
 export function questionsContent(questions) {
-    return questions.map((q, index) => `问题 ${index + 1}/${questions.length}：${q.question}\n\n`
+    return questions.map((q, index) => t('reply.questionHeading', { index: index + 1, total: questions.length, question: q.question }) + '\n\n'
         + q.options.map((o, i) => `${i + 1}. ${o.label}\n${o.description}${o.preview ? '\n' + o.preview : ''}`).join('\n\n')
-        + (q.multiSelect ? '\n\n可多选：进入 Telegram 后逐项选择，再点击「提交所选项」；也可自定义输入。'
-            : '\n\n进入 Telegram 后点击选项直接回答，或选择自定义输入。')).join('\n\n────────\n\n');
+        + (q.multiSelect ? t('reply.feishuMultiSelectHint')
+            : t('reply.feishuSingleSelectHint'))).join('\n\n────────\n\n');
 }
 export async function showInteraction(access, id, chat, api) {
     const value = await stateTransaction(access, state => state.requests[id]);
     if (!active(value)) {
-        await replyHint(api, chat, '⚠️ 交互已失效', '请从最新通知进入，或回到本机处理。');
+        await replyHint(api, chat, t('reply.inactiveTitle'), t('reply.inactiveBody'));
         return;
     }
     // 使用通知分段器发送较长选项，所有选项正文保留，只有最后一段附选择按钮。
     const { makePlan, deliver } = await import('./channels.js');
     const { config } = access;
-    const plan = makePlan('telegram', { title: 'Claude Code 需要你处理', content: interactionContent(value), footer: '', level: 'warn' }, { ...config, telegram: { ...config.telegram, chatIds: [chat] } });
+    const plan = makePlan('telegram', { title: t('hook.notificationTitle'), content: interactionContent(value), footer: '', level: 'warn' }, { ...config, telegram: { ...config.telegram, chatIds: [chat] } });
     plan.items[plan.items.length - 1].payload.reply_markup = interactionMarkup(value);
     plan.onSent = async (item, response) => {
         const message = response.result?.message_id;
         if (!Number.isSafeInteger(message))
-            throw new ConfigError('交互通知没有返回消息 ID。');
+            throw new ConfigError(t('reply.noInteractionMessageId'));
         await stateTransaction(access, state => {
             const current = state.requests[id];
             if (current) {
@@ -119,7 +120,7 @@ export async function showInteraction(access, id, chat, api) {
     // API 封装由测试或真实桥接注入，不另建网络连接。
     const result = await deliver(plan, config, async (_url, payload) => ({ ok: true, result: await api('sendMessage', payload) }));
     if (!result.ok)
-        throw new ConfigError('交互通知没有完整发送，请回到本机处理。');
+        throw new ConfigError(t('reply.interactionNotSent'));
     await stateTransaction(access, state => {
         const current = state.requests[id];
         if (!current)
@@ -152,7 +153,7 @@ export async function handleInteractionCallback(access, callback, chat, api) {
         if (!active(value) || value.index !== Number(index) || !target || targetEpoch(target) !== value.epoch)
             return 'expired';
         if (operation === 'l') {
-            finishInteraction(value, { kind: 'not-applied', text: '已关闭远程答题，本机仍可正常处理。' });
+            finishInteraction(value, { kind: 'not-applied', reason: 'closed', text: t('reply.closedLocal') });
             return 'local';
         }
         const question = value.questions[value.index]?.question;
@@ -188,17 +189,17 @@ export async function handleInteractionCallback(access, callback, chat, api) {
         return operation === 'c' ? 'custom' : value.response ? 'done' : value.index !== previousIndex ? 'answered' : 'next';
     });
     await api('answerCallbackQuery', { callback_query_id: callback.id,
-        text: outcome === 'expired' ? '没有提交：按钮已失效，或已有答案等待确认。' : outcome === 'local' ? '已关闭远程答题，本机不受影响。' : outcome === 'done' || outcome === 'answered' ? '答案已登记，尚未确认生效。' : '已更新。' }).catch(() => { });
+        text: outcome === 'expired' ? t('reply.callbackExpired') : outcome === 'local' ? t('reply.callbackClosed') : outcome === 'done' || outcome === 'answered' ? t('reply.callbackRegistered') : t('reply.callbackUpdated') }).catch(() => { });
     if (outcome === 'done' || outcome === 'answered')
-        await replyHint(api, chat, '⏳ 答案已登记，等待确认', (outcome === 'answered' ? '仍需完成其余问题，之后才回传整份答案。' : '已进入回传流程，Claude 是否采用会在稍后反馈。')
-            + '\n稍后会反馈结果；如果一直没有收到，请检查终端。\n请求：' + id.slice(0, 8)).catch(() => { });
+        await replyHint(api, chat, t('reply.pendingConfirmationTitle'), (outcome === 'answered' ? t('reply.pendingRemaining') : t('reply.pendingSubmitted'))
+            + t('reply.pendingFooter', { id: id.slice(0, 8) })).catch(() => { });
     if (outcome === 'expired')
-        await replyHint(api, chat, '⚠️ 本次提交未生效', '这次操作没有提交：问题已处理、过期、题目已切换，或已有答案等待确认。\n请求：' + id.slice(0, 8)).catch(() => { });
+        await replyHint(api, chat, t('reply.notAppliedTitle'), t('reply.notAppliedBody', { id: id.slice(0, 8) })).catch(() => { });
     if (outcome === 'custom') {
         const value = await stateTransaction(access, state => state.requests[id]);
         if (!active(value))
             return true;
-        const sent = await replyHint(api, chat, '✍️ 自定义输入', value.kind === 'permission' ? '请回复这条消息，填写拒绝说明。这段说明不会批准权限。' : '请回复这条消息，输入这个问题的完整答案。', callback.message.message_id, { force_reply: true, selective: true });
+        const sent = await replyHint(api, chat, t('reply.customInput'), value.kind === 'permission' ? t('reply.denyInstruction') : t('reply.answerInstruction'), callback.message.message_id, { force_reply: true, selective: true });
         if (Number.isSafeInteger(sent?.message_id))
             await stateTransaction(access, state => {
                 state.entries[`tg:${chat}:${sent.message_id}`] = { session: value.session, epoch: value.epoch, request: id, question: value.index, updated: Date.now() };
@@ -211,7 +212,7 @@ export async function handleInteractionCallback(access, callback, chat, api) {
 export async function handleInteractionText(access, id, chat, message, api) {
     const text = message.text;
     if (!text.trim() || Array.from(text).length > 4000) {
-        await replyHint(api, chat, '❌ 答案没有提交', '请输入不超过 4000 字符的答案；内容不会被截断。', message.message_id);
+        await replyHint(api, chat, t('reply.answerInvalidTitle'), t('reply.answerInvalidBody'), message.message_id);
         return;
     }
     const outcome = await stateTransaction(access, state => {
@@ -231,9 +232,9 @@ export async function handleInteractionText(access, id, chat, message, api) {
             question, answer: value.kind === 'question' ? text : 'deny', custom: true });
         return value.response ? 'done' : 'next';
     });
-    await replyHint(api, chat, outcome === 'expired' ? '⚠️ 本次提交未生效' : '⏳ 答案已登记，等待确认', (outcome === 'done' ? '等待 Claude 确认，稍后会反馈最终结果；如果一直没有收到，请检查终端。'
-        : outcome === 'next' ? '仍需完成其余问题，之后才会回传整份答案；目前还没有生效。'
-            : '这次操作没有提交：对应问题已经结束、过期、切换，或已有答案等待确认。') + '\n请求：' + id.slice(0, 8));
+    await replyHint(api, chat, outcome === 'expired' ? t('reply.notAppliedTitle') : t('reply.pendingConfirmationTitle'), (outcome === 'done' ? t('reply.finalWaiting')
+        : outcome === 'next' ? t('reply.nextWaiting')
+            : t('reply.notSubmitted')) + t('reply.requestLine', { id: id.slice(0, 8) }));
     if (outcome === 'next')
         await showInteraction(access, id, chat, api);
 }
@@ -263,7 +264,7 @@ export async function waitInteraction(access, value, fresh, options = {}) {
     await stateTransaction(access, state => {
         const request = state.requests[value.id];
         if (request && !request.result)
-            finishInteraction(request, { kind: request.claimed ? 'unknown' : 'not-applied', text: options.signal?.aborted ? '交互等待已取消，远程答案是否生效还没有确认。' : '远程交互等待超时，尚未确认生效。你仍可在本机继续处理。' });
+            finishInteraction(request, { kind: request.claimed ? 'unknown' : 'not-applied', reason: options.signal?.aborted ? 'failed' : 'expired', text: options.signal?.aborted ? t('reply.interactionCancelled') : t('reply.expiredUnsentAnswer') });
     });
     return null;
 }

package/dist/reply-outcomes.js

@@ -1,4 +1,5 @@
 import { digest, stateTransaction, targetEpoch } from './reply-state.js';
+import { t } from './i18n.js';
 import { replyHint } from './reply-telegram.js';
 // PermissionRequest 没有 tool_use_id：只接受唯一且尚未结束的同输入调用，歧义时保留本机处理。
 function canonical(value) {
@@ -27,6 +28,20 @@ export function finishInteraction(value, result) {
         delete receipt.question;
     }
 }
+function endLabel(result) {
+    if (result.kind === 'unknown')
+        return t('reply.buttonUnknown');
+    if (result.kind === 'applied')
+        return t('reply.buttonApplied');
+    switch (result.reason) {
+        case 'expired': return t('reply.buttonExpired');
+        case 'session':
+        case 'switched': return t('reply.buttonInvalid');
+        case 'closed': return t('reply.buttonClosed');
+        case 'processed': return t('reply.buttonProcessed');
+        default: return t('reply.buttonEnded');
+    }
+}
 export function endSessionInteractions(state, session, reason) {
     for (const call of Object.values(state.calls))
         if (call.session === session)
@@ -34,8 +49,8 @@ export function endSessionInteractions(state, session, reason) {
     for (const value of Object.values(state.requests))
         if (value.session === session && !value.result)
             finishInteraction(value, {
-                kind: value.claimed ? 'unknown' : 'not-applied',
-                text: value.claimed ? reason + '；还没有收到本次答案的生效确认，请检查终端。' : reason + '；这次远程答案没有回传。',
+                kind: value.claimed ? 'unknown' : 'not-applied', reason: 'session',
+                text: reason + (value.claimed ? t('reply.sessionUnknownSuffix') : t('reply.sessionUnsentSuffix')),
             });
 }
 export async function registerToolCall(access, target, data) {
@@ -92,24 +107,24 @@ export async function completeToolCall(access, data) {
                 const q = value.questions.find(q => q.question === receipt.question);
                 const exists = valid && answered && receipt.question !== undefined && Object.hasOwn(answers, receipt.question)
                     && !output.annotations?.[receipt.question]?.unanswered;
-                receipt.result = !value.claimed ? { kind: 'not-applied', text: '本机或其他端已经先处理了，这次 Telegram 答案没有提交。' }
-                    : !valid ? { kind: 'unknown', text: 'Claude 已经结束了这个问题，但没有返回可核实的结果。请检查终端。' }
+                receipt.result = !value.claimed ? { kind: 'not-applied', text: t('reply.earlierHandled') }
+                    : !valid ? { kind: 'unknown', text: t('reply.noVerifiableResult') }
                         : exists && sameAnswer(answers[receipt.question], receipt.answer, q?.multiSelect === true && receipt.custom !== true && q.options.every(o => !o.label.includes(',')))
-                            ? { kind: 'applied', text: 'Claude 已确认采用了与你提交内容一致的答案。如果本机也提交了相同内容，这次结果无法说明是哪一方生效。' }
-                            : { kind: 'not-applied', text: 'Claude 已经结束问题，但没有采用你提交的答案；本机或其他端可能已经先处理。' };
+                            ? { kind: 'applied', text: t('reply.answerApplied') }
+                            : { kind: 'not-applied', text: t('reply.answerNotApplied') };
             }
-            finishInteraction(value, { kind: 'not-applied', text: '问题已处理，旧按钮已失效。' });
+            finishInteraction(value, { kind: 'not-applied', reason: 'processed', text: t('reply.questionProcessed') });
         }
         else if (data.hook_event_name === 'PostToolUse' && value.kind === 'permission') {
             const allow = value.claimed && value.receipts?.some(r => r.answer === 'allow');
             finishInteraction(value, allow
-                ? { kind: 'applied', text: '工具已获准并执行完成。如果本机同时也批准了，完成事件本身无法说明是哪一方放行。' }
-                : { kind: 'not-applied', text: '工具已经获准执行，这次远程决定没有阻止执行。' });
+                ? { kind: 'applied', reason: 'processed', text: t('reply.permissionApplied') }
+                : { kind: 'not-applied', reason: 'processed', text: t('reply.permissionNotApplied') });
         }
         else
-            finishInteraction(value, { kind: value.claimed ? 'unknown' : 'not-applied', text: value.claimed
-                    ? '工具执行失败、被拒绝或取消。这个事件无法说明远程决定是否生效，请检查终端。'
-                    : '请求失败、被拒绝或取消，这次远程决定没有回传。' });
+            finishInteraction(value, { kind: value.claimed ? 'unknown' : 'not-applied', reason: 'failed', text: value.claimed
+                    ? t('reply.toolFailedUnknown')
+                    : t('reply.toolFailed') });
     });
 }
 export async function drainInteractionFeedback(access, api, fresh, log = () => { }) {
@@ -118,13 +133,21 @@ export async function drainInteractionFeedback(access, api, fresh, log = () => {
         return;
     const work = await stateTransaction(access, state => {
         for (const value of Object.values(state.requests)) {
+            if (value.result)
+                continue;
             const target = state.sessions[value.session];
-            if (!value.result && (!target || targetEpoch(target) !== value.epoch || value.expires <= Date.now()))
-                finishInteraction(value, {
-                    kind: value.claimed ? 'unknown' : 'not-applied', text: value.claimed
-                        ? '等待生效确认超时，或会话已经切换。结果暂时未知，请检查终端。'
-                        : '交互已过期或会话已结束；远程答案没有回传，你仍可在本机界面继续处理。',
-                });
+            const ended = !target || targetEpoch(target) !== value.epoch;
+            if (!ended && value.expires > Date.now())
+                continue;
+            finishInteraction(value, {
+                kind: value.claimed ? 'unknown' : 'not-applied',
+                reason: ended ? 'session' : 'expired',
+                text: value.claimed
+                    ? t('reply.waitTimeoutUnknown')
+                    : ended
+                        ? t('reply.sessionEndedUnsent')
+                        : t('reply.expiredUnanswered'),
+            });
         }
         return Object.values(state.requests).filter(value => value.result || value.receipts?.some(r => r.result));
     });
@@ -146,12 +169,12 @@ export async function drainInteractionFeedback(access, api, fresh, log = () => {
                 continue;
             let delivery = 'sent';
             try {
-                const title = receipt.result.kind === 'applied' ? '✅ 答案内容已生效' : receipt.result.kind === 'not-applied' ? '⚠️ 本次提交未生效' : '⚠️ 提交结果暂时无法确认';
-                await replyHint(api, receipt.chat, title, receipt.result.text + '\n请求：' + value.id.slice(0, 8));
+                const title = receipt.result.kind === 'applied' ? t('reply.appliedTitle') : receipt.result.kind === 'not-applied' ? t('reply.notAppliedTitle') : t('reply.resultUnknownTitle');
+                await replyHint(api, receipt.chat, title, receipt.result.text + t('reply.requestLabel', { id: value.id.slice(0, 8) }));
             }
             catch {
                 delivery = 'unknown';
-                log('Telegram 结果反馈没有发送成功。不会自动重发，已经采用的答案不受影响。');
+                log(t('reply.feedbackFailedLog'));
             }
             await stateTransaction(access, state => {
                 const actual = state.requests[value.id]?.receipts?.find(r => r.id === receipt.id);
@@ -173,10 +196,10 @@ export async function drainInteractionFeedback(access, api, fresh, log = () => {
                 if (actual)
                     actual.cleared = true;
             });
-            const label = value.result.kind === 'unknown' ? '已关闭 · 结果待核实' : value.result.text.includes('过期') ? '已过期 · 不再接受答案' : '已处理 · 不再接受答案';
+            const label = endLabel(value.result);
             await api('editMessageReplyMarkup', { chat_id: message.chat, message_id: message.message,
                 reply_markup: { inline_keyboard: [[{ text: label, callback_data: `dn:q:${value.id}:0:l` }]] } })
-                .catch(() => log('Telegram 旧按钮没有移除成功。服务端仍会拒绝这个请求。'));
+                .catch(() => log(t('reply.clearButtonsFailedLog')));
         }
     }
 }

package/dist/reply-platform.js

@@ -3,12 +3,13 @@ import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { homedir } from 'node:os';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { claudeSettingsPath } from './claude-code.js';
 export const runCommand = (command, args, input = '') => new Promise((resolve, reject) => {
     const child = spawn(command, args, { windowsHide: true, shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
     let stdout = '', overflow = false;
-    const timer = setTimeout(() => { child.kill(); reject(new ConfigError('系统会话操作超时。输入可能已经部分送达，为避免重复提交，不会自动重试。')); }, 15000);
-    const fail = () => { clearTimeout(timer); reject(new ConfigError('系统会话操作失败。为了避免泄露命令或输入，这里不显示底层信息。')); };
+    const timer = setTimeout(() => { child.kill(); reject(new ConfigError(t('reply.platformTimeout'))); }, 15000);
+    const fail = () => { clearTimeout(timer); reject(new ConfigError(t('reply.platformFailed'))); };
     child.on('error', fail);
     child.stdin.on('error', () => { });
     child.stdout.on('data', data => { if (stdout.length + data.length > 1024 * 1024) {
@@ -28,12 +29,12 @@ function powershell(script, input, runner) {
 const READ_PROCESS = `$ErrorActionPreference='Stop'; [Console]::InputEncoding=[Text.UTF8Encoding]::new($false); $x=[Console]::In.ReadToEnd()|ConvertFrom-Json; $p=Get-Process -Id $x.pid; if($p.ProcessName -ne 'claude'){exit 3}; @{birth=$p.StartTime.ToUniversalTime().Ticks.ToString()}|ConvertTo-Json -Compress`;
 export function sanitizeReply(text) {
     if (typeof text !== 'string' || !text.trim())
-        throw new ConfigError('回复内容不能为空。');
+        throw new ConfigError(t('reply.emptyReply'));
     if (Array.from(text).length > 4000)
-        throw new ConfigError('回复超过 4000 字符，没有提交。内容不会被截断，也不会拆成多次发送。');
+        throw new ConfigError(t('reply.replyTooLong'));
     const value = text.replace(/\r\n|[\r\n\u2028\u2029]/g, ' ').replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').trim();
     if (!value)
-        throw new ConfigError('回复清理后没有可提交的内容。');
+        throw new ConfigError(t('reply.emptyAfterCleanup'));
     return value;
 }
 export async function processIdentity(pid, platform = process.platform, runner = runCommand) {
@@ -166,15 +167,15 @@ if([DevNotifyConsole]::Send([uint32]$x.pid,[string]$x.text)){exit 0}else{exit 4}
 export async function injectReply(target, text, options = {}) {
     const safe = sanitizeReply(text), runner = options.runner ?? runCommand, platform = options.platform ?? process.platform;
     if (!await validateTarget(target, options))
-        throw new ConfigError('会话已经关闭、切换，或无法核验身份。请从最新通知回复。');
+        throw new ConfigError(t('reply.targetInvalid'));
     if (platform === 'win32') {
         const result = await powershell(WINDOWS_INJECT, { pid: target.pid, birth: target.birth, text: safe }, runner);
         if (result.code !== 0)
-            throw new ConfigError('Windows 控制台注入失败，可能只写入了一部分。不会自动重试，请检查终端。');
+            throw new ConfigError(t('reply.windowsPartial'));
         return;
     }
     if (platform !== 'darwin')
-        throw new ConfigError('远程回复仅支持 Windows 和 macOS。');
+        throw new ConfigError(t('reply.unsupportedPlatform'));
     // 先确定 tmux pane，字面文本通过 stdin 缓冲区传入，绝不作为 shell 或按键名称执行。
     let listing = null;
     try {
@@ -186,14 +187,14 @@ export async function injectReply(target, text, options = {}) {
         const name = 'dev-notify-' + target.pid + '-' + Date.now();
         const loaded = await runner('tmux', ['load-buffer', '-b', name, '-'], safe);
         if (loaded.code !== 0)
-            throw new ConfigError('tmux 输入缓冲区创建失败，这次回复没有提交。');
+            throw new ConfigError(t('reply.tmuxBufferFailed'));
         try {
             if (!await validateTarget(target, options))
-                throw new ConfigError('会话已经变化，这次回复没有提交。');
+                throw new ConfigError(t('reply.tmuxChanged'));
             if ((await runner('tmux', ['paste-buffer', '-d', '-b', name, '-t', pane])).code !== 0)
-                throw new ConfigError('tmux 粘贴失败，可能只送达了一部分。不会自动重试。');
+                throw new ConfigError(t('reply.tmuxPasteFailed'));
             if ((await runner('tmux', ['send-keys', '-t', pane, 'Enter'])).code !== 0)
-                throw new ConfigError('tmux 提交失败，文本可能已经输入。不会自动重试。');
+                throw new ConfigError(t('reply.tmuxSubmitFailed'));
         }
         finally {
             await runner('tmux', ['delete-buffer', '-b', name]).catch(() => { });
@@ -205,5 +206,5 @@ export async function injectReply(target, text, options = {}) {
     const script = `tell application "Ghostty"\nrepeat with w in windows\nrepeat with t in terminals of w\nif tty of t is "${escape(target.tty)}" then\nperform action "${escape(action)}" on t\nreturn "ok"\nend if\nend repeat\nend repeat\nreturn "notfound"\nend tell`;
     const result = await runner('/usr/bin/osascript', ['-'], script);
     if (result.code !== 0 || result.stdout.trim() !== 'ok')
-        throw new ConfigError('Ghostty 没有找到目标窗口，或注入失败。不会改投其他窗口，也不会重复输入。');
+        throw new ConfigError(t('reply.ghosttyFailed'));
 }

package/dist/reply-state.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { randomBytes, createHash } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { ConfigError, decodeUtf8, loadConfig, ready } from './config.js';
+import { joinList, t } from './i18n.js';
 import { replyHooksReady } from './claude-code.js';
 export const TTL = 24 * 60 * 60 * 1000;
 export const digest = (text) => createHash('sha256').update(text).digest('hex');
@@ -20,7 +21,7 @@ export async function readJson(file) {
     catch (error) {
         if (error.code === 'ENOENT')
             return null;
-        throw new ConfigError('无法读取回复配置或状态。为了不覆盖现有数据，远程输入没有启用。');
+        throw new ConfigError(t('reply.readFailed'));
     }
 }
 export async function atomicJson(file, value) {
@@ -52,9 +53,9 @@ export async function locked(file, work) {
         }
         catch (error) {
             if (error.code !== 'EEXIST')
-                throw new ConfigError('无法获取回复状态写入锁。');
+                throw new ConfigError(t('reply.lockUnavailable'));
             if (attempt === 99)
-                throw new ConfigError('回复状态锁正忙。请确认相关进程已经退出，再处理残留锁。');
+                throw new ConfigError(t('reply.lockBusy'));
             await delay(40);
         }
     }
@@ -73,16 +74,16 @@ export async function accessReplies(file, env = process.env) {
     if (policy.version !== 1 || policy.enabled !== true || typeof policy.bot !== 'string' || !/^[a-f0-9]{64}$/.test(policy.bot)
         || typeof policy.generation !== 'string' || !/^[a-f0-9]{32}$/.test(policy.generation)
         || !Array.isArray(policy.users) || !policy.users.length || policy.users.some((id) => typeof id !== 'string' || !/^[1-9][0-9]*$/.test(id))) {
-        throw new ConfigError('回复授权配置无效，远程输入已停用。');
+        throw new ConfigError(t('reply.invalidPolicy'));
     }
     if (!await replyHooksReady(file, { env }))
-        throw new ConfigError('回复所需的 hooks 缺失、时序不安全或已禁用。请重新运行 integration claude-code install，并在 /hooks 中确认加载。');
+        throw new ConfigError(t('reply.hooksMissing'));
     const config = await loadConfig(file, true, env);
     if (!ready(config, 'telegram') || botKey(config) !== policy.bot)
-        throw new ConfigError('Telegram Bot 已变更或不可用，请重新运行 reply setup 授权。');
+        throw new ConfigError(t('reply.botChanged'));
     const users = policy.users.filter((id) => config.telegram.chatIds.includes(id));
     if (!users.length)
-        throw new ConfigError('授权用户不在当前 Telegram 接收名单中，远程输入已停用。');
+        throw new ConfigError(t('reply.usersRevoked'));
     const effective = { ...policy, users };
     return { file, config, policy: effective, identity: digest(JSON.stringify([policy.bot, policy.generation, users, policy.permissions === true])) };
 }
@@ -92,7 +93,7 @@ export async function stateTransaction(access, work) {
         const policy = await readJson(policyPath(access.file));
         if (!policy?.enabled || policy.bot !== access.policy.bot || policy.generation !== access.policy.generation
             || (policy.permissions === true) !== (access.policy.permissions === true))
-            throw new ConfigError('回复授权已撤销或发生变化，没有写入旧状态。');
+            throw new ConfigError(t('reply.authorizationChanged'));
         let state = await readJson(path.join(directory, 'state.json'));
         if (!state || state.identity !== access.identity)
             state = { version: 1, identity: access.identity, offset: 0, sessions: {}, entries: {}, pending: {}, requests: {}, calls: {} };
@@ -101,7 +102,7 @@ export async function stateTransaction(access, work) {
         state.calls ??= {};
         if (state.version !== 1 || !Number.isSafeInteger(state.offset) || state.offset < 0
             || ![state.sessions, state.entries, state.pending, state.requests, state.calls].every(record))
-            throw new ConfigError('回复状态结构无效，远程输入已停用。');
+            throw new ConfigError(t('reply.invalidState'));
         const now = Date.now();
         for (const section of [state.sessions, state.entries, state.pending, state.requests, state.calls])
             for (const [key, value] of Object.entries(section)) {
@@ -136,54 +137,54 @@ export async function stateTransaction(access, work) {
 }
 export async function configureReplies(file, prompts, env = process.env) {
     if (!await replyHooksReady(file, { env }))
-        throw new ConfigError('请先运行 integration claude-code install，安装绑定此通知配置的完整 hooks，再配置回复。');
+        throw new ConfigError(t('reply.setupHooksFirst'));
     const config = await loadConfig(file, true, env);
     if (!ready(config, 'telegram'))
-        throw new ConfigError('回复 Claude 需要先配置 Telegram Bot 和私聊接收人。');
+        throw new ConfigError(t('reply.setupTelegramFirst'));
     const available = config.telegram.chatIds.filter(id => /^[1-9][0-9]*$/.test(id));
     if (!available.length)
-        throw new ConfigError('远程回复仅支持 Telegram 私聊用户，不支持群聊。');
+        throw new ConfigError(t('reply.setupPrivateOnly'));
     const before = await readJson(policyPath(file));
-    prompts.out('远程回复等同于在本机 Claude Code 终端输入并提交内容。它可以提交 Claude 命令，但不会自动批准工具权限。请只授权给可信用户。');
-    prompts.out('飞书按钮会跳转到 Telegram，不直接接收飞书消息。这个功能需要独占 Bot 的 getUpdates，请不要与旧版桥接或其他机器共用同一个 Bot。');
-    prompts.out('Windows 使用系统 PowerShell / 控制台 API；macOS 使用 Ghostty 或 tmux，需要相应的系统权限。');
-    prompts.out('目前不支持 VS Code 集成终端、WSL 和 SSH。目标不确定或会话已经切换时，会拒绝输入。');
-    prompts.out('通知接收人不会自动获得输入权限。可选择的私聊 chat_id：' + available.join('、'));
-    const text = await prompts.text('请输入要授权的私聊 chat_id（逗号分隔；留空取消）：');
+    prompts.out(t('reply.setupNoticeInput'));
+    prompts.out(t('reply.setupNoticeBridge'));
+    prompts.out(t('reply.setupNoticePlatform'));
+    prompts.out(t('reply.setupNoticeUnsupported'));
+    prompts.out(t('reply.setupAvailable', { users: joinList(available) }));
+    const text = await prompts.text(t('reply.setupPrompt'));
     if (!text.trim())
         return false;
     const users = [...new Set(text.split(',').map(id => id.trim()))];
     if (users.some(id => !available.includes(id)))
-        throw new ConfigError('只能授权当前通知名单中的私聊用户。');
-    prompts.out('将授权以下用户远程输入：' + users.join('、'));
-    prompts.out('结构化问题会展示真实选项，也支持自定义回答；普通回复会在本轮结束后输入。问题、选项和工具请求参数可能包含敏感信息，会发送到授权私聊和已配置的飞书。');
-    const permissions = /^(y|yes)$/i.test(await prompts.text('是否允许这些用户逐次批准或拒绝工具权限？这不会修改永久规则。[y/N] '));
-    if (!/^(y|yes)$/i.test(await prompts.text('确认启用远程回复并接受上述权限范围？[y/N] ')))
+        throw new ConfigError(t('reply.setupInvalidUser'));
+    prompts.out(t('reply.setupAuthorizing', { users: joinList(users) }));
+    prompts.out(t('reply.setupSensitive'));
+    const permissions = /^(y|yes)$/i.test(await prompts.text(t('reply.setupPermissionsPrompt')));
+    if (!/^(y|yes)$/i.test(await prompts.text(t('reply.setupConfirm'))))
         return false;
     await locked(policyPath(file) + '.lock', async () => {
         if (JSON.stringify(before) !== JSON.stringify(await readJson(policyPath(file))))
-            throw new ConfigError('回复授权已被其他进程修改，请重试。');
+            throw new ConfigError(t('reply.setupChanged'));
         const effective = await loadConfig(file, true, env);
         if (botKey(effective) !== botKey(config) || users.some(id => !effective.telegram.chatIds.includes(id)))
-            throw new ConfigError('通知配置在授权期间发生了变化，请重试。');
+            throw new ConfigError(t('reply.setupConfigChanged'));
         await atomicJson(policyPath(file), { version: 1, enabled: true, bot: botKey(config), users, permissions, generation: randomBytes(16).toString('hex') });
     });
-    prompts.out('授权已保存。旧消息的回复映射不会保留；请从启用后的任务完成通知进入。');
+    prompts.out(t('reply.setupSaved'));
     return true;
 }
 export async function disableReplies(file, prompts) {
     const before = await readJson(policyPath(file));
     if (!before?.enabled) {
-        prompts.out('远程回复尚未启用。');
+        prompts.out(t('reply.disableNotEnabled'));
         return true;
     }
-    if (!/^(y|yes)$/i.test(await prompts.text('确认禁用远程回复？通知和凭据都会保留。[y/N] ')))
+    if (!/^(y|yes)$/i.test(await prompts.text(t('reply.disableConfirm'))))
         return false;
     await locked(policyPath(file) + '.lock', async () => {
         if (JSON.stringify(before) !== JSON.stringify(await readJson(policyPath(file))))
-            throw new ConfigError('回复授权发生了变化，请重试。');
+            throw new ConfigError(t('reply.disableChanged'));
         await atomicJson(policyPath(file), { ...before, enabled: false });
     });
-    prompts.out('远程回复已禁用。正在进行的操作无法撤回，桥接会在下次检查时退出。');
+    prompts.out(t('reply.disabled'));
     return true;
 }

package/dist/reply-telegram.js

@@ -1,14 +1,15 @@
 import { requestJson } from './channels.js';
 import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 export function telegramApi(token, request = requestJson) {
     return async (method, payload) => {
         if (!['sendMessage', 'editMessageReplyMarkup', 'answerCallbackQuery', 'getMe', 'getUpdates', 'getWebhookInfo'].includes(method))
-            throw new ConfigError('不支持的 Telegram 桥接方法');
+            throw new ConfigError(t('reply.telegramMethod'));
         const response = await request(`https://api.telegram.org/bot${token}/${method}`, payload);
         if (response.ok !== true) {
             if (response.error_code === 409)
-                throw new ConfigError('Telegram 轮询冲突；检查旧版桥接、其他机器或 webhook，桥接不会抢占或删除 webhook');
-            throw new ConfigError('Telegram 桥接请求失败；不输出服务端正文或秘密');
+                throw new ConfigError(t('reply.telegramConflict'));
+            throw new ConfigError(t('reply.telegramRequestFailed'));
         }
         return response.result;
     };