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

package/dist/cli.js

@@ -9,32 +9,39 @@ import { deliver, makePlan } from './channels.js';
 import { wizard, clearCredentials } from './setup.js';
 import { terminalPrompts, readText, Cancelled } from './prompts.js';
 import { CredentialError } from './credentials.js';
-import { claudeCodeStatus, configureClaudeCode, offerClaudeCode } from './claude-code.js';
+import { claudeCodeStatus, claudeSettingsPath, configureClaudeCode } from './claude-code.js';
 import { dispatchClaudeHook, readHookInput } from './claude-hook.js';
 import { accessReplies, configureReplies, disableReplies } from './reply-state.js';
 import { startBridge, stopBridge, bridgeStatus, runBridge } from './reply-bridge.js';
-const HELP = `dev-notify 0.1.0-alpha.3 — 跨平台开发任务通知
+import { updatePackage } from './update.js';
+export const VERSION = '0.1.1';
+const HELP = `dev-notify ${VERSION} — 跨平台开发任务通知
 
 命令：
   send --title 标题 [--content 正文 | --content-file 文件 | --stdin]
        [--channel all|telegram|feishu] [--level info|success|warn|error]
        [--footer 辅助信息] [--dry-run]
-  setup                     配置渠道及系统凭据，可选测试与 Claude Code 通知
-  setup --template [--yes]   仅创建无密钥模板，不覆盖已有配置、不安装 hooks
-  credentials clear         确认后移除当前 Node 凭据引用和条目
-  paths                     显示配置路径，不写文件
-  doctor / status           离线检查，不发消息
+  setup [--no-test] [--no-hooks]
+                            配置渠道及系统凭据；默认同时发送测试并安装
+                            Claude Code 通知 hooks，一次确认完成
+  setup --template [--yes]   只创建无密钥模板；不会覆盖已有配置，也不会安装 hooks
+  credentials clear         移除当前 Node 凭据引用和条目（需要确认）
+  paths                     显示配置路径（不会写入文件）
+  doctor / status           离线检查（不会发送消息）
+  update [--check] [--yes]  检查并更新到 npm 最新版本（确认后调用 npm）
   integration list          列出可用集成
   integration claude-code install / status / remove
                             单独安装、查询或移除用户级 hooks
-  reply setup               另行授权可信 Telegram 私聊用户
+  reply setup               授权可信的 Telegram 私聊用户
   reply start / status / stop
                             启动、查询或停止回复桥接
-  reply disable             确认后撤销远程回复授权并请求停止桥接
+  reply disable             撤销远程回复授权并停止桥接（需要确认）
   reply run                 前台运行桥接（排错用，不启用系统自启动）
 
 全局选项：--config 路径、--help、--version
-系统凭据使用 Windows Credential Manager / macOS Keychain；不调用 Python，不写入明文密钥。`;
+环境变量：TELEGRAM_BOT_TOKEN、TELEGRAM_CHAT_ID / TELEGRAM_CHAT_IDS、
+          FEISHU_WEBHOOK、FEISHU_SECRET；显式存在时优先。详见 README。
+系统凭据保存在 Windows Credential Manager / macOS Keychain；不会写入明文密钥。`;
 const defaults = {
     env: process.env,
     out: text => console.log(text),
@@ -44,7 +51,7 @@ const defaults = {
     hookStdin: () => readHookInput(),
     confirm: async () => {
         if (!process.stdin.isTTY)
-            throw new ConfigError('非交互环境请使用 setup --template --yes');
+            throw new ConfigError('当前不是交互终端。自动化场景请使用 setup --template --yes。');
         return /^(y|yes)$/i.test(await readText('确认创建模板？[y/N] '));
     },
     send: deliver,
@@ -60,10 +67,11 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                     title: { type: 'string' }, content: { type: 'string' }, 'content-file': { type: 'string' }, stdin: { type: 'boolean' },
                     channel: { type: 'string' }, level: { type: 'string' }, footer: { type: 'string' }, 'dry-run': { type: 'boolean' },
                     template: { type: 'boolean' }, yes: { type: 'boolean' },
+                    'no-test': { type: 'boolean' }, 'no-hooks': { type: 'boolean' }, check: { type: 'boolean' },
                 } });
         }
         catch {
-            throw new ConfigError('参数无效，请使用 --help；不回显可能含秘密的参数');
+            throw new ConfigError('参数无效，请运行 --help 查看用法。');
         }
         const { values, positionals } = parsed;
         if (values.help) {
@@ -71,30 +79,36 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
             return 0;
         }
         if (values.version) {
-            context.out('dev-notify 0.1.0-alpha.3');
+            context.out(`dev-notify ${VERSION}`);
             return 0;
         }
         const [command, action, integrationAction] = positionals;
         const allowed = {
             send: ['title', 'content', 'content-file', 'stdin', 'channel', 'level', 'footer', 'dry-run'],
-            setup: ['template', 'yes'], paths: [], doctor: [], status: [], integration: [], credentials: [], reply: [],
+            setup: ['template', 'yes', 'no-test', 'no-hooks'], paths: [], doctor: [], status: [], integration: [], credentials: [], reply: [], update: ['check', 'yes'],
         };
         if (!command || !Object.hasOwn(allowed, command) || positionals.length > (command === 'integration' ? 3 : command === 'credentials' || command === 'reply' ? 2 : 1)
             || Object.keys(values).some(key => key !== 'config' && !allowed[command].includes(key)))
-            throw new ConfigError('命令或选项组合无效，请使用 --help');
+            throw new ConfigError('命令或选项组合不正确，请运行 --help 查看用法。');
         const paths = appPaths(process.platform, context.env);
         const file = values.config ? path.resolve(values.config) : paths.config;
         if (command === 'paths') {
             context.out(JSON.stringify({ config: file, data: paths.data }, null, 2));
             return 0;
         }
+        if (command === 'update') {
+            return await updatePackage(VERSION, {
+                out: context.out, prompts: context.prompts,
+                check: !!values.check, yes: !!values.yes,
+            });
+        }
         if (command === 'integration') {
             if (action === 'list' && !integrationAction) {
-                context.out('claude-code: 可选通知集成、Telegram 回复与结构化问题交互；通知 hooks 与 reply setup 输入授权分开，默认不开启远程输入。');
+                context.out('claude-code：支持通知、Telegram 回复和结构化问题交互。通知 hooks 与回复权限分开，默认只发送通知，不接收远程输入。');
                 return 0;
             }
             if (action !== 'claude-code' || !['install', 'status', 'remove', 'hook'].includes(integrationAction))
-                throw new ConfigError('请使用 integration list 或 integration claude-code install / status / remove');
+                throw new ConfigError('请使用 integration list，或 integration claude-code install / status / remove。');
             if (integrationAction === 'hook') {
                 await dispatchClaudeHook(await context.hookStdin(), file, { ...context, response: value => context.out(JSON.stringify(value)) });
                 return 0;
@@ -103,44 +117,44 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                 const status = await claudeCodeStatus({ env: context.env });
                 context.out(`Claude Code 用户级设置：${status.file}`);
                 context.out(`本工具 hooks：Stop ${status.stop} 个，Notification ${status.notification} 个，会话生命周期 ${status.lifecycle}/3 个，交互及结果确认 ${status.interaction}/5 个；其他处理器 ${status.others} 个。`);
-                context.out(status.disabled ? '当前文件设置了 disableAllHooks；本工具不会解除禁用。'
-                    : '仅检查用户级文件；实际是否加载或受项目、托管策略限制，请在 Claude Code /hooks 中确认。');
+                context.out(status.disabled ? '当前文件启用了 disableAllHooks，安装后 hooks 不会生效；请自行解除禁用。'
+                    : '这里只检查用户级文件。是否实际加载还受项目和托管策略影响，请在 Claude Code 的 /hooks 中确认。');
                 return status.stop === 1 && status.notification === 1 && status.lifecycle === 3 && status.interaction === 5 && !status.disabled ? 0 : 1;
             }
             const prompts = context.prompts ?? terminalPrompts();
             if (integrationAction === 'install') {
                 const config = await loadConfig(file, true, context.env);
                 if (!ready(config, 'telegram') && !ready(config, 'feishu'))
-                    throw new ConfigError('请先运行 setup 配置可用通知渠道，再安装 Claude Code hooks');
+                    throw new ConfigError('请先运行 setup 配置至少一个通知渠道，再安装 Claude Code hooks。');
             }
             return await configureClaudeCode(file, integrationAction, prompts, { env: context.env }) ? 0 : 130;
         }
         if (command === 'reply') {
             if (!['setup', 'start', 'status', 'stop', 'disable', 'run'].includes(action))
-                throw new ConfigError('请使用 reply setup / start / status / stop / disable / run');
+                throw new ConfigError('请使用 reply setup / start / status / stop / disable / run。');
             if (action === 'setup') {
                 const saved = await configureReplies(file, context.prompts ?? terminalPrompts(), context.env);
                 if (saved)
-                    context.out('授权已保存；请确认已安装本版 hooks，再运行 reply start。新授权不会恢复旧消息映射。');
+                    context.out('授权已保存。请确认 hooks 已安装，然后运行 reply start。旧消息的回复映射不会保留。');
                 return saved ? 0 : 130;
             }
             if (action === 'disable') {
                 if (!await disableReplies(file, context.prompts ?? terminalPrompts()))
                     return 130;
                 const stopped = await stopBridge(file);
-                context.out(stopped ? '桥接已停止或未运行。' : '已撤销授权并请求停止；正在进行中的调用不能撤回。');
+                context.out(stopped ? '桥接已停止或未运行。' : '已撤销授权并请求停止。正在进行中的调用无法撤回。');
                 return 0;
             }
             if (action === 'stop') {
                 const stopped = await stopBridge(file);
-                context.out(stopped ? '桥接已停止或未运行；授权仍保留，下一次事件可再次启动。彻底关闭请用 reply disable。'
-                    : '停止请求已登记；桥接尚未退出，未强杀进程，请用 reply status 检查。');
+                context.out(stopped ? '桥接已停止或未运行。授权仍然保留，下次事件可以再次启动；如需彻底关闭，请运行 reply disable。'
+                    : '已发出停止请求，桥接正在退出。可运行 reply status 查看状态。');
                 return stopped ? 0 : 1;
             }
             if (action === 'status') {
                 const access = await accessReplies(file, context.env), status = await bridgeStatus(file);
-                context.out(access ? `远程回复：已另行授权 ${access.policy.users.length} 个私聊用户；逐次工具权限${access.policy.permissions ? '已启用' : '未启用'}。` : '远程回复：未启用。');
-                context.out(status.ready ? '桥接：已就绪。' : status.running ? '桥接：进程存在但未就绪。' : '桥接：未运行。');
+                context.out(access ? `远程回复：已授权 ${access.policy.users.length} 个私聊用户；工具权限逐次确认${access.policy.permissions ? '已开启' : '未开启'}。` : '远程回复：尚未启用。');
+                context.out(status.ready ? '桥接：已就绪。' : status.running ? '桥接：进程存在，但还没有就绪。' : '桥接：未运行。');
                 if (status.error)
                     context.err(status.error);
                 return access && status.ready ? 0 : 1;
@@ -150,22 +164,39 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                 return 0;
             }
             const ready = await startBridge(file, context.env);
-            context.out(ready ? '回复桥接已就绪；请从新任务通知进入。' : '桥接尚未就绪；请用 reply status / reply run 查看安全错误，不要同时运行旧 Python 桥接。');
+            context.out(ready ? '回复桥接已就绪。请从新的任务通知进入。' : '桥接还没有就绪。请运行 reply status 或 reply run 查看原因；如果旧版桥接在运行，请先停用它。');
             return ready ? 0 : 1;
         }
         if (command === 'credentials') {
             if (action !== 'clear')
-                throw new ConfigError('当前只支持 credentials clear，且必须交互确认');
+                throw new ConfigError('credentials 目前只支持 clear，并且需要在交互终端中确认。');
             return await clearCredentials(file, context.prompts ?? terminalPrompts()) ? 0 : 130;
         }
         if (command === 'setup') {
             if (!values.template) {
                 if (values.yes)
-                    throw new ConfigError('--yes 只允许与 --template 同时使用，不能跳过密钥保存确认');
+                    throw new ConfigError('--yes 只能和 --template 一起使用；保存密钥前仍然需要确认。');
                 const prompts = context.prompts ?? terminalPrompts();
+                const notes = [];
+                const test = !values['no-test'];
+                if (test)
+                    notes.push('保存后会向最终生效的接收目标发送一条固定内容的测试通知。');
+                let hooks = !values['no-hooks'];
+                if (hooks) {
+                    try {
+                        notes.push(`Claude Code 用户级设置：${claudeSettingsPath(context.env)}`);
+                        notes.push('会为该设置文件对应的所有项目安装通知 hooks。最终回复正文可能包含敏感内容，将发送到配置实际生效的渠道。');
+                        notes.push('同时安装会话生命周期和结构化问题 hooks。远程输入只有在运行 reply setup 授权后才会开启。');
+                    }
+                    catch (error) {
+                        hooks = false;
+                        context.out(error instanceof ConfigError ? `跳过 Claude Code hooks：${error.message}` : '跳过 Claude Code hooks：没有找到用户级设置路径。');
+                    }
+                }
+                let integrationFailed = false;
                 const saved = await wizard(file, {
-                    prompts, store: context.store, env: context.env,
-                    testSend: async (config) => {
+                    prompts, store: context.store, env: context.env, notes,
+                    testSend: test ? async (config) => {
                         let count = 0, ok = true;
                         for (const channel of ['telegram', 'feishu']) {
                             if (!ready(config, channel))
@@ -173,57 +204,50 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                             count++;
                             const plan = makePlan(channel, { title: 'dev-notify 配置测试', content: '这是一条由你确认发送的测试通知。', footer: '', level: 'info' }, config);
                             const result = await context.send(plan, config);
-                            context.out(`${channel}: 测试已发送 ${result.sent}/${result.planned}`);
+                            context.out(`${channel}：测试已发送 ${result.sent}/${result.planned} 条`);
                             ok = ok && result.ok;
                         }
                         return count > 0 && ok;
-                    },
+                    } : undefined,
+                    afterSave: hooks ? async () => {
+                        try {
+                            await configureClaudeCode(file, 'install', prompts, { env: context.env, confirm: false });
+                        }
+                        catch (error) {
+                            integrationFailed = true;
+                            throw error;
+                        }
+                    } : undefined,
                 });
                 if (!saved)
                     return 130;
-                try {
-                    await offerClaudeCode(file, prompts, { env: context.env });
-                    const config = await loadConfig(file, true, context.env);
-                    if (ready(config, 'telegram') && /^(y|yes)$/i.test(await prompts.text('是否另行配置可信私聊用户回复 Claude？默认关闭。[y/N] '))) {
-                        await configureReplies(file, prompts, context.env);
-                        context.out('回复授权流程结束；确认 hooks 已安装后可运行 reply start，或由下一次支持的会话事件启动。');
-                    }
-                }
-                catch (error) {
-                    if (error instanceof Cancelled) {
-                        context.out('渠道配置已保存；已取消后续 Claude Code 集成/回复配置。');
-                        return 0;
-                    }
-                    context.err('渠道配置已保存，但 Claude Code hook 或回复配置未完成；请运行 integration claude-code status / reply status 检查后重试。');
-                    return 1;
-                }
-                return 0;
+                return integrationFailed ? 1 : 0;
             }
-            context.out(`将创建无密钥模板: ${file}；不会联网或修改 hooks`);
+            context.out(`将创建无密钥模板：${file}。不会联网，也不会修改 hooks。`);
             if (!values.yes && !await context.confirm()) {
-                context.out('已取消，未写入');
+                context.out('已取消，没有写入。');
                 return 130;
             }
             await createConfig(file);
-            context.out('已创建模板；请配置环境凭据和接收人');
+            context.out('模板已创建。请配置环境凭据和接收人。');
             return 0;
         }
         const config = await loadConfig(file, values.config !== undefined, context.env);
         if (command === 'doctor' || command === 'status') {
             context.out(`配置路径: ${file}`);
             for (const channel of ['telegram', 'feishu'])
-                context.out(`${channel}: ${ready(config, channel) ? '配置齐全，网络未验证' : '未启用或配置不完整'}`);
-            context.out('凭据: 环境变量优先，其次 Windows Credential Manager / macOS Keychain；检查不联网，系统可能要求授权');
+                context.out(`${channel}：${ready(config, channel) ? '配置完整（尚未验证网络）' : '未启用或配置不完整'}`);
+            context.out('凭据：优先使用环境变量，其次系统凭据；本检查不联网，系统可能弹出授权提示。');
             return ready(config, 'telegram') || ready(config, 'feishu') ? 0 : 1;
         }
         if (!values.title?.trim())
-            throw new ConfigError('send 必须指定非空 --title');
+            throw new ConfigError('send 需要提供非空的 --title。');
         if ([values.content !== undefined, values['content-file'] !== undefined, !!values.stdin].filter(Boolean).length > 1)
-            throw new ConfigError('正文来源只能指定一个');
+            throw new ConfigError('--content、--content-file 和 --stdin 只能选择一个。');
         const level = values.level ?? 'info';
         const channel = values.channel ?? 'all';
         if (!['info', 'success', 'warn', 'error'].includes(level) || !['all', 'telegram', 'feishu'].includes(channel))
-            throw new ConfigError('渠道或通知级别无效');
+            throw new ConfigError('渠道或通知级别不正确。');
         let content = values.content ?? values.title;
         if (values['content-file'] !== undefined)
             content = decodeUtf8(await readFile(values['content-file']));
@@ -235,7 +259,7 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
         for (const name of selected) {
             if (!ready(config, name)) {
                 if (channel !== 'all')
-                    throw new ConfigError('指定渠道未启用或配置不完整');
+                    throw new ConfigError('这个渠道未启用，或配置不完整。');
                 continue;
             }
             planned++;
@@ -244,31 +268,31 @@ export async function main(argv = process.argv.slice(2), overrides = {}) {
                 plan = makePlan(name, message, config);
             }
             catch {
-                context.err(`${name}: 无法生成安全分段，请缩短标题/辅助信息或检查正文格式`);
+                context.err(`${name}：无法安全分段。请缩短标题或底部信息，或检查正文格式。`);
                 failed = true;
                 continue;
             }
             if (values['dry-run']) {
-                context.out(`${name}: 接收目标 ${plan.recipients}，预计请求 ${plan.items.length}；未发送`);
+                context.out(`${name}：接收目标 ${plan.recipients}，预计请求 ${plan.items.length} 条（dry-run，没有实际发送）`);
                 continue;
             }
             const result = await context.send(plan, config);
-            context.out(`${name}: 已发送 ${result.sent}/${result.planned}`);
+            context.out(`${name}：已发送 ${result.sent}/${result.planned} 条`);
             if (!result.ok) {
                 failed = true;
-                context.err(result.error ?? '投递失败');
+                context.err(result.error ?? '发送失败。');
             }
         }
         if (!planned)
-            throw new ConfigError('没有可发送的渠道，请配置环境凭据和接收人');
+            throw new ConfigError('没有可用渠道，请先配置环境凭据和接收人。');
         return failed ? 1 : 0;
     }
     catch (error) {
         if (error instanceof Cancelled) {
-            context.out('已取消，未继续执行。');
+            context.out('已取消。');
             return isHook ? 0 : 130;
         }
-        context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : '操作失败，请检查文件、权限或输入；不输出可能含秘密的底层异常');
+        context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : '操作失败。请检查文件、权限或输入；为避免泄露密钥，这里不显示底层异常。');
         // Stop hook 的退出码 2 会要求 Claude 继续；通知失败只能报告，不能阻塞或触发重试循环。
         return isHook ? 0 : 2;
     }

package/dist/config.js

@@ -13,7 +13,7 @@ export function appPaths(platform = process.platform, env = process.env, home) {
     const join = platform === 'win32' ? path.win32 : path.posix;
     if (env.DEV_NOTIFY_HOME) {
         if (!join.isAbsolute(env.DEV_NOTIFY_HOME))
-            throw new ConfigError('DEV_NOTIFY_HOME 必须是绝对路径');
+            throw new ConfigError('DEV_NOTIFY_HOME 需要是绝对路径。');
         return { config: join.join(env.DEV_NOTIFY_HOME, 'config', 'config.json'), data: join.join(env.DEV_NOTIFY_HOME, 'data') };
     }
     home ??= homedir();
@@ -31,23 +31,23 @@ export function appPaths(platform = process.platform, env = process.env, home) {
 }
 export function object(value, allowed, name) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new ConfigError(`${name} 必须是 JSON 对象`);
+        throw new ConfigError(`${name} 需要是 JSON 对象。`);
     const result = value;
     if (Object.keys(result).some(key => !allowed.includes(key)))
-        throw new ConfigError(`${name} 包含不支持的字段；不能直接保存明文密钥`);
+        throw new ConfigError(`${name} 包含不支持的字段；不能直接保存明文密钥。`);
     return result;
 }
 function enabled(section) {
     if (section.enabled === undefined)
         return true;
     if (typeof section.enabled !== 'boolean')
-        throw new ConfigError('enabled 必须是布尔值');
+        throw new ConfigError('enabled 需要是布尔值。');
     return section.enabled;
 }
 function secret(section, field, fallback, env, stored) {
     const name = section[field] ?? fallback;
     if (typeof name !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
-        throw new ConfigError('凭据引用必须是合法的环境变量名称');
+        throw new ConfigError('凭据引用需要是合法的环境变量名称。');
     if (Object.hasOwn(env, name))
         return (env[name] ?? '').trim();
     return enabled(section) ? stored().trim() : '';
@@ -55,12 +55,12 @@ function secret(section, field, fallback, env, stored) {
 export function parseConfig(input, env = process.env, resolver = resolveReference) {
     const data = object(input, ['version', 'telegram', 'feishu', 'credentials'], '配置');
     if ((data.version ?? 1) !== 1)
-        throw new ConfigError('不支持的配置版本');
+        throw new ConfigError('不支持这个配置版本。');
     let reference;
     if (data.credentials !== undefined) {
         const value = object(data.credentials, ['backend', 'id'], 'credentials');
         if (!['system', 'keyring'].includes(String(value.backend)) || typeof value.id !== 'string' || !/^[a-f0-9]{32}$/.test(value.id))
-            throw new ConfigError('系统凭据引用无效');
+            throw new ConfigError('系统凭据引用无效。');
         reference = value;
     }
     let cached;
@@ -78,18 +78,18 @@ export function parseConfig(input, env = process.env, resolver = resolveReferenc
         ids = `${env.TELEGRAM_CHAT_ID ?? ''},${env.TELEGRAM_CHAT_IDS ?? ''}`.split(',').map(v => v.trim()).filter(Boolean);
     }
     if (!Array.isArray(ids))
-        throw new ConfigError('telegram.chat_ids 必须是数组');
+        throw new ConfigError('telegram.chat_ids 需要是数组。');
     const chatIds = [...new Set(ids.map(value => {
             if (typeof value !== 'string' && !(typeof value === 'number' && Number.isSafeInteger(value)))
-                throw new ConfigError('接收人必须是数字 chat_id；大整数请使用字符串');
+                throw new ConfigError('接收人需要使用数字 chat_id；大整数请写成字符串。');
             const id = String(value).trim();
             if (!/^-?[1-9][0-9]*$/.test(id))
-                throw new ConfigError('接收人必须是非零数字 chat_id');
+                throw new ConfigError('接收人需要是非零的数字 chat_id。');
             return id;
         }))];
     const token = secret(tg, 'token_env', 'TELEGRAM_BOT_TOKEN', env, () => stored('telegram_token'));
     if (token && !/^[0-9]+:[A-Za-z0-9_-]+$/.test(token))
-        throw new ConfigError('Telegram Token 格式无效');
+        throw new ConfigError('Telegram Token 格式不正确。');
     const webhook = secret(fs, 'webhook_env', 'FEISHU_WEBHOOK', env, () => stored('feishu_webhook'));
     if (webhook) {
         let valid = false;
@@ -99,7 +99,7 @@ export function parseConfig(input, env = process.env, resolver = resolveReferenc
         }
         catch { /* 不输出含秘密的 URL 异常。 */ }
         if (!valid)
-            throw new ConfigError('飞书 webhook 必须是 open.feishu.cn 的 HTTPS 自定义机器人地址');
+            throw new ConfigError('飞书 webhook 需要是 open.feishu.cn 的 HTTPS 自定义机器人地址。');
     }
     return { telegram: { enabled: tgEnabled, token, chatIds }, feishu: { enabled: fsEnabled, webhook,
             secret: secret(fs, 'secret_env', 'FEISHU_SECRET', env, () => stored('feishu_secret')) } };
@@ -113,7 +113,7 @@ export function decodeUtf8(data) {
         return new TextDecoder('utf-8', { fatal: true }).decode(data);
     }
     catch {
-        throw new ConfigError('输入必须是有效的 UTF-8 文本');
+        throw new ConfigError('输入需要是有效的 UTF-8 文本。');
     }
 }
 export async function loadConfig(file, required = false, env = process.env) {
@@ -124,7 +124,7 @@ export async function loadConfig(file, required = false, env = process.env) {
     catch (error) {
         if (error.code === 'ENOENT' && !required)
             return parseConfig({}, env);
-        throw new ConfigError('配置文件缺失、不可读取或不是合法 UTF-8 JSON');
+        throw new ConfigError('配置文件缺失、无法读取，或不是合法的 UTF-8 JSON。');
     }
     return parseConfig(input, env);
 }
@@ -135,7 +135,7 @@ export async function createConfig(file) {
     }
     catch (error) {
         if (error.code === 'EEXIST')
-            throw new ConfigError('配置已存在，未覆盖；Node 版不会修改 Python 原型的配置');
-        throw new ConfigError('无法创建配置，请检查路径和权限');
+            throw new ConfigError('配置已经存在，没有覆盖。Node 版不会修改旧版原型的配置。');
+        throw new ConfigError('无法创建配置，请检查路径和权限。');
     }
 }

package/dist/credentials.js

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

package/dist/formatting.js

@@ -104,7 +104,7 @@ export function visibleText(blocks) {
 }
 function cut(text, budget, measure) {
     if (budget < 1)
-        throw new Error('分段空间不足');
+        throw new Error('可用空间不足，无法分段。');
     let used = 0, end = 0;
     for (const ch of text) {
         const size = measure(ch);
@@ -114,7 +114,7 @@ function cut(text, budget, measure) {
         end += ch.length;
     }
     if (!end && text)
-        throw new Error('分段空间不足以容纳一个字符');
+        throw new Error('可用空间连一个字符都放不下。');
     if (end < text.length) {
         for (const boundary of ['\n\n', '\n', ' ']) {
             const offset = text.slice(0, end).lastIndexOf(boundary);
@@ -128,7 +128,7 @@ function cut(text, budget, measure) {
 }
 export function telegramParts(blocks, budget) {
     if (budget < 2)
-        throw new Error('Telegram 标题或辅助信息过长');
+        throw new Error('Telegram 标题或底部信息太长，没有剩余空间放正文。');
     const output = [];
     let html = '', plain = '';
     const flush = () => { if (plain)
@@ -156,7 +156,7 @@ export function telegramParts(blocks, budget) {
 }
 export function feishuParts(blocks, budget) {
     if (budget < 128)
-        throw new Error('飞书标题或辅助信息过长');
+        throw new Error('飞书标题或底部信息太长，没有剩余空间放正文。');
     const output = [];
     let current = '';
     const size = (text) => Buffer.byteLength(text, 'utf8');

package/dist/prompts.js

@@ -5,7 +5,7 @@ export class Cancelled extends Error {
 }
 export function terminalPrompts() {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
-        throw new ConfigError('配置向导需要交互终端；自动化请使用 setup --template --yes 和环境变量');
+        throw new ConfigError('配置向导需要在交互终端中运行。自动化场景可以改用 setup --template --yes 搭配环境变量。');
     return {
         out: text => console.log(text),
         text: label => readText(label),
@@ -22,7 +22,7 @@ export async function readText(label, input = process.stdin, output = process.st
         return (await terminal.question(label, { signal: controller.signal })).trim();
     }
     catch {
-        throw new Cancelled('已取消');
+        throw new Cancelled('已取消。');
     }
     finally {
         terminal.off('SIGINT', cancel);
@@ -32,7 +32,7 @@ export async function readText(label, input = process.stdin, output = process.st
 }
 export async function readHidden(label, input = process.stdin, output = process.stdout) {
     if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== 'function')
-        throw new ConfigError('当前终端不支持隐藏输入，拒绝回显密钥');
+        throw new ConfigError('当前终端不支持隐藏输入。为了不暴露密钥，这里不会改用明文输入；请在支持的终端中运行，或用环境变量配置。');
     const wasRaw = input.isRaw, wasPaused = input.isPaused();
     return new Promise((resolve, reject) => {
         let value = '';
@@ -58,8 +58,8 @@ export async function readHidden(label, input = process.stdin, output = process.
             value = '';
             error ? reject(error) : resolve(result);
         };
-        const failed = () => finish(new ConfigError('隐藏输入失败，未保存凭据'));
-        const cancelled = () => finish(new Cancelled('已取消'));
+        const failed = () => finish(new ConfigError('隐藏输入没有完成，凭据没有保存。'));
+        const cancelled = () => finish(new Cancelled('已取消。'));
         const keypress = (text, key = {}) => {
             if (key.ctrl && (key.name === 'c' || key.name === 'd'))
                 return cancelled();
@@ -76,7 +76,7 @@ export async function readHidden(label, input = process.stdin, output = process.
             if (key.ctrl || key.meta || !text || /[\x00-\x1f\x7f]/.test(text))
                 return;
             if (value.length + text.length > 8192)
-                return finish(new ConfigError('凭据输入过长，未保存'));
+                return finish(new ConfigError('凭据输入过长，没有保存。'));
             value += text;
         };
         try {