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

package/dist/reply-platform.js

@@ -7,8 +7,8 @@ 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('系统会话操作超时。输入可能已经部分送达，为避免重复提交，不会自动重试。')); }, 15000);
+    const fail = () => { clearTimeout(timer); reject(new ConfigError('系统会话操作失败。为了避免泄露命令或输入，这里不显示底层信息。')); };
     child.on('error', fail);
     child.stdin.on('error', () => { });
     child.stdout.on('data', data => { if (stdout.length + data.length > 1024 * 1024) {
@@ -28,12 +28,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('回复内容不能为空。');
     if (Array.from(text).length > 4000)
-        throw new ConfigError('回复超过 4000 字符，未提交；不会截断或拆成多次任务');
+        throw new ConfigError('回复超过 4000 字符，没有提交。内容不会被截断，也不会拆成多次发送。');
     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('回复清理后没有可提交的内容。');
     return value;
 }
 export async function processIdentity(pid, platform = process.platform, runner = runCommand) {
@@ -95,6 +95,33 @@ export async function findSession(session, options = {}) {
     return { session, pid: d.pid, ...identity, title: typeof d.name === 'string' ? Array.from(d.name).slice(0, 60).join('') : '',
         cwd: typeof d.cwd === 'string' ? d.cwd : '', updated: Date.now(), working: false };
 }
+// 仅用于通知展示：按 sessionId 读取本地会话注册表名称，不做进程身份核验，失败时返回空。
+export async function findSessionName(session, options = {}) {
+    if (!session || !/^[A-Za-z0-9_-]{1,128}$/.test(session))
+        return '';
+    const directory = path.join(path.dirname(claudeSettingsPath(options.env, options.home ?? homedir())), 'sessions');
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return '';
+    }
+    for (const name of names) {
+        if (!/^\d+\.json$/.test(name))
+            continue;
+        try {
+            const bytes = await readFile(path.join(directory, name));
+            if (bytes.length > 128 * 1024)
+                continue;
+            const d = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+            if (d.sessionId === session && typeof d.name === 'string' && d.name.trim())
+                return d.name;
+        }
+        catch { /* 其他损坏或写入中的会话文件不提供名称。 */ }
+    }
+    return '';
+}
 export async function validateTarget(target, options = {}) {
     const current = await findSession(target.session, options);
     return current !== null && current.pid === target.pid && current.birth === target.birth && current.tty === target.tty;
@@ -139,15 +166,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('会话已经关闭、切换，或无法核验身份。请从最新通知回复。');
     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('Windows 控制台注入失败，可能只写入了一部分。不会自动重试，请检查终端。');
         return;
     }
     if (platform !== 'darwin')
-        throw new ConfigError('远程回复仅支持 Windows 与 macOS');
+        throw new ConfigError('远程回复仅支持 Windows 和 macOS。');
     // 先确定 tmux pane，字面文本通过 stdin 缓冲区传入，绝不作为 shell 或按键名称执行。
     let listing = null;
     try {
@@ -159,14 +186,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('tmux 输入缓冲区创建失败，这次回复没有提交。');
         try {
             if (!await validateTarget(target, options))
-                throw new ConfigError('会话已变化，未提交');
+                throw new ConfigError('会话已经变化，这次回复没有提交。');
             if ((await runner('tmux', ['paste-buffer', '-d', '-b', name, '-t', pane])).code !== 0)
-                throw new ConfigError('tmux 粘贴失败，可能部分送达，不重试');
+                throw new ConfigError('tmux 粘贴失败，可能只送达了一部分。不会自动重试。');
             if ((await runner('tmux', ['send-keys', '-t', pane, 'Enter'])).code !== 0)
-                throw new ConfigError('tmux 提交失败，文本可能已输入，不重试');
+                throw new ConfigError('tmux 提交失败，文本可能已经输入。不会自动重试。');
         }
         finally {
             await runner('tmux', ['delete-buffer', '-b', name]).catch(() => { });
@@ -178,5 +205,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('Ghostty 没有找到目标窗口，或注入失败。不会改投其他窗口，也不会重复输入。');
 }

package/dist/reply-state.js

@@ -20,7 +20,7 @@ export async function readJson(file) {
     catch (error) {
         if (error.code === 'ENOENT')
             return null;
-        throw new ConfigError('无法读取回复配置或状态；未覆盖、未启用远程输入');
+        throw new ConfigError('无法读取回复配置或状态。为了不覆盖现有数据，远程输入没有启用。');
     }
 }
 export async function atomicJson(file, value) {
@@ -52,9 +52,9 @@ export async function locked(file, work) {
         }
         catch (error) {
             if (error.code !== 'EEXIST')
-                throw new ConfigError('无法获取回复状态写入锁');
+                throw new ConfigError('无法获取回复状态写入锁。');
             if (attempt === 99)
-                throw new ConfigError('回复状态锁繁忙；确认进程已退出后才能处理残留锁');
+                throw new ConfigError('回复状态锁正忙。请确认相关进程已经退出，再处理残留锁。');
             await delay(40);
         }
     }
@@ -73,16 +73,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('回复授权配置无效，远程输入已停用。');
     }
     if (!await replyHooksReady(file, { env }))
-        throw new ConfigError('回复所需 hooks 缺失、异步时序不安全或已禁用；请先重新运行 integration claude-code install 并在 /hooks 确认加载');
+        throw new ConfigError('回复所需的 hooks 缺失、时序不安全或已禁用。请重新运行 integration claude-code install，并在 /hooks 中确认加载。');
     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('Telegram Bot 已变更或不可用，请重新运行 reply setup 授权。');
     const users = policy.users.filter((id) => config.telegram.chatIds.includes(id));
     if (!users.length)
-        throw new ConfigError('回复授权用户不在当前 Telegram 接收名单中，拒绝远程输入');
+        throw new ConfigError('授权用户不在当前 Telegram 接收名单中，远程输入已停用。');
     const effective = { ...policy, users };
     return { file, config, policy: effective, identity: digest(JSON.stringify([policy.bot, policy.generation, users, policy.permissions === true])) };
 }
@@ -92,7 +92,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('回复授权已撤销或发生变化，没有写入旧状态。');
         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 +101,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('回复状态结构无效，远程输入已停用。');
         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 +136,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('请先运行 integration claude-code install，安装绑定此通知配置的完整 hooks，再配置回复。');
     const config = await loadConfig(file, true, env);
     if (!ready(config, 'telegram'))
-        throw new ConfigError('回复 Claude 需要先配置 Telegram Bot 和私聊接收人');
+        throw new ConfigError('回复 Claude 需要先配置 Telegram Bot 和私聊接收人。');
     const available = config.telegram.chatIds.filter(id => /^[1-9][0-9]*$/.test(id));
     if (!available.length)
-        throw new ConfigError('远程回复只允许 Telegram 私聊用户，不支持群聊');
+        throw new ConfigError('远程回复仅支持 Telegram 私聊用户，不支持群聊。');
     const before = await readJson(policyPath(file));
-    prompts.out('远程回复等同向本机 Claude Code 终端输入并提交内容；不会自动批准工具权限，但可提交 Claude 命令。只授权可信用户。');
-    prompts.out('飞书按钮跳转 Telegram；不直接接收飞书消息。需要独占 Bot 的 getUpdates：不得与旧 Python 桥接或另一台机器共用同一个 Bot。');
-    prompts.out('Windows 使用系统 PowerShell / 控制台 API；macOS 使用 Ghostty 或 tmux，需要相应系统权限。不依赖 Python。');
-    prompts.out('支持范围不含 VS Code 集成终端、WSL、SSH；不确定目标或会话已切换时拒绝输入。');
-    prompts.out('通知接收人不会自动获得输入权限。当前可选择的私聊 chat_id：' + available.join('、'));
-    const text = await prompts.text('输入本次明确授权的私聊 chat_id（逗号分隔，留空取消）：');
+    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（逗号分隔；留空取消）：');
     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('只能授权当前通知名单中的明确私聊用户');
+        throw new ConfigError('只能授权当前通知名单中的私聊用户。');
     prompts.out('将授权以下用户远程输入：' + users.join('、'));
-    prompts.out('结构化问题将展示真实选项并允许自定义回答；普通回复只在本轮结束后输入。问题/选项及可选的工具请求参数可能含敏感信息，将发送到授权私聊和已配置的飞书渠道。');
-    const permissions = /^(y|yes)$/i.test(await prompts.text('是否另外允许这些用户逐次点击批准/拒绝工具权限？不修改永久规则。[y/N] '));
+    prompts.out('结构化问题会展示真实选项，也支持自定义回答；普通回复会在本轮结束后输入。问题、选项和工具请求参数可能包含敏感信息，会发送到授权私聊和已配置的飞书。');
+    const permissions = /^(y|yes)$/i.test(await prompts.text('是否允许这些用户逐次批准或拒绝工具权限？这不会修改永久规则。[y/N] '));
     if (!/^(y|yes)$/i.test(await prompts.text('确认启用远程回复并接受上述权限范围？[y/N] ')))
         return false;
     await locked(policyPath(file) + '.lock', async () => {
         if (JSON.stringify(before) !== JSON.stringify(await readJson(policyPath(file))))
-            throw new ConfigError('回复授权已被其他进程修改，请重试');
+            throw new ConfigError('回复授权已被其他进程修改，请重试。');
         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('通知配置在授权期间发生了变化，请重试。');
         await atomicJson(policyPath(file), { version: 1, enabled: true, bot: botKey(config), users, permissions, generation: randomBytes(16).toString('hex') });
     });
-    prompts.out('回复授权已保存；旧消息映射不继承。新回复需从启用后的任务完成通知进入。');
+    prompts.out('授权已保存。旧消息的回复映射不会保留；请从启用后的任务完成通知进入。');
     return true;
 }
 export async function disableReplies(file, prompts) {
     const before = await readJson(policyPath(file));
     if (!before?.enabled) {
-        prompts.out('远程回复未启用。');
+        prompts.out('远程回复尚未启用。');
         return true;
     }
-    if (!/^(y|yes)$/i.test(await prompts.text('确认禁用远程回复？通知和凭据保持不变。[y/N] ')))
+    if (!/^(y|yes)$/i.test(await prompts.text('确认禁用远程回复？通知和凭据都会保留。[y/N] ')))
         return false;
     await locked(policyPath(file) + '.lock', async () => {
         if (JSON.stringify(before) !== JSON.stringify(await readJson(policyPath(file))))
-            throw new ConfigError('回复授权已变化，请重试');
+            throw new ConfigError('回复授权发生了变化，请重试。');
         await atomicJson(policyPath(file), { ...before, enabled: false });
     });
-    prompts.out('远程回复已禁用；正在进行中的注入不能撤回，桥接下次检查授权时退出。');
+    prompts.out('远程回复已禁用。正在进行的操作无法撤回，桥接会在下次检查时退出。');
     return true;
 }

package/dist/reply-telegram.js

@@ -7,7 +7,7 @@ export function telegramApi(token, request = requestJson) {
         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 轮询冲突；检查旧 Python 桥接、其他机器或 webhook，桥接不会抢占或删除 webhook');
+                throw new ConfigError('Telegram 轮询冲突；检查旧版桥接、其他机器或 webhook，桥接不会抢占或删除 webhook');
             throw new ConfigError('Telegram 桥接请求失败；不输出服务端正文或秘密');
         }
         return response.result;

package/dist/setup.js

@@ -1,10 +1,11 @@
 import { readFile, mkdir, open, rename, unlink } from 'node:fs/promises';
 import path from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { ConfigError, decodeUtf8, example, parseConfig } from './config.js';
+import { ConfigError, decodeUtf8, example, parseConfig, ready } from './config.js';
 import { encodeBundle, nativeStore } from './credentials.js';
 import { terminalPrompts } from './prompts.js';
 const yes = (text) => /^(y|yes)$/i.test(text.trim());
+const defaultYes = (text) => !text.trim() || yes(text);
 export async function snapshot(file) {
     try {
         return await readFile(file);
@@ -12,7 +13,7 @@ export async function snapshot(file) {
     catch (error) {
         if (error.code === 'ENOENT')
             return null;
-        throw new ConfigError('无法读取现有配置，未修改');
+        throw new ConfigError('无法读取现有配置，这次没有做任何修改。');
     }
 }
 function same(left, right) { return left === null ? right === null : right !== null && left.equals(right); }
@@ -24,7 +25,7 @@ export function readRaw(raw) {
         data = JSON.parse(decodeUtf8(raw));
     }
     catch {
-        throw new ConfigError('现有配置损坏，未覆盖；请先修复 JSON');
+        throw new ConfigError('现有配置无法解析，这次没有覆盖它。请先修复 JSON。');
     }
     parseConfig(data, {}, () => ({}));
     return data;
@@ -59,20 +60,20 @@ export async function commitConfig(file, data, expected, store, values, options
         lock = await open(lockPath, 'wx', 0o600);
     }
     catch {
-        throw new ConfigError('配置写入锁不可用；请检查权限，或确认没有运行中的向导后处理残留 .setup.lock');
+        throw new ConfigError('配置写入锁不可用。请检查权限；如果确认没有向导在运行，可以删除残留的 .setup.lock。');
     }
     const temporary = path.join(path.dirname(file), `.config-${id}.tmp`);
     let created = false, committed = false, tempCreated = false;
     try {
         await lock.close();
         if (!same(await snapshot(file), expected))
-            throw new ConfigError('配置在向导期间已变化，未覆盖，请重试');
+            throw new ConfigError('配置在向导期间发生了变化，这次没有覆盖它。请重试。');
         if (values !== null) {
             store.create(id, values);
             created = true;
             const check = store.read(id);
             if (check === null || JSON.stringify(check) !== JSON.stringify(values))
-                throw new ConfigError('凭据写入校验失败，未切换配置');
+                throw new ConfigError('凭据写入后校验失败，配置没有切换。');
         }
         const stream = await open(temporary, 'wx', 0o600);
         tempCreated = true;
@@ -84,7 +85,7 @@ export async function commitConfig(file, data, expected, store, values, options
             await stream.close();
         }
         if (!same(await snapshot(file), expected))
-            throw new ConfigError('配置在保存期间已变化，未覆盖，请重试');
+            throw new ConfigError('配置在保存期间发生了变化，这次没有覆盖它。请重试。');
         await (options.replace ?? rename)(temporary, file);
         committed = true;
     }
@@ -94,7 +95,7 @@ export async function commitConfig(file, data, expected, store, values, options
                 await removeFile(temporary);
             }
             catch {
-                warn(`临时配置清理失败：${path.basename(temporary)}`);
+                warn(`临时配置没有清理掉：${path.basename(temporary)}`);
             }
         }
         if (created && !committed) {
@@ -102,14 +103,14 @@ export async function commitConfig(file, data, expected, store, values, options
                 store.remove(id);
             }
             catch {
-                warn(`配置未切换，但新凭据清理失败；引用 ID：${id}`);
+                warn(`配置没有切换，新凭据也未能清理。引用 ID：${id}`);
             }
         }
         try {
             await removeFile(lockPath);
         }
         catch {
-            warn('配置写入锁清理失败，请确认没有向导运行后处理 .setup.lock');
+            warn('配置写入锁没有清理掉。请确认没有向导在运行，再删除 .setup.lock。');
         }
     }
     if (old?.backend === 'keyring') {
@@ -117,11 +118,11 @@ export async function commitConfig(file, data, expected, store, values, options
             store.remove(old.id);
         }
         catch {
-            warn(`配置已保存，但旧凭据清理失败；引用 ID：${old.id}`);
+            warn(`配置已保存，但旧凭据没有清理掉。引用 ID：${old.id}`);
         }
     }
     else if (old?.backend === 'system') {
-        warn('Python 原型旧凭据未删除；仍由原型管理，避免跨实现误删');
+        warn('旧版原型的旧凭据仍然保留，由旧版工具继续管理，避免两个实现互相误删。');
     }
 }
 export async function wizard(file, options = {}) {
@@ -129,11 +130,14 @@ export async function wizard(file, options = {}) {
     const before = await snapshot(file), data = readRaw(before);
     const { out } = prompts;
     out(`配置路径：${file}`);
-    out('密钥隐藏输入并存入 Windows Credential Manager / macOS Keychain；JSON 只保存引用。');
-    out('本步骤仅配置渠道；保存后可另行确认启用 Claude Code 通知，不启用远程控制。只有额外同意测试时才发送测试消息。');
-    if (before && !yes(await prompts.text('已有配置，继续编辑？[y/N] ')))
-        return false;
-    const selection = await prompts.text('选择渠道：1 Telegram，2 飞书，3 两者；其他输入取消：');
+    out('Token、webhook 和签名密钥都不会回显，将保存到 Windows Credential Manager / macOS Keychain；配置文件只保留引用。');
+    const telegramEnabled = data.telegram?.enabled !== false;
+    const feishuEnabled = data.feishu?.enabled !== false;
+    const current = before === null ? ''
+        : telegramEnabled && feishuEnabled ? '3'
+            : telegramEnabled ? '1' : feishuEnabled ? '2' : '';
+    const entered = await prompts.text(`选择通知渠道：1 Telegram，2 飞书，3 两者${current ? ` [${current}]` : ''}（输入其他内容取消）：`);
+    const selection = entered || current;
     if (!['1', '2', '3'].includes(selection))
         return false;
     const store = options.store ?? nativeStore();
@@ -147,13 +151,13 @@ export async function wizard(file, options = {}) {
             previous = existing;
         }
         catch {
-            out('原凭据无法读取，可能缺失、锁定或权限不足。');
-            if (!yes(await prompts.text('放弃旧值，重新输入所选渠道凭据？[y/N] ')))
+            out('当前凭据暂时读不到，可能是条目缺失、凭据库锁定或权限不足。');
+            if (!yes(await prompts.text('要重新输入所选渠道的凭据吗？[y/N] ')))
                 return false;
         }
     }
     else if (reference?.backend === 'system')
-        out('检测到 Python 原型凭据；本次重新输入保存，旧凭据不读取、不删除。');
+        out('检测到旧版原型保存的凭据。本次会重新输入并保存为 Node 版凭据，旧凭据保持不变。');
     data.telegram ??= {};
     data.feishu ??= {};
     data.telegram.enabled = selection !== '2';
@@ -161,11 +165,12 @@ export async function wizard(file, options = {}) {
     const values = {};
     const readValue = async (label, key, required) => {
         while (true) {
-            const hint = previous[key] ? '留空保留已存值' : '不从环境变量自动复制';
-            const answer = await prompts.secret(`${label}（${hint}${required ? '' : '；输入 - 清除'}）：`);
+            const hint = previous[key] ? '留空保留当前值' : '不会从环境变量自动填充';
+            const optional = required ? '' : '可选；';
+            const answer = await prompts.secret(`${label}（隐藏输入，不回显；${optional}${hint}${required ? '' : '；输入 - 清除'}）：`);
             const value = !required && answer === '-' ? '' : answer || previous[key] || '';
             if (required && !value) {
-                out('此项不能为空，请重试，或 Ctrl+C 取消。');
+                out('这一项不能为空，请重新输入；按 Ctrl+C 可退出。');
                 continue;
             }
             try {
@@ -175,15 +180,15 @@ export async function wizard(file, options = {}) {
                 return value;
             }
             catch {
-                out('格式不正确，请检查后重新输入；不会显示秘密。');
+                out('格式不正确，请重新输入（输入内容不会显示）。');
             }
         }
     };
     if (data.telegram.enabled) {
         values.telegram_token = await readValue('Telegram Bot Token', 'telegram_token', true);
-        out('接收人需要先启动 Bot；本轮手动填写数字 chat_id，不启动 getUpdates 或自动配对。');
+        out('请先让接收人给 Bot 发一条消息，然后填写数字 chat_id；这里不会自动获取或配对接收人。');
         while (true) {
-            const entered = await prompts.text('接收人 chat_id，多个用逗号分隔（留空保留原名单）：');
+            const entered = await prompts.text('接收人 chat_id，多个用逗号分隔（留空保留现有名单）：');
             const ids = entered ? entered.split(',').map(item => item.trim()) : data.telegram.chat_ids ?? [];
             try {
                 if (!ids.length)
@@ -193,58 +198,84 @@ export async function wizard(file, options = {}) {
                 break;
             }
             catch {
-                out('请填写至少一个有效数字 chat_id，或 Ctrl+C 取消。');
+                out('请填写至少一个有效的数字 chat_id；按 Ctrl+C 可退出。');
             }
         }
     }
     if (data.feishu.enabled) {
         values.feishu_webhook = await readValue('飞书 webhook', 'feishu_webhook', true);
-        values.feishu_secret = await readValue('飞书签名密钥（可选）', 'feishu_secret', false);
+        values.feishu_secret = await readValue('飞书签名密钥', 'feishu_secret', false);
     }
     encodeBundle(values);
     const preview = { ...data, credentials: { backend: 'keyring', id: '0'.repeat(32) } };
     parseConfig(preview, {}, () => values);
     const env = options.env ?? process.env;
-    out(`将启用：${data.telegram.enabled ? `Telegram（${data.telegram.chat_ids.length} 个接收人）` : ''}${data.feishu.enabled ? ' 飞书' : ''}`);
-    out('环境变量仍优先（含显式空值）；测试通知会使用最终生效的配置，不一定是刚输入的值。');
+    const channels = [];
+    if (data.telegram.enabled)
+        channels.push(`Telegram（${data.telegram.chat_ids.length} 个接收人）`);
+    if (data.feishu.enabled)
+        channels.push('飞书');
+    out(`将启用：${channels.join('、')}`);
+    out('环境变量的优先级更高，空值也会覆盖这里的设置；测试通知使用最终生效的配置。');
     const overrides = [data.telegram.token_env ?? 'TELEGRAM_BOT_TOKEN', data.feishu.webhook_env ?? 'FEISHU_WEBHOOK',
         data.feishu.secret_env ?? 'FEISHU_SECRET', 'TELEGRAM_CHAT_ID', 'TELEGRAM_CHAT_IDS'].filter(name => Object.hasOwn(env, name));
     if (overrides.length)
-        out('当前存在环境覆盖：' + overrides.join('、'));
+        out('以下环境变量正在覆盖配置：' + overrides.join('、'));
     if (reference?.backend === 'keyring')
-        out('保存成功后删除旧凭据；共享旧引用 ID 的配置副本也需更新。');
-    out('未选中的渠道会禁用；新条目只保存所选渠道凭据。');
-    if (!yes(await prompts.text('确认保存配置和系统凭据？[y/N] ')))
+        out('保存成功后会删除旧凭据；如果其他配置也引用了同一个凭据，需要一并更新。');
+    out('没有选中的渠道会被停用；新凭据只用于本次选中的渠道。');
+    for (const line of options.notes ?? [])
+        out(line);
+    const actions = ['保存配置和系统凭据'];
+    if (options.testSend)
+        actions.push('发送固定内容的测试通知');
+    if (options.afterSave)
+        actions.push('安装 Claude Code 通知 hooks');
+    if (!defaultYes(await prompts.text(`将${actions.join('、')}。继续？[Y/n] `)))
         return false;
     await commitConfig(file, data, before, store, values, { warn: out });
     out('配置和系统凭据已保存。');
-    if (options.testSend && yes(await prompts.text('发送固定内容的测试通知到生效的接收目标？[y/N] '))) {
+    if (options.testSend) {
         try {
             const effective = parseConfig(preview, env, () => values);
             const ok = await options.testSend(effective);
-            out(ok ? '测试通知发送成功。' : '配置已保存，但测试通知失败或没有可用渠道；请运行 doctor 检查。');
+            out(ok ? '测试通知发送成功。' : '配置已保存。测试通知没有发送成功，请运行 dev-notify doctor 检查。');
         }
         catch {
-            out('配置已保存，但环境覆盖或网络导致测试失败；请运行 doctor 检查。');
+            out('配置已保存。测试通知没有发送成功，可能是环境变量覆盖或网络问题；请运行 dev-notify doctor 检查。');
         }
     }
     else
-        out('未发送测试通知。');
+        out('已跳过测试通知。');
+    if (options.afterSave) {
+        try {
+            await options.afterSave();
+        }
+        catch (error) {
+            out(`配置已保存。Claude Code hooks 没有安装完成：${error instanceof ConfigError ? error.message : '请运行 integration claude-code status 检查'}`);
+        }
+    }
+    try {
+        if (ready(parseConfig(preview, env, () => values), 'telegram')) {
+            out('如需在 Telegram 中回复 Claude，请运行：dev-notify reply setup');
+        }
+    }
+    catch { /* 环境覆盖无效时上方测试分支已报告。 */ }
     return true;
 }
 export async function clearCredentials(file, prompts, store) {
     const before = await snapshot(file), data = readRaw(before);
     const reference = data.credentials;
     if (!reference) {
-        prompts.out('此配置没有系统凭据引用，未修改。');
+        prompts.out('当前配置没有系统凭据引用，无需清理。');
         return true;
     }
     if (reference.backend !== 'keyring')
-        throw new ConfigError('这是 Python 原型的凭据，Node 不执行跨实现删除');
-    prompts.out('将移除当前配置的系统凭据引用并删除其条目；环境变量不变，共享引用的配置副本将失效。');
-    if (!yes(await prompts.text('确认清除？[y/N] ')))
+        throw new ConfigError('这是旧版原型保存的凭据；Node 版不会跨实现删除，请用原工具处理。');
+    prompts.out('将删除当前配置引用的系统凭据，并从配置中移除引用。环境变量不受影响；如果其他配置共享同一个凭据，它们也会失效。');
+    if (!yes(await prompts.text('确认清除吗？[y/N] ')))
         return false;
     await commitConfig(file, data, before, store ?? nativeStore(), null, { warn: prompts.out });
-    prompts.out('凭据引用已移除；如删除条目失败，上方会显示警告。');
+    prompts.out('凭据引用已移除。如果系统条目删除失败，上方会显示提示。');
     return true;
 }

package/dist/update.js

@@ -0,0 +1,92 @@
+import { spawnSync } from 'node:child_process';
+import { ConfigError } from './config.js';
+import { terminalPrompts } from './prompts.js';
+const NAME = '@quecue/dev-notify';
+const VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(alpha|beta|rc)\.(0|[1-9]\d*))?$/;
+function npmRunner(args, capture) {
+    // Windows 的 npm 是 .cmd；Node 不能直接 spawn，需要经过 shell。参数均为固定值。
+    const result = spawnSync('npm', args, {
+        encoding: 'utf8',
+        stdio: capture ? 'pipe' : 'inherit',
+        timeout: capture ? 30000 : 300000,
+        shell: process.platform === 'win32',
+    });
+    if (result.error)
+        throw new ConfigError('无法运行 npm。请确认已安装 npm，并且它在 PATH 中。');
+    return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}
+async function fetchLatest() {
+    let response;
+    try {
+        response = await fetch(`https://registry.npmjs.org/${NAME.replace('/', '%2F')}/latest?t=${Date.now()}`, {
+            redirect: 'error',
+            signal: AbortSignal.timeout(10000),
+            headers: { 'Cache-Control': 'no-cache, no-store', Accept: 'application/json' },
+        });
+    }
+    catch {
+        throw new ConfigError('无法检查最新版本。请检查网络后重试。');
+    }
+    if (!response.ok)
+        throw new ConfigError(`无法检查最新版本（HTTP ${response.status}）。请检查网络后重试。`);
+    let version;
+    try {
+        version = (await response.json())?.version;
+    }
+    catch {
+        throw new ConfigError('npm registry 返回的版本信息无法解析。');
+    }
+    if (typeof version !== 'string' || !VERSION.test(version))
+        throw new ConfigError('npm registry 返回的版本号格式不受支持。');
+    return version;
+}
+function parts(version) {
+    const match = VERSION.exec(version);
+    if (!match)
+        throw new ConfigError('版本号格式不受支持。');
+    const rank = match[4] === 'alpha' ? 1 : match[4] === 'beta' ? 2 : match[4] === 'rc' ? 3 : 4;
+    return [Number(match[1]), Number(match[2]), Number(match[3]), rank, Number(match[5] ?? 0)];
+}
+export function compareVersions(left, right) {
+    const a = parts(left), b = parts(right);
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return a[i] > b[i] ? 1 : -1;
+    return 0;
+}
+async function confirmUpdate(latest, options) {
+    if (options.yes)
+        return true;
+    if (!options.prompts && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+        throw new ConfigError('更新需要在交互终端中确认；非交互场景请使用 dev-notify update --yes。');
+    }
+    const prompts = options.prompts ?? terminalPrompts();
+    return /^(y|yes)$/i.test(await prompts.text(`更新到 ${latest}？[y/N] `));
+}
+export async function updatePackage(current, options) {
+    if (!VERSION.test(current))
+        throw new ConfigError('当前版本号格式不受支持，无法检查更新。');
+    const latest = await (options.latest ?? fetchLatest)();
+    if (!VERSION.test(latest))
+        throw new ConfigError('npm registry 返回的版本号格式不受支持。');
+    if (compareVersions(latest, current) <= 0) {
+        options.out(`已是最新版本 ${current}。`);
+        return 0;
+    }
+    options.out(`当前版本 ${current}，npm 最新版本 ${latest}。`);
+    if (options.check) {
+        options.out('运行 dev-notify update 更新。');
+        return 0;
+    }
+    if (!await confirmUpdate(latest, options)) {
+        options.out('已取消，没有更新。');
+        return 130;
+    }
+    options.out(`运行 npm install -g ${NAME}@${latest} ...`);
+    const result = (options.runner ?? npmRunner)(['install', '-g', `${NAME}@${latest}`], false);
+    if (result.status !== 0)
+        throw new ConfigError(`更新没有完成。请检查 npm 权限，或手动运行 npm install -g ${NAME}@latest。`);
+    options.out(`已更新到 ${latest}。请重新打开终端后运行 dev-notify --version 确认。`);
+    options.out('如有 Claude Code hooks，请运行 dev-notify integration claude-code install；如使用远程回复，请重启桥接。');
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quecue/dev-notify",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.1",
   "description": "跨平台开发任务通知工具，支持 Telegram 与飞书",
   "license": "MIT",
   "repository": {