@quecue/dev-notify 0.0.0-stage → 0.1.0-alpha.3

package/dist/claude-code.js

@@ -0,0 +1,236 @@
+import { readFile, mkdir, open, rename, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomBytes } from 'node:crypto';
+import { ConfigError, decodeUtf8 } from './config.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'];
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const yes = (value) => /^(y|yes)$/i.test(value.trim());
+export function claudeSettingsPath(env = process.env, home = homedir(), platform = process.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 设置');
+    return join.join(root, 'settings.json');
+}
+function settingsFile(options) {
+    return claudeSettingsPath(options.env, options.home, options.platform);
+}
+async function snapshot(file) {
+    try {
+        const bytes = await readFile(file);
+        if (bytes.length > 1024 * 1024)
+            throw new ConfigError('Claude Code 设置超过 1 MiB，未修改');
+        return bytes;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        if (error instanceof ConfigError)
+            throw error;
+        throw new ConfigError('无法读取 Claude Code 设置，未修改');
+    }
+}
+function parseSettings(before) {
+    let data;
+    try {
+        data = before === null ? {} : JSON.parse(decodeUtf8(before));
+    }
+    catch {
+        throw new ConfigError('Claude Code 设置不是合法 UTF-8 JSON，未覆盖');
+    }
+    if (!record(data) || (data.hooks !== undefined && !record(data.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 数组结构无效，未覆盖');
+    }
+    return data;
+}
+function owned(hook) {
+    return hook.type === 'command' && hook.statusMessage === HOOK_MARKER && Array.isArray(hook.args)
+        && hook.args.length === 6 && typeof hook.args[0] === 'string'
+        && hook.args[1] === 'integration' && hook.args[2] === 'claude-code' && hook.args[3] === 'hook'
+        && hook.args[4] === '--config' && typeof hook.args[5] === 'string';
+}
+function describe(file, data) {
+    const result = { file, stop: 0, notification: 0, lifecycle: 0, interaction: 0, others: 0, disabled: data.disableAllHooks === true };
+    for (const event of EVENTS)
+        for (const group of data.hooks?.[event] ?? [])
+            for (const hook of group.hooks) {
+                if (owned(hook)) {
+                    if (event === 'Stop')
+                        result.stop++;
+                    else if (event === 'Notification')
+                        result.notification++;
+                    else if (['PreToolUse', 'PermissionRequest', 'PostToolUse', 'PostToolUseFailure', 'PermissionDenied'].includes(event))
+                        result.interaction++;
+                    else
+                        result.lifecycle++;
+                }
+                else
+                    result.others++;
+            }
+    return result;
+}
+export async function claudeCodeStatus(options = {}) {
+    const file = settingsFile(options);
+    return describe(file, parseSettings(await snapshot(file)));
+}
+export async function replyHooksReady(config, options = {}) {
+    const data = parseSettings(await snapshot(settingsFile(options)));
+    if (data.disableAllHooks === true)
+        return false;
+    const normalize = (file) => process.platform === 'win32' ? path.resolve(file).toLowerCase() : path.resolve(file);
+    for (const event of EVENTS) {
+        const groups = data.hooks?.[event] ?? [];
+        const matches = groups.flatMap((group) => group.hooks)
+            .filter((hook) => owned(hook) && normalize(hook.args[5]) === normalize(config));
+        if (matches.length !== 1 || (event !== 'Notification' && matches[0].async === true))
+            return false;
+        if (event !== 'Notification' && groups.some((group) => group.matcher && group.matcher !== '*'
+            && group.hooks.includes(matches[0])))
+            return false;
+    }
+    return true;
+}
+function merged(data, config, runtime) {
+    const target = structuredClone(data);
+    for (const event of EVENTS) {
+        const groups = [];
+        for (const group of target.hooks?.[event] ?? []) {
+            const remaining = group.hooks.filter((hook) => !owned(hook));
+            if (remaining.length === group.hooks.length)
+                groups.push(group);
+            else if (remaining.length)
+                groups.push({ ...group, hooks: remaining });
+        }
+        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 };
+            const matcher = event === 'Notification' ? NOTIFICATION_MATCHER : null;
+            groups.push(matcher ? { matcher, hooks: [handler] } : { hooks: [handler] });
+        }
+        if (groups.length) {
+            target.hooks ??= {};
+            target.hooks[event] = groups;
+        }
+        else if (target.hooks)
+            delete target.hooks[event];
+    }
+    if (target.hooks && !Object.keys(target.hooks).length)
+        delete target.hooks;
+    return target;
+}
+function same(left, right) {
+    return left === null ? right === null : right !== null && left.equals(right);
+}
+async function remove(file) {
+    try {
+        await unlink(file);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+async function commit(file, before, target, prompts, replace = rename) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const lockFile = file + '.dev-notify.lock';
+    let lock;
+    try {
+        lock = await open(lockFile, 'wx', 0o600);
+    }
+    catch {
+        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 设置在确认期间已变化，未覆盖，请重试');
+        const stream = await open(temporary, 'wx', 0o600);
+        created = true;
+        try {
+            await stream.writeFile(JSON.stringify(target, null, 2) + '\n', 'utf8');
+            await stream.sync();
+        }
+        finally {
+            await stream.close();
+        }
+        if (!same(before, await snapshot(file)))
+            throw new ConfigError('Claude Code 设置在保存期间已变化，未覆盖，请重试');
+        await replace(temporary, file);
+    }
+    finally {
+        if (created) {
+            try {
+                await remove(temporary);
+            }
+            catch {
+                prompts.out('临时 Claude Code 设置清理失败，请确认安装结束后清理 .dev-notify-*.tmp');
+            }
+        }
+        try {
+            await remove(lockFile);
+        }
+        catch {
+            prompts.out('Claude Code 设置锁清理失败，请确认安装结束后处理 .dev-notify.lock');
+        }
+    }
+}
+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，未修改。');
+        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}`);
+    if (JSON.stringify(data) === JSON.stringify(target)) {
+        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 (status.others)
+            prompts.out(`保留当前文件中另外 ${status.others} 个相关处理器；可能出现重复通知。`);
+        prompts.out('项目级或插件 hooks 也可能同时生效；不会自动迁移或删除原 Python hooks。');
+        if (status.disabled)
+            prompts.out('注意：该文件设置了 disableAllHooks，安装后仍不会生效；本工具不擅自解除禁用。');
+    }
+    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 设置未修改。');
+        return false;
+    }
+    await commit(file, before, target, prompts, options.replace);
+    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

@@ -0,0 +1,123 @@
+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 { 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);
+    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 输入超过大小限制，未截断发送');
+            chunks.push(bytes);
+        }
+        return Buffer.concat(chunks);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function metadata(value, limit) {
+    if (typeof value !== 'string')
+        return '';
+    const clean = value.replace(/[\x00-\x1f\x7f]/g, ' ');
+    const chars = Array.from(clean);
+    return chars.length > limit ? chars.slice(0, limit).join('') + '…' : clean;
+}
+export function claudeHookMessage(bytes) {
+    if (bytes.byteLength > MAX_HOOK_BYTES)
+        throw new ConfigError('Claude Code hook 输入超过大小限制，未截断发送');
+    let data;
+    try {
+        data = JSON.parse(decodeUtf8(bytes));
+    }
+    catch {
+        throw new ConfigError('Claude Code hook 输入不是合法 UTF-8 JSON，未发送通知');
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        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');
+    if (data.hook_event_name === 'Stop') {
+        if (data.stop_hook_active !== undefined && typeof data.stop_hook_active !== 'boolean')
+            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,
+            content: data.last_assistant_message?.trim() ? data.last_assistant_message
+                : '本轮回复已结束，但 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,
+        content: data.message?.trim() ? data.message : 'Claude Code 正在等待你的确认或输入，请回到终端处理。' };
+}
+export async function dispatchClaudeHook(bytes, configFile, context) {
+    const message = claudeHookMessage(bytes);
+    const data = JSON.parse(decodeUtf8(bytes));
+    const options = { send: context.send, ...context.reply, env: context.env, err: context.err, response: context.response };
+    try {
+        await lifecycleHook(data, configFile, options);
+        await interactionHook(data, configFile, options);
+    }
+    catch {
+        context.err('Claude Code 回复状态或交互处理失败；未自动选择答案/批准权限，请在本机处理。');
+    }
+    if (!message)
+        return;
+    let binding = null;
+    try {
+        binding = await attachReply(message, data, configFile, options);
+    }
+    catch {
+        context.err('远程回复未就绪；仍尝试发送普通通知。');
+    }
+    const config = await loadConfig(configFile, true, context.env);
+    let covered = { telegram: [], feishu: false };
+    try {
+        covered = await notificationCoverage(data, configFile, config, options);
+    }
+    catch {
+        context.err('无法核验选择题通知覆盖情况；保留普通权限提醒。');
+    }
+    let channels = 0;
+    for (const channel of ['telegram', 'feishu']) {
+        if (!ready(config, channel))
+            continue;
+        channels++;
+        try {
+            if (channel === 'feishu' && covered.feishu)
+                continue;
+            const plan = makePlan(channel, message, 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;
+                if (!plan.items.length)
+                    continue;
+            }
+            if (binding)
+                mapReplies(plan, binding);
+            const result = await context.send(plan, config);
+            if (!result.ok)
+                context.err(`${channel}: Claude Code 通知未完整发送；不自动重发整条消息。`);
+        }
+        catch {
+            context.err(`${channel}: Claude Code 通知发送失败；请检查配置、系统凭据及网络，不自动重发整条消息。`);
+        }
+    }
+    if (!channels)
+        throw new ConfigError('Claude Code 通知没有可用渠道，请运行 dev-notify doctor 检查');
+}

package/dist/cli.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { appPaths, ConfigError, createConfig, decodeUtf8, loadConfig, ready } from './config.js';
+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 { 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 — 跨平台开发任务通知
+
+命令：
+  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           离线检查，不发消息
+  integration list          列出可用集成
+  integration claude-code install / status / remove
+                            单独安装、查询或移除用户级 hooks
+  reply setup               另行授权可信 Telegram 私聊用户
+  reply start / status / stop
+                            启动、查询或停止回复桥接
+  reply disable             确认后撤销远程回复授权并请求停止桥接
+  reply run                 前台运行桥接（排错用，不启用系统自启动）
+
+全局选项：--config 路径、--help、--version
+系统凭据使用 Windows Credential Manager / macOS Keychain；不调用 Python，不写入明文密钥。`;
+const defaults = {
+    env: process.env,
+    out: text => console.log(text),
+    err: text => console.error(text),
+    stdin: async () => { const chunks = []; for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk)); return Buffer.concat(chunks); },
+    hookStdin: () => readHookInput(),
+    confirm: async () => {
+        if (!process.stdin.isTTY)
+            throw new ConfigError('非交互环境请使用 setup --template --yes');
+        return /^(y|yes)$/i.test(await readText('确认创建模板？[y/N] '));
+    },
+    send: deliver,
+};
+export async function main(argv = process.argv.slice(2), overrides = {}) {
+    const context = { ...defaults, ...overrides };
+    const isHook = argv[0] === 'integration' && argv[1] === 'claude-code' && argv[2] === 'hook';
+    try {
+        let parsed;
+        try {
+            parsed = parseArgs({ args: argv, allowPositionals: true, strict: true, options: {
+                    help: { type: 'boolean', short: 'h' }, version: { type: 'boolean' }, config: { type: 'string' },
+                    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' },
+                } });
+        }
+        catch {
+            throw new ConfigError('参数无效，请使用 --help；不回显可能含秘密的参数');
+        }
+        const { values, positionals } = parsed;
+        if (values.help) {
+            context.out(HELP);
+            return 0;
+        }
+        if (values.version) {
+            context.out('dev-notify 0.1.0-alpha.3');
+            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: [],
+        };
+        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');
+        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 === 'integration') {
+            if (action === 'list' && !integrationAction) {
+                context.out('claude-code: 可选通知集成、Telegram 回复与结构化问题交互；通知 hooks 与 reply setup 输入授权分开，默认不开启远程输入。');
+                return 0;
+            }
+            if (action !== 'claude-code' || !['install', 'status', 'remove', 'hook'].includes(integrationAction))
+                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;
+            }
+            if (integrationAction === 'status') {
+                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 中确认。');
+                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');
+            }
+            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');
+            if (action === 'setup') {
+                const saved = await configureReplies(file, context.prompts ?? terminalPrompts(), context.env);
+                if (saved)
+                    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 ? '桥接已停止或未运行。' : '已撤销授权并请求停止；正在进行中的调用不能撤回。');
+                return 0;
+            }
+            if (action === 'stop') {
+                const stopped = await stopBridge(file);
+                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 ? '桥接：进程存在但未就绪。' : '桥接：未运行。');
+                if (status.error)
+                    context.err(status.error);
+                return access && status.ready ? 0 : 1;
+            }
+            if (action === 'run') {
+                await runBridge(file, { env: context.env, log: context.err });
+                return 0;
+            }
+            const ready = await startBridge(file, context.env);
+            context.out(ready ? '回复桥接已就绪；请从新任务通知进入。' : '桥接尚未就绪；请用 reply status / reply run 查看安全错误，不要同时运行旧 Python 桥接。');
+            return ready ? 0 : 1;
+        }
+        if (command === 'credentials') {
+            if (action !== '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 同时使用，不能跳过密钥保存确认');
+                const prompts = context.prompts ?? terminalPrompts();
+                const saved = await wizard(file, {
+                    prompts, store: context.store, env: context.env,
+                    testSend: async (config) => {
+                        let count = 0, ok = true;
+                        for (const channel of ['telegram', 'feishu']) {
+                            if (!ready(config, channel))
+                                continue;
+                            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}`);
+                            ok = ok && result.ok;
+                        }
+                        return count > 0 && ok;
+                    },
+                });
+                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;
+            }
+            context.out(`将创建无密钥模板: ${file}；不会联网或修改 hooks`);
+            if (!values.yes && !await context.confirm()) {
+                context.out('已取消，未写入');
+                return 130;
+            }
+            await createConfig(file);
+            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；检查不联网，系统可能要求授权');
+            return ready(config, 'telegram') || ready(config, 'feishu') ? 0 : 1;
+        }
+        if (!values.title?.trim())
+            throw new ConfigError('send 必须指定非空 --title');
+        if ([values.content !== undefined, values['content-file'] !== undefined, !!values.stdin].filter(Boolean).length > 1)
+            throw new ConfigError('正文来源只能指定一个');
+        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('渠道或通知级别无效');
+        let content = values.content ?? values.title;
+        if (values['content-file'] !== undefined)
+            content = decodeUtf8(await readFile(values['content-file']));
+        if (values.stdin)
+            content = decodeUtf8(await context.stdin());
+        const message = { title: values.title, content, footer: values.footer ?? '', level: level };
+        const selected = channel === 'all' ? ['telegram', 'feishu'] : [channel];
+        let failed = false, planned = 0;
+        for (const name of selected) {
+            if (!ready(config, name)) {
+                if (channel !== 'all')
+                    throw new ConfigError('指定渠道未启用或配置不完整');
+                continue;
+            }
+            planned++;
+            let plan;
+            try {
+                plan = makePlan(name, message, config);
+            }
+            catch {
+                context.err(`${name}: 无法生成安全分段，请缩短标题/辅助信息或检查正文格式`);
+                failed = true;
+                continue;
+            }
+            if (values['dry-run']) {
+                context.out(`${name}: 接收目标 ${plan.recipients}，预计请求 ${plan.items.length}；未发送`);
+                continue;
+            }
+            const result = await context.send(plan, config);
+            context.out(`${name}: 已发送 ${result.sent}/${result.planned}`);
+            if (!result.ok) {
+                failed = true;
+                context.err(result.error ?? '投递失败');
+            }
+        }
+        if (!planned)
+            throw new ConfigError('没有可发送的渠道，请配置环境凭据和接收人');
+        return failed ? 1 : 0;
+    }
+    catch (error) {
+        if (error instanceof Cancelled) {
+            context.out('已取消，未继续执行。');
+            return isHook ? 0 : 130;
+        }
+        context.err(error instanceof ConfigError || error instanceof CredentialError ? error.message : '操作失败，请检查文件、权限或输入；不输出可能含秘密的底层异常');
+        // Stop hook 的退出码 2 会要求 Claude 继续；通知失败只能报告，不能阻塞或触发重试循环。
+        return isHook ? 0 : 2;
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    process.exitCode = await main();
+}