@quecue/dev-notify 0.1.3 → 0.1.5

package/dist/channels.js

@@ -1,7 +1,9 @@
 import { createHmac } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
+import { ConfigError } from './config.js';
+import { t } from './i18n.js';
 import { escapeHtml, feishuParts, parseMarkdown, partTitle, telegramParts } from './formatting.js';
-export class TransportError extends Error {
+export class TransportError extends ConfigError {
 }
 const icons = { info: 'ℹ️', success: '✅', warn: '⚠️', error: '❌' };
 const colors = { info: 'blue', success: 'green', warn: 'yellow', error: 'red' };
@@ -11,7 +13,7 @@ export async function requestJson(url, payload, fetcher = fetch) {
         const response = await fetcher(url, { method: 'POST', body: JSON.stringify(payload),
             headers: { 'Content-Type': 'application/json' }, redirect: 'error', signal: AbortSignal.timeout(10000) });
         if (!response.body)
-            throw new TransportError('服务端没有返回内容。');
+            throw new TransportError(t('channels.noResponse'));
         const reader = response.body.getReader();
         const chunks = [];
         let size = 0;
@@ -23,7 +25,7 @@ export async function requestJson(url, payload, fetcher = fetch) {
                 size += value.byteLength;
                 if (size > 1024 * 1024) {
                     await reader.cancel();
-                    throw new TransportError('服务端响应过大，已停止读取。');
+                    throw new TransportError(t('channels.responseTooLarge'));
                 }
                 chunks.push(value);
             }
@@ -33,13 +35,13 @@ export async function requestJson(url, payload, fetcher = fetch) {
         }
         const result = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
         if (!result || typeof result !== 'object' || Array.isArray(result))
-            throw new TransportError('服务端返回的不是 JSON 对象。');
+            throw new TransportError(t('channels.notJsonObject'));
         return result;
     }
     catch (error) {
         if (error instanceof TransportError)
             throw error;
-        throw new TransportError('网络请求失败或响应无效。为避免重复通知，不会自动重发；这条消息可能没有送达。');
+        throw new TransportError(t('channels.network'));
     }
 }
 function text(title, content, footer, icon, html) {
@@ -57,13 +59,13 @@ function card(message, title, content) {
     if (message.footer)
         elements.push({ tag: 'hr' }, { tag: 'note', elements: [{ tag: 'plain_text', content: message.footer }] });
     if (message.reply?.url)
-        elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: '💬 在 Telegram 回复 Claude' }, url: message.reply.url, type: 'primary' }] });
+        elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: t('channels.feishuReplyButton') }, url: message.reply.url, type: 'primary' }] });
     return { msg_type: 'interactive', card: { config: { wide_screen_mode: true },
             header: { template: colors[message.level], title: { tag: 'plain_text', content: title } }, elements } };
 }
 export function makePlan(channel, message, config) {
     if (!message.title.trim())
-        throw new Error('通知标题不能为空。');
+        throw new Error(t('channels.emptyTitle'));
     const blocks = parseMarkdown(message.content);
     if (channel === 'telegram') {
         const icon = icons[message.level];
@@ -76,10 +78,10 @@ export function makePlan(channel, message, config) {
                 const title = partTitle(message.title, index, chunks.length);
                 const plain = text(title, chunk.plain, message.footer, icon, false);
                 if (plain.length > 4096)
-                    throw new Error('Telegram 分段后仍然超过消息长度限制。');
+                    throw new Error(t('channels.telegramTooLong'));
                 items.push({ recipient: chatId, plain, payload: { chat_id: chatId,
                         text: text(title, chunk.html, message.footer, icon, true), parse_mode: 'HTML', disable_web_page_preview: true,
-                        ...(message.reply?.users.includes(chatId) ? { reply_markup: { inline_keyboard: [[{ text: '💬 回复 Claude', callback_data: 'dn:r:' + message.reply.token }]] } } : {}) } });
+                        ...(message.reply?.users.includes(chatId) ? { reply_markup: { inline_keyboard: [[{ text: t('channels.telegramReplyButton'), callback_data: 'dn:r:' + message.reply.token }]] } } : {}) } });
             });
         return { channel, items, recipients: config.telegram.chatIds.length };
     }
@@ -88,7 +90,7 @@ export function makePlan(channel, message, config) {
     const items = chunks.map((chunk, index) => {
         const payload = card(message, partTitle(message.title, index, chunks.length), chunk);
         if (bytes(payload) + 128 > 28000)
-            throw new Error('飞书分段后仍然超过请求大小限制。');
+            throw new Error(t('channels.feishuTooLong'));
         return { recipient: 'feishu', payload };
     });
     return { channel, items, recipients: 1 };
@@ -144,12 +146,12 @@ export async function deliver(plan, config, request = requestJson, sleep = delay
             }
             else {
                 failed.add(item.recipient);
-                error = '渠道拒绝了这次发送。请检查凭据、接收人授权、签名和频率限制。';
+                error = t('channels.rejected');
             }
         }
         catch (cause) {
             failed.add(item.recipient);
-            error = cause instanceof TransportError ? cause.message : '发送失败，这条消息可能没有送达。';
+            error = cause instanceof TransportError ? cause.message : t('channels.sendFailed');
         }
         if (!telegram && !failed.has(item.recipient) && index + 1 < plan.items.length)
             await sleep(250);

package/dist/claude-code.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomBytes } from 'node:crypto';
 import { ConfigError, decodeUtf8 } from './config.js';
+import { t } from './i18n.js';
 export const HOOK_MARKER = 'dev-notify:claude-code:v1';
 export const NOTIFICATION_MATCHER = 'permission_prompt|elicitation_dialog|elicitation_url_dialog|agent_needs_input';
 export const EVENTS = ['Stop', 'Notification', 'SessionStart', 'UserPromptSubmit', 'SessionEnd', 'PreToolUse', 'PermissionRequest', 'PostToolUse', 'PostToolUseFailure', 'PermissionDenied'];
@@ -13,7 +14,7 @@ export function claudeSettingsPath(env = process.env, home = homedir(), platform
     const join = platform === 'win32' ? path.win32 : path.posix;
     const root = env.CLAUDE_CONFIG_DIR || join.join(home, '.claude');
     if (!join.isAbsolute(root))
-        throw new ConfigError('CLAUDE_CONFIG_DIR 需要是绝对路径，Claude Code 设置没有改动');
+        throw new ConfigError(t('claude.settingsAbsolute'));
     return join.join(root, 'settings.json');
 }
 function settingsFile(options) {
@@ -23,7 +24,7 @@ async function snapshot(file) {
     try {
         const bytes = await readFile(file);
         if (bytes.length > 1024 * 1024)
-            throw new ConfigError('Claude Code 设置超过 1 MiB，操作已停止，文件没有改动。');
+            throw new ConfigError(t('claude.settingsTooLarge'));
         return bytes;
     }
     catch (error) {
@@ -31,7 +32,7 @@ async function snapshot(file) {
             return null;
         if (error instanceof ConfigError)
             throw error;
-        throw new ConfigError('无法读取 Claude Code 设置，操作已停止。');
+        throw new ConfigError(t('claude.settingsReadFailed'));
     }
 }
 function parseSettings(before) {
@@ -40,17 +41,17 @@ function parseSettings(before) {
         data = before === null ? {} : JSON.parse(decodeUtf8(before));
     }
     catch {
-        throw new ConfigError('Claude Code 设置不是合法的 UTF-8 JSON，没有覆盖。');
+        throw new ConfigError(t('claude.settingsInvalidJson'));
     }
     if (!record(data) || (data.hooks !== undefined && !record(data.hooks)))
-        throw new ConfigError('Claude Code 设置或 hooks 结构无效，没有覆盖。');
+        throw new ConfigError(t('claude.settingsInvalidShape'));
     for (const event of EVENTS) {
         const groups = data.hooks?.[event];
         if (groups === undefined)
             continue;
         if (!Array.isArray(groups) || groups.some(group => !record(group) || !Array.isArray(group.hooks)
             || group.hooks.some((hook) => !record(hook))))
-            throw new ConfigError('Claude Code hook 数组结构无效，没有覆盖。');
+            throw new ConfigError(t('claude.hooksInvalidShape'));
     }
     return data;
 }
@@ -117,7 +118,7 @@ function merged(data, config, runtime) {
         if (config !== null) {
             const handler = { type: 'command', command: runtime.node,
                 args: [runtime.cli, 'integration', 'claude-code', 'hook', '--config', config],
-                ...(event === 'Notification' ? { async: true } : { timeout: event === 'PermissionRequest' ? 360 : event === 'PreToolUse' ? 10 : 120 }), statusMessage: HOOK_MARKER };
+                ...(event === 'Notification' ? { async: true } : { timeout: event === 'PermissionRequest' ? 720 : event === 'PreToolUse' ? 10 : 120 }), statusMessage: HOOK_MARKER };
             const matcher = event === 'Notification' ? NOTIFICATION_MATCHER : null;
             groups.push(matcher ? { matcher, hooks: [handler] } : { hooks: [handler] });
         }
@@ -152,14 +153,14 @@ async function commit(file, before, target, prompts, replace = rename) {
         lock = await open(lockFile, 'wx', 0o600);
     }
     catch {
-        throw new ConfigError('暂时无法获取 Claude Code 设置写入锁。请确认没有安装进程在运行，再处理残留的 .dev-notify.lock。');
+        throw new ConfigError(t('claude.lockUnavailable'));
     }
     const temporary = path.join(path.dirname(file), `.dev-notify-${randomBytes(16).toString('hex')}.tmp`);
     let created = false;
     try {
         await lock.close();
         if (!same(before, await snapshot(file)))
-            throw new ConfigError('Claude Code 设置在确认期间发生了变化，没有覆盖，请重试。');
+            throw new ConfigError(t('claude.changedDuringConfirm'));
         const stream = await open(temporary, 'wx', 0o600);
         created = true;
         try {
@@ -170,7 +171,7 @@ async function commit(file, before, target, prompts, replace = rename) {
             await stream.close();
         }
         if (!same(before, await snapshot(file)))
-            throw new ConfigError('Claude Code 设置在保存期间发生了变化，没有覆盖，请重试。');
+            throw new ConfigError(t('claude.changedDuringSave'));
         await replace(temporary, file);
     }
     finally {
@@ -179,14 +180,14 @@ async function commit(file, before, target, prompts, replace = rename) {
                 await remove(temporary);
             }
             catch {
-                prompts.out('临时文件清理失败。安装结束后请删除 .dev-notify-*.tmp。');
+                prompts.out(t('claude.tempCleanupFailed'));
             }
         }
         try {
             await remove(lockFile);
         }
         catch {
-            prompts.out('锁文件清理失败。安装结束后请删除 .dev-notify.lock。');
+            prompts.out(t('claude.lockCleanupFailed'));
         }
     }
 }
@@ -194,8 +195,8 @@ export async function configureClaudeCode(config, action, prompts, options = {})
     const file = settingsFile(options), before = await snapshot(file), data = parseSettings(before);
     const status = describe(file, data);
     if (action === 'remove' && status.stop + status.notification + status.lifecycle + status.interaction === 0) {
-        prompts.out(`Claude Code 用户级设置：${file}`);
-        prompts.out('没有找到本工具添加的 hooks，设置没有改动。');
+        prompts.out(t('claude.settingsPath', { file }));
+        prompts.out(t('claude.noHooks'));
         return true;
     }
     const runtime = options.runtime ?? { node: process.execPath, cli: fileURLToPath(new URL('./cli.js', import.meta.url)) };
@@ -203,35 +204,34 @@ export async function configureClaudeCode(config, action, prompts, options = {})
     // setup 快速路径已在汇总确认前展示路径和发送范围，避免保存后重复整段说明。
     const quiet = options.confirm === false;
     if (!quiet)
-        prompts.out(`Claude Code 用户级设置：${file}`);
+        prompts.out(t('claude.settingsPath', { file }));
     if (JSON.stringify(data) === JSON.stringify(target)) {
-        prompts.out(action === 'install' ? '本工具 hooks 已经安装，配置一致，无需重复添加。' : '没有找到本工具添加的 hooks，设置没有改动。');
+        prompts.out(action === 'install' ? t('claude.alreadyInstalled') : t('claude.noHooks'));
         return true;
     }
     if (action === 'install') {
         if (!quiet) {
-            prompts.out(`通知配置：${path.resolve(config)}`);
-            prompts.out('会为这个 Claude Code 配置目录下的所有项目启用通知：任务结束时发送最终回复，需要你确认或输入时也会提醒。');
-            prompts.out('最终回复和提醒正文可能包含敏感内容，会发送到配置实际生效的 Telegram / 飞书。环境变量仍然优先。');
-            prompts.out('同时安装会话生命周期和结构化问题 hooks。远程输入需要另行运行 reply setup 授权。');
-            prompts.out('不会读取整份会话记录。启用回复后，会读取会话的进程元数据；结构化问题或权限请求会发送对应的问题和工具信息。');
-            prompts.out('PreToolUse 只登记调用身份；PermissionRequest 会和本机终端窗口同时等待，远程回答的有效期是 5 分钟。安装完成事件只用于反馈结果，不会代替你作答。已核对 Claude Code 2.1.316；其他版本或宿主环境需要另行验证。');
+            prompts.out(t('claude.configPath', { config: path.resolve(config) }));
+            prompts.out(t('claude.installScope'));
+            prompts.out(t('claude.installSensitive'));
+            prompts.out(t('claude.installLifecycle'));
+            prompts.out(t('claude.installReads'));
+            prompts.out(t('claude.installTiming'));
         }
         if (status.others)
-            prompts.out(`当前文件里还有 ${status.others} 个其他相关处理器，可能会重复通知。`);
-        prompts.out('项目级或插件的 hooks 也可能同时生效；本工具不会自动迁移或删除旧版 hooks。');
+            prompts.out(t('claude.otherHandlers', { count: status.others }));
+        prompts.out(t('claude.projectHooks'));
         if (status.disabled)
-            prompts.out('注意：该文件启用了 disableAllHooks，安装后 hooks 也不会生效；请自行解除禁用。');
+            prompts.out(t('claude.disabledWarning'));
     }
     else if (!quiet)
-        prompts.out('只会移除本工具添加的通知、生命周期和交互处理器；其他设置、hooks、通知配置和系统凭据都会保留。如需停止回复桥接，请运行 reply disable 或 reply stop。');
+        prompts.out(t('claude.removeScope'));
     if (options.confirm !== false
-        && !yes(await prompts.text(action === 'install' ? '安装这些 Claude Code hooks？[y/N] ' : '移除本工具的 Claude Code hooks？[y/N] '))) {
-        prompts.out('已取消，Claude Code 设置没有改动。');
+        && !yes(await prompts.text(action === 'install' ? t('claude.confirmInstall') : t('claude.confirmRemove')))) {
+        prompts.out(t('claude.cancelled'));
         return false;
     }
     await commit(file, before, target, prompts, options.replace);
-    prompts.out(action === 'install' ? 'Claude Code hooks 已安装。请在 /hooks 中检查并按界面确认；如果没有生效，请重启会话。'
-        : '本工具的 Claude Code hooks 已移除。请在 /hooks 中检查，必要时重启会话。');
+    prompts.out(action === 'install' ? t('claude.installed') : t('claude.removed'));
     return true;
 }

package/dist/claude-hook.js

@@ -1,20 +1,21 @@
 import { ConfigError, decodeUtf8, loadConfig, ready } from './config.js';
 import { makePlan } from './channels.js';
 import { NOTIFICATION_MATCHER } from './claude-code.js';
+import { t } from './i18n.js';
 import { findSessionName } from './reply-platform.js';
 import { lifecycleHook, interactionHook, attachReply, mapReplies, notificationCoverage } from './reply-hooks.js';
 export const MAX_HOOK_BYTES = 8 * 1024 * 1024;
 export async function readHookInput(input = process.stdin, limit = MAX_HOOK_BYTES) {
     const chunks = [];
     let size = 0;
-    const timer = setTimeout(() => input.destroy(new ConfigError('Claude Code hook 输入超时，通知没有发送。')), 15000);
+    const timer = setTimeout(() => input.destroy(new ConfigError(t('hook.timeout'))), 15000);
     timer.unref();
     try {
         for await (const chunk of input) {
             const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             size += bytes.length;
             if (size > limit)
-                throw new ConfigError('Claude Code hook 输入超过大小限制，通知没有发送；内容不会被截断。');
+                throw new ConfigError(t('hook.tooLarge'));
             chunks.push(bytes);
         }
         return Buffer.concat(chunks);
@@ -31,44 +32,43 @@ function metadata(value, limit) {
     return chars.length > limit ? chars.slice(0, limit).join('') + '…' : clean;
 }
 function footer(data, sessionName) {
-    const project = typeof data.cwd === 'string' && data.cwd.trim() ? `项目：${metadata(data.cwd, 300)}` : '';
-    const topic = typeof sessionName === 'string' && sessionName.trim() ? `主题：${metadata(sessionName.trim(), 120)}` : '';
-    const session = typeof data.session_id === 'string' && data.session_id.trim() ? `会话：${metadata(data.session_id, 120)}` : '';
+    const project = typeof data.cwd === 'string' && data.cwd.trim() ? t('hook.footerProject', { value: metadata(data.cwd, 300) }) : '';
+    const topic = typeof sessionName === 'string' && sessionName.trim() ? t('hook.footerTopic', { value: metadata(sessionName.trim(), 120) }) : '';
+    const session = typeof data.session_id === 'string' && data.session_id.trim() ? t('hook.footerSession', { value: metadata(data.session_id, 120) }) : '';
     return [project, topic, session].filter(Boolean).join('\n');
 }
 export function claudeHookMessage(bytes, sessionName = '') {
     if (bytes.byteLength > MAX_HOOK_BYTES)
-        throw new ConfigError('Claude Code hook 输入超过大小限制，通知没有发送；内容不会被截断。');
+        throw new ConfigError(t('hook.tooLarge'));
     let data;
     try {
         data = JSON.parse(decodeUtf8(bytes));
     }
     catch {
-        throw new ConfigError('Claude Code hook 输入不是合法的 UTF-8 JSON，通知没有发送。');
+        throw new ConfigError(t('hook.invalidJson'));
     }
     if (!data || typeof data !== 'object' || Array.isArray(data))
-        throw new ConfigError('Claude Code hook 输入需要是 JSON 对象。');
+        throw new ConfigError(t('hook.notObject'));
     if (data.hook_event_name !== 'Stop' && data.hook_event_name !== 'Notification')
         return null;
     const details = footer(data, sessionName);
     if (data.hook_event_name === 'Stop') {
         if (data.stop_hook_active !== undefined && typeof data.stop_hook_active !== 'boolean')
-            throw new ConfigError('Claude Code Stop 状态字段无效。');
+            throw new ConfigError(t('hook.invalidStopState'));
         if (data.stop_hook_active === true)
             return null;
         if (data.last_assistant_message !== undefined && typeof data.last_assistant_message !== 'string')
-            throw new ConfigError('Claude Code 最终回复字段无效。');
-        return { title: 'Claude Code 回复完成', level: 'success', footer: details,
-            content: data.last_assistant_message?.trim() ? data.last_assistant_message
-                : '本轮回复已结束，Claude Code 没有提供最终正文。请回到终端查看；这里不会读取会话文件来补正文，以免显示过期内容。' };
+            throw new ConfigError(t('hook.invalidReply'));
+        return { title: t('hook.replyTitle'), level: 'success', footer: details,
+            content: data.last_assistant_message?.trim() ? data.last_assistant_message : t('hook.replyFallback') };
     }
     // 空闲提醒在 Stop 之后重复触发；只转发明确需要用户处理的通知。
     if (!NOTIFICATION_MATCHER.split('|').includes(data.notification_type))
         return null;
     if (data.message !== undefined && typeof data.message !== 'string')
-        throw new ConfigError('Claude Code 通知正文字段无效。');
-    return { title: 'Claude Code 需要你处理', level: 'warn', footer: details,
-        content: data.message?.trim() ? data.message : 'Claude Code 正在等待你的确认或输入，请回到终端处理。' };
+        throw new ConfigError(t('hook.invalidNotification'));
+    return { title: t('hook.notificationTitle'), level: 'warn', footer: details,
+        content: data.message?.trim() ? data.message : t('hook.notificationFallback') };
 }
 export async function dispatchClaudeHook(bytes, configFile, context) {
     const message = claudeHookMessage(bytes);
@@ -79,7 +79,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         await interactionHook(data, configFile, options);
     }
     catch {
-        context.err('Claude Code 的回复状态或交互处理失败。没有自动选择答案或批准权限，请在本机处理。');
+        context.err(t('hook.interactionFailed'));
     }
     if (!message)
         return;
@@ -88,7 +88,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         sessionName = await findSessionName(data.session_id, { env: context.env });
     }
     catch {
-        context.err('读取不到 Claude Code 会话名称，通知底部将省略主题。');
+        context.err(t('hook.sessionNameFailed'));
     }
     const notification = sessionName ? claudeHookMessage(bytes, sessionName) ?? message : message;
     let binding = null;
@@ -96,7 +96,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         binding = await attachReply(notification, data, configFile, options);
     }
     catch {
-        context.err('远程回复还没有就绪，仍会尝试发送普通通知。');
+        context.err(t('hook.replyNotReady'));
     }
     const config = await loadConfig(configFile, true, context.env);
     let covered = { telegram: [], feishu: false };
@@ -104,7 +104,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         covered = await notificationCoverage(data, configFile, config, options);
     }
     catch {
-        context.err('没有核验到选择题通知的覆盖情况，将保留普通权限提醒。');
+        context.err(t('hook.coverageFailed'));
     }
     let channels = 0;
     for (const channel of ['telegram', 'feishu']) {
@@ -125,12 +125,12 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
                 mapReplies(plan, binding);
             const result = await context.send(plan, config);
             if (!result.ok)
-                context.err(`${channel}：Claude Code 通知没有完整发送。整条消息不会自动重发。`);
+                context.err(t('hook.sendIncomplete', { channel }));
         }
         catch {
-            context.err(`${channel}：Claude Code 通知发送失败。请检查配置、系统凭据和网络；整条消息不会自动重发。`);
+            context.err(t('hook.sendFailed', { channel }));
         }
     }
     if (!channels)
-        throw new ConfigError('Claude Code 通知没有可用渠道，请运行 dev-notify doctor 检查。');
+        throw new ConfigError(t('hook.noChannels'));
 }