@quecue/dev-notify 0.1.0-alpha.3 → 0.1.1

package/dist/channels.js

@@ -11,7 +11,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('服务端没有返回内容。');
         const reader = response.body.getReader();
         const chunks = [];
         let size = 0;
@@ -23,7 +23,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('服务端响应过大，已停止读取。');
                 }
                 chunks.push(value);
             }
@@ -33,13 +33,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('服务端返回的不是 JSON 对象。');
         return result;
     }
     catch (error) {
         if (error instanceof TransportError)
             throw error;
-        throw new TransportError('网络请求失败或响应无效；未自动重发，投递状态可能未知');
+        throw new TransportError('网络请求失败或响应无效。为避免重复通知，不会自动重发；这条消息可能没有送达。');
     }
 }
 function text(title, content, footer, icon, html) {
@@ -63,7 +63,7 @@ function card(message, title, content) {
 }
 export function makePlan(channel, message, config) {
     if (!message.title.trim())
-        throw new Error('通知标题不能为空');
+        throw new Error('通知标题不能为空。');
     const blocks = parseMarkdown(message.content);
     if (channel === 'telegram') {
         const icon = icons[message.level];
@@ -76,7 +76,7 @@ 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('Telegram 分段后仍然超过消息长度限制。');
                 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 }]] } } : {}) } });
@@ -88,7 +88,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('飞书分段后仍然超过请求大小限制。');
         return { recipient: 'feishu', payload };
     });
     return { channel, items, recipients: 1 };
@@ -144,12 +144,12 @@ export async function deliver(plan, config, request = requestJson, sleep = delay
             }
             else {
                 failed.add(item.recipient);
-                error = '渠道拒绝发送，请检查凭据、接收人授权、签名或频率限制';
+                error = '渠道拒绝了这次发送。请检查凭据、接收人授权、签名和频率限制。';
             }
         }
         catch (cause) {
             failed.add(item.recipient);
-            error = cause instanceof TransportError ? cause.message : '发送失败；投递状态可能未知';
+            error = cause instanceof TransportError ? cause.message : '发送失败，这条消息可能没有送达。';
         }
         if (!telegram && !failed.has(item.recipient) && index + 1 < plan.items.length)
             await sleep(250);

package/dist/claude-code.js

@@ -13,7 +13,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('CLAUDE_CONFIG_DIR 需要是绝对路径，Claude Code 设置没有改动');
     return join.join(root, 'settings.json');
 }
 function settingsFile(options) {
@@ -23,7 +23,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('Claude Code 设置超过 1 MiB，操作已停止，文件没有改动。');
         return bytes;
     }
     catch (error) {
@@ -31,7 +31,7 @@ async function snapshot(file) {
             return null;
         if (error instanceof ConfigError)
             throw error;
-        throw new ConfigError('无法读取 Claude Code 设置，未修改');
+        throw new ConfigError('无法读取 Claude Code 设置，操作已停止。');
     }
 }
 function parseSettings(before) {
@@ -40,17 +40,17 @@ function parseSettings(before) {
         data = before === null ? {} : JSON.parse(decodeUtf8(before));
     }
     catch {
-        throw new ConfigError('Claude Code 设置不是合法 UTF-8 JSON，未覆盖');
+        throw new ConfigError('Claude Code 设置不是合法的 UTF-8 JSON，没有覆盖。');
     }
     if (!record(data) || (data.hooks !== undefined && !record(data.hooks)))
-        throw new ConfigError('Claude Code 设置或 hooks 结构无效，未覆盖');
+        throw new ConfigError('Claude Code 设置或 hooks 结构无效，没有覆盖。');
     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('Claude Code hook 数组结构无效，没有覆盖。');
     }
     return data;
 }
@@ -150,14 +150,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('暂时无法获取 Claude Code 设置写入锁。请确认没有安装进程在运行，再处理残留的 .dev-notify.lock。');
     }
     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('Claude Code 设置在确认期间发生了变化，没有覆盖，请重试。');
         const stream = await open(temporary, 'wx', 0o600);
         created = true;
         try {
@@ -168,7 +168,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('Claude Code 设置在保存期间发生了变化，没有覆盖，请重试。');
         await replace(temporary, file);
     }
     finally {
@@ -177,14 +177,14 @@ async function commit(file, before, target, prompts, replace = rename) {
                 await remove(temporary);
             }
             catch {
-                prompts.out('临时 Claude Code 设置清理失败，请确认安装结束后清理 .dev-notify-*.tmp');
+                prompts.out('临时文件清理失败。安装结束后请删除 .dev-notify-*.tmp。');
             }
         }
         try {
             await remove(lockFile);
         }
         catch {
-            prompts.out('Claude Code 设置锁清理失败，请确认安装结束后处理 .dev-notify.lock');
+            prompts.out('锁文件清理失败。安装结束后请删除 .dev-notify.lock。');
         }
     }
 }
@@ -193,44 +193,43 @@ export async function configureClaudeCode(config, action, prompts, options = {})
     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('没有找到本工具添加的 hooks，设置没有改动。');
         return true;
     }
     const runtime = options.runtime ?? { node: process.execPath, cli: fileURLToPath(new URL('./cli.js', import.meta.url)) };
     const target = merged(data, action === 'install' ? path.resolve(config) : null, runtime);
-    prompts.out(`Claude Code 用户级设置：${file}`);
+    // setup 快速路径已在汇总确认前展示路径和发送范围，避免保存后重复整段说明。
+    const quiet = options.confirm === false;
+    if (!quiet)
+        prompts.out(`Claude Code 用户级设置：${file}`);
     if (JSON.stringify(data) === JSON.stringify(target)) {
-        prompts.out(action === 'install' ? '本工具 hooks 已安装且配置一致，未重复添加。' : '没有本工具标记的 hooks，未修改。');
+        prompts.out(action === 'install' ? '本工具 hooks 已经安装，配置一致，无需重复添加。' : '没有找到本工具添加的 hooks，设置没有改动。');
         return true;
     }
     if (action === 'install') {
-        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 实现；旧版和特殊宿主需另行验收。');
+        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；其他版本或宿主环境需要另行验证。');
+        }
         if (status.others)
-            prompts.out(`保留当前文件中另外 ${status.others} 个相关处理器；可能出现重复通知。`);
-        prompts.out('项目级或插件 hooks 也可能同时生效；不会自动迁移或删除原 Python hooks。');
+            prompts.out(`当前文件里还有 ${status.others} 个其他相关处理器，可能会重复通知。`);
+        prompts.out('项目级或插件的 hooks 也可能同时生效；本工具不会自动迁移或删除旧版 hooks。');
         if (status.disabled)
-            prompts.out('注意：该文件设置了 disableAllHooks，安装后仍不会生效；本工具不擅自解除禁用。');
+            prompts.out('注意：该文件启用了 disableAllHooks，安装后 hooks 也不会生效；请自行解除禁用。');
     }
-    else
-        prompts.out('只移除本工具标记的通知、生命周期和交互处理器；保留其他设置、hooks、通知配置和系统凭据。如需停止回复桥接，请运行 reply disable / stop。');
-    if (!yes(await prompts.text(action === 'install' ? '确认合并安装 Claude Code 通知 hooks？[y/N] ' : '确认移除本工具的 Claude Code hooks？[y/N] '))) {
-        prompts.out('已取消，Claude Code 设置未修改。');
+    else if (!quiet)
+        prompts.out('只会移除本工具添加的通知、生命周期和交互处理器；其他设置、hooks、通知配置和系统凭据都会保留。如需停止回复桥接，请运行 reply disable 或 reply stop。');
+    if (options.confirm !== false
+        && !yes(await prompts.text(action === 'install' ? '安装这些 Claude Code hooks？[y/N] ' : '移除本工具的 Claude Code hooks？[y/N] '))) {
+        prompts.out('已取消，Claude Code 设置没有改动。');
         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' ? 'Claude Code hooks 已安装。请在 /hooks 中检查并按界面确认；如果没有生效，请重启会话。'
+        : '本工具的 Claude Code hooks 已移除。请在 /hooks 中检查，必要时重启会话。');
     return true;
 }
-export async function offerClaudeCode(config, prompts, options = {}) {
-    if (!yes(await prompts.text('是否配置 Claude Code 自动通知？将另行展示用户级设置路径及发送范围。[y/N] '))) {
-        prompts.out('未更改 Claude Code hooks；已有集成保持原样。');
-        return;
-    }
-    await configureClaudeCode(config, 'install', prompts, options);
-}

package/dist/claude-hook.js

@@ -1,20 +1,20 @@
-import path from 'node:path';
 import { ConfigError, decodeUtf8, loadConfig, ready } from './config.js';
 import { makePlan } from './channels.js';
 import { NOTIFICATION_MATCHER } from './claude-code.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('Claude Code hook 输入超时，通知没有发送。')), 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('Claude Code hook 输入超过大小限制，通知没有发送；内容不会被截断。');
             chunks.push(bytes);
         }
         return Buffer.concat(chunks);
@@ -30,39 +30,44 @@ function metadata(value, limit) {
     const chars = Array.from(clean);
     return chars.length > limit ? chars.slice(0, limit).join('') + '…' : clean;
 }
-export function claudeHookMessage(bytes) {
+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)}` : '';
+    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('Claude Code hook 输入超过大小限制，通知没有发送；内容不会被截断。');
     let data;
     try {
         data = JSON.parse(decodeUtf8(bytes));
     }
     catch {
-        throw new ConfigError('Claude Code hook 输入不是合法 UTF-8 JSON，未发送通知');
+        throw new ConfigError('Claude Code hook 输入不是合法的 UTF-8 JSON，通知没有发送。');
     }
     if (!data || typeof data !== 'object' || Array.isArray(data))
-        throw new ConfigError('Claude Code hook 输入必须是 JSON 对象');
+        throw new ConfigError('Claude Code hook 输入需要是 JSON 对象。');
     if (data.hook_event_name !== 'Stop' && data.hook_event_name !== 'Notification')
         return null;
-    const footer = [typeof data.cwd === 'string' ? `项目：${metadata(path.win32.basename(data.cwd), 120)}` : '',
-        typeof data.session_id === 'string' ? `会话：${metadata(data.session_id, 120)}` : ''].filter(Boolean).join('\n');
+    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('Claude Code Stop 状态字段无效。');
         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,
+            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 未提供最终正文。请在终端查看回复；不会读取可能滞后的会话文件来代替正文。' };
+                : '本轮回复已结束，Claude Code 没有提供最终正文。请回到终端查看；这里不会读取会话文件来补正文，以免显示过期内容。' };
     }
     // 空闲提醒在 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,
+        throw new ConfigError('Claude Code 通知正文字段无效。');
+    return { title: 'Claude Code 需要你处理', level: 'warn', footer: details,
         content: data.message?.trim() ? data.message : 'Claude Code 正在等待你的确认或输入，请回到终端处理。' };
 }
 export async function dispatchClaudeHook(bytes, configFile, context) {
@@ -74,16 +79,24 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         await interactionHook(data, configFile, options);
     }
     catch {
-        context.err('Claude Code 回复状态或交互处理失败；未自动选择答案/批准权限，请在本机处理。');
+        context.err('Claude Code 的回复状态或交互处理失败。没有自动选择答案或批准权限，请在本机处理。');
     }
     if (!message)
         return;
+    let sessionName = '';
+    try {
+        sessionName = await findSessionName(data.session_id, { env: context.env });
+    }
+    catch {
+        context.err('读取不到 Claude Code 会话名称，通知底部将省略主题。');
+    }
+    const notification = sessionName ? claudeHookMessage(bytes, sessionName) ?? message : message;
     let binding = null;
     try {
-        binding = await attachReply(message, data, configFile, options);
+        binding = await attachReply(notification, data, configFile, options);
     }
     catch {
-        context.err('远程回复未就绪；仍尝试发送普通通知。');
+        context.err('远程回复还没有就绪，仍会尝试发送普通通知。');
     }
     const config = await loadConfig(configFile, true, context.env);
     let covered = { telegram: [], feishu: false };
@@ -91,7 +104,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         covered = await notificationCoverage(data, configFile, config, options);
     }
     catch {
-        context.err('无法核验选择题通知覆盖情况；保留普通权限提醒。');
+        context.err('没有核验到选择题通知的覆盖情况，将保留普通权限提醒。');
     }
     let channels = 0;
     for (const channel of ['telegram', 'feishu']) {
@@ -101,7 +114,7 @@ export async function dispatchClaudeHook(bytes, configFile, context) {
         try {
             if (channel === 'feishu' && covered.feishu)
                 continue;
-            const plan = makePlan(channel, message, config);
+            const plan = makePlan(channel, notification, config);
             if (channel === 'telegram' && covered.telegram.length) {
                 plan.items = plan.items.filter(item => !covered.telegram.includes(item.recipient));
                 plan.recipients = new Set(plan.items.map(item => item.recipient)).size;
@@ -112,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(`${channel}：Claude Code 通知没有完整发送。整条消息不会自动重发。`);
         }
         catch {
-            context.err(`${channel}: Claude Code 通知发送失败；请检查配置、系统凭据及网络，不自动重发整条消息。`);
+            context.err(`${channel}：Claude Code 通知发送失败。请检查配置、系统凭据和网络；整条消息不会自动重发。`);
         }
     }
     if (!channels)
-        throw new ConfigError('Claude Code 通知没有可用渠道，请运行 dev-notify doctor 检查');
+        throw new ConfigError('Claude Code 通知没有可用渠道，请运行 dev-notify doctor 检查。');
 }