@quecue/dev-notify 0.1.0-alpha.1 → 0.1.0

package/dist/reply-bridge.js

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { mkdir, open, unlink, realpath } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { appPaths, ConfigError } from './config.js';
+import { accessReplies, atomicJson, readJson, replyDirectory, stateTransaction } from './reply-state.js';
+import { telegramApi } from './reply-telegram.js';
+import { drainReplies, processUpdate } from './reply-engine.js';
+import { drainInteractionFeedback } from './reply-outcomes.js';
+const leasePath = (file) => path.join(replyDirectory(file), 'bridge.json');
+const controlPath = (file) => path.join(replyDirectory(file), 'stop.json');
+function alive(pid) {
+    if (!Number.isSafeInteger(pid) || Number(pid) <= 0)
+        return false;
+    try {
+        process.kill(Number(pid), 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function bridgeStatus(file) {
+    const lease = await readJson(leasePath(file));
+    const running = !!lease && alive(lease.pid) && Date.now() - lease.updated < 30000;
+    return { running, ready: !!lease?.ready && running, error: lease?.error };
+}
+export async function stopBridge(file) {
+    const lease = await readJson(leasePath(file));
+    if (!lease || !alive(lease.pid))
+        return true;
+    // 不按可复用 PID 杀进程；只有持有本次 owner 的桥接响应此控制文件。
+    await atomicJson(controlPath(file), { owner: lease.owner });
+    for (let attempt = 0; attempt < 16; attempt++) {
+        await delay(250);
+        const current = await readJson(leasePath(file));
+        if (!current || current.owner !== lease.owner || !alive(current.pid))
+            return true;
+    }
+    return false;
+}
+export async function startBridge(file, env = process.env) {
+    const access = await accessReplies(file, env);
+    if (!access)
+        throw new ConfigError('远程回复尚未授权，请先运行 reply setup。');
+    const existing = await bridgeStatus(file);
+    if (existing.running)
+        return existing.ready;
+    const node = await realpath(process.execPath), cli = await realpath(fileURLToPath(new URL('./cli.js', import.meta.url)));
+    // 无 shell、无命令行秘密、无系统开机自启；worker 自己持有排他锁。
+    const child = spawn(node, [cli, 'reply', 'run', '--config', path.resolve(file)], {
+        detached: true, windowsHide: true, shell: false, stdio: 'ignore', env: { ...process.env, ...env },
+    });
+    let failed = false;
+    child.once('error', () => { failed = true; });
+    child.unref();
+    for (let attempt = 0; attempt < 20; attempt++) {
+        await delay(150);
+        if (failed)
+            return false;
+        const status = await bridgeStatus(file);
+        if (status.ready)
+            return true;
+        if (status.error)
+            return false;
+    }
+    return false;
+}
+export async function runBridge(file, options = {}) {
+    const env = options.env ?? process.env;
+    let access = await accessReplies(file, env);
+    if (!access)
+        throw new ConfigError('远程回复尚未授权。');
+    const directory = replyDirectory(file);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const botDirectory = path.join(appPaths(process.platform, env).data, 'reply-bots');
+    await mkdir(botDirectory, { recursive: true, mode: 0o700 });
+    const lockPath = path.join(botDirectory, access.policy.bot + '.lock');
+    let lock;
+    try {
+        lock = await open(lockPath, 'wx', 0o600);
+    }
+    catch {
+        throw new ConfigError('当前用户已经有同一个 Bot 的桥接在运行，或残留了锁文件。请确认进程退出后，再处理 reply-bots 中对应的锁。');
+    }
+    const owner = randomBytes(16).toString('hex'), lease = { pid: process.pid, owner, ready: false, updated: Date.now() };
+    let stopping = false;
+    const stop = () => { stopping = true; };
+    process.on('SIGTERM', stop);
+    process.on('SIGINT', stop);
+    const fresh = async () => await isStopped() ? null : accessReplies(file, env);
+    const log = options.log ?? (() => { });
+    let lastActivity = Date.now();
+    const isStopped = async () => stopping || options.stopped?.() === true || (await readJson(controlPath(file)))?.owner === owner;
+    try {
+        await lock.writeFile(JSON.stringify({ pid: process.pid, owner }));
+        await atomicJson(leasePath(file), lease);
+        let api = (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
+        const webhook = await api('getWebhookInfo', {});
+        if (webhook?.url)
+            throw new ConfigError('这个 Bot 已经设置了 webhook，不能同时使用 getUpdates。请先移除 webhook；本工具不会自动删除。');
+        await api('getMe', {});
+        const currentState = await stateTransaction(access, state => ({ offset: state.offset, empty: Object.keys(state.entries).length === 0 }));
+        if (!currentState.offset && currentState.empty) {
+            const old = await api('getUpdates', { offset: -1, timeout: 0, allowed_updates: ['message', 'callback_query'] });
+            if (Array.isArray(old) && old.length)
+                await stateTransaction(access, state => {
+                    const id = old[old.length - 1]?.update_id;
+                    if (Number.isSafeInteger(id))
+                        state.offset = Math.max(state.offset, id + 1);
+                });
+        }
+        lease.ready = true;
+        lease.updated = Date.now();
+        await atomicJson(leasePath(file), lease);
+        let iteration = 0, failures = 0;
+        while (!await isStopped() && iteration++ < (options.maxIterations ?? Infinity)) {
+            const current = await fresh();
+            if (!current)
+                break;
+            if (current.identity !== access.identity) {
+                // 修改授权或 Bot 必须重启并重新核验，丢弃旧长轮询结果。
+                break;
+            }
+            access = current;
+            api = (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
+            const context = { api, fresh, validate: options.validate, inject: options.inject };
+            await drainReplies(access, context);
+            await drainInteractionFeedback(access, api, fresh, log);
+            if (await isStopped())
+                break;
+            const offset = await stateTransaction(access, state => state.offset);
+            let updates;
+            try {
+                updates = await api('getUpdates', { offset, timeout: 2, allowed_updates: ['message', 'callback_query'] });
+            }
+            catch (error) {
+                if (error instanceof ConfigError && /冲突/.test(error.message))
+                    throw error;
+                log('Telegram 轮询失败；日志中没有记录密钥或服务端正文。');
+                if (++failures >= 5)
+                    throw new ConfigError('Telegram 连续轮询失败 5 次，桥接已经退出。请检查网络、Token 或 API 冲突后重新启动。');
+                lease.updated = Date.now();
+                await atomicJson(leasePath(file), lease);
+                await (options.sleep ?? delay)(3000);
+                continue;
+            }
+            failures = 0;
+            const after = await fresh();
+            if (!after || after.identity !== access.identity || await isStopped())
+                break;
+            if (!Array.isArray(updates))
+                throw new ConfigError('Telegram 更新格式无效。');
+            for (const update of updates) {
+                if (await isStopped())
+                    break;
+                try {
+                    await processUpdate(access, update, context);
+                }
+                catch {
+                    log('回复处理失败。这条更新不会重放；请检查终端，或从最新通知重试。');
+                }
+            }
+            if (updates.length)
+                lastActivity = Date.now();
+            lease.updated = Date.now();
+            await atomicJson(leasePath(file), lease);
+            if (Date.now() - lastActivity > 24 * 60 * 60 * 1000)
+                break;
+        }
+    }
+    catch (error) {
+        lease.ready = false;
+        lease.error = error instanceof ConfigError ? error.message : '桥接启动或运行失败；为避免泄露密钥，没有显示底层错误。';
+        await atomicJson(leasePath(file), lease).catch(() => { });
+        throw error;
+    }
+    finally {
+        process.off('SIGTERM', stop);
+        process.off('SIGINT', stop);
+        const current = await readJson(leasePath(file)).catch(() => null);
+        if (current?.owner === owner && !lease.error)
+            await unlink(leasePath(file)).catch(() => { });
+        await lock.close();
+        await unlink(lockPath);
+    }
+}

package/dist/reply-engine.js

@@ -0,0 +1,205 @@
+import { randomBytes } from 'node:crypto';
+import { ConfigError } from './config.js';
+import { digest, targetEpoch, stateTransaction, TTL } from './reply-state.js';
+import { handleInteractionCallback, handleInteractionText, showInteraction } from './reply-interactions.js';
+import { injectReply, sanitizeReply, validateTarget } from './reply-platform.js';
+import { replyHint } from './reply-telegram.js';
+export const sessionEpoch = targetEpoch;
+export const textHash = (text) => digest(text.replace(/\s+/g, ' ').trim());
+function privateUser(message, sender) {
+    const chat = message?.chat;
+    if (chat?.type !== 'private' || !Number.isSafeInteger(chat.id) || chat.id <= 0
+        || !Number.isSafeInteger(sender?.id) || sender.id !== chat.id || sender.is_bot === true)
+        return null;
+    return String(chat.id);
+}
+export async function resolveEntry(access, key, context) {
+    const resolved = await stateTransaction(access, state => {
+        const entry = state.entries[key], target = entry && state.sessions[entry.session];
+        return entry && target && (target.tracked === true || !!entry.request) && entry.epoch === sessionEpoch(target) && Date.now() - entry.updated < TTL ? { entry, target } : null;
+    });
+    if (!resolved || !await (context.validate ?? (target => validateTarget(target)))(resolved.target))
+        return null;
+    return resolved;
+}
+// autoReply：Telegram 内联按钮沿用 force_reply，点击后自动进入回复状态。
+// 飞书跳转使用普通提示 + remove_keyboard：清除客户端缓存的旧强制回复目标，但不拉起新的回复框。
+async function prompt(access, chat, messageId, key, context, autoReply = true) {
+    const resolved = await resolveEntry(access, key, context);
+    if (!resolved) {
+        await replyHint(context.api, chat, '⚠️ 无法回复', '这个会话已经关闭、切换，或这条通知已过期。请从最新通知进入。', messageId);
+        return;
+    }
+    if (resolved.entry.request) {
+        await showInteraction(access, resolved.entry.request, chat, context.api);
+        return;
+    }
+    const session = resolved.target.title || resolved.target.session;
+    const sent = autoReply
+        ? await replyHint(context.api, chat, '💬 回复 Claude', '请回复此消息输入内容。该输入将提交到对应本机会话。\n会话：' + session, messageId, { force_reply: true, selective: true })
+        : await replyHint(context.api, chat, '💬 回复 Claude', '请长按这条消息并选择「回复」，然后输入内容。该输入将提交到对应本机会话。\n会话：' + session, messageId, { remove_keyboard: true });
+    if (Number.isSafeInteger(sent?.message_id))
+        await stateTransaction(access, state => { state.entries[`tg:${chat}:${sent.message_id}`] = resolved.entry; });
+}
+export async function processUpdate(access, update, context) {
+    try {
+        await processAuthorizedUpdate(access, update, context);
+    }
+    catch (error) {
+        const message = update?.callback_query?.message ?? update?.message;
+        const sender = update?.callback_query?.from ?? update?.message?.from;
+        const chat = privateUser(message, sender);
+        const current = await context.fresh().catch(() => null);
+        if (chat && current?.identity === access.identity && current.policy.users.includes(chat)) {
+            if (typeof update?.callback_query?.id === 'string')
+                await context.api('answerCallbackQuery', {
+                    callback_query_id: update.callback_query.id, text: '处理没有完成，请检查终端；不会自动重复提交。',
+                }).catch(() => { });
+            await replyHint(context.api, chat, '⚠️ 本次提交没有完成', '处理时出现了异常，这次提交可能已经登记，也可能没有生效。请检查终端和后续结果；不会自动重复提交。').catch(() => { });
+        }
+        throw error;
+    }
+}
+async function processAuthorizedUpdate(access, update, context) {
+    if (!Number.isSafeInteger(update?.update_id) || update.update_id < 0)
+        return;
+    const current = await context.fresh();
+    if (!current || current.identity !== access.identity)
+        return;
+    // 先提交 offset；强杀可能丢失本条，但不能重放已授权的终端输入。
+    const claimed = await stateTransaction(access, state => {
+        if (update.update_id < state.offset)
+            return false;
+        state.offset = update.update_id + 1;
+        return true;
+    });
+    if (!claimed)
+        return;
+    if (update.callback_query) {
+        const callback = update.callback_query, chat = privateUser(callback.message, callback.from);
+        if (!chat || !current.policy.users.includes(chat))
+            return;
+        const value = callback.data;
+        if (typeof value === 'string' && value.startsWith('dn:q:')) {
+            const id = value.split(':')[2];
+            if (!/^[a-f0-9]{32}$/.test(id) || !await resolveEntry(access, 'token:' + id, context)) {
+                await context.api('answerCallbackQuery', { callback_query_id: callback.id, text: '会话已关闭，或这次交互已经失效。' }).catch(() => { });
+                await replyHint(context.api, chat, '⚠️ 这次提交没有生效', '会话已经关闭、切换，或交互已经失效，答案没有回传。').catch(() => { });
+                return;
+            }
+            if (await handleInteractionCallback(access, callback, chat, context.api))
+                return;
+        }
+        if (typeof value !== 'string' || !/^dn:r:[a-f0-9]{32}$/.test(value) || typeof callback.id !== 'string')
+            return;
+        await context.api('answerCallbackQuery', { callback_query_id: callback.id, text: '请在回复框输入内容' });
+        await prompt(access, chat, callback.message.message_id, 'token:' + value.slice(5), context);
+        return;
+    }
+    const message = update.message, chat = privateUser(message, message?.from);
+    if (!chat || typeof message.text !== 'string' || !Number.isSafeInteger(message.message_id))
+        return;
+    const text = message.text.trim();
+    if (text === '/chatid') {
+        await replyHint(context.api, chat, 'Telegram chat_id', chat, message.message_id);
+        return;
+    }
+    if (!current.policy.users.includes(chat))
+        return;
+    if (typeof message.date === 'number' && Date.now() / 1000 - message.date > 300) {
+        await replyHint(context.api, chat, '⚠️ 本次提交没有生效', '这条消息已经超过有效时间，答案没有回传。请查看最新问题或终端状态。');
+        return;
+    }
+    if (/^\/start\s+[a-f0-9]{32}$/.test(text)) {
+        // 飞书跳转：只发普通提示并清除旧键盘状态，不自动进入回复。
+        await prompt(access, chat, message.message_id, 'token:' + text.split(/\s+/)[1], context, false);
+        return;
+    }
+    const replyTo = message.reply_to_message?.message_id;
+    if (!Number.isSafeInteger(replyTo)) {
+        await replyHint(context.api, chat, '💬 回复方式', '请直接回复任务完成通知，或点击通知里的「回复 Claude」按钮。', message.message_id);
+        return;
+    }
+    const resolved = await resolveEntry(access, `tg:${chat}:${replyTo}`, context);
+    if (!resolved) {
+        await replyHint(context.api, chat, '⚠️ 无法回复', '通知已过期，或对应会话已经关闭、切换。请从最新通知回复。', message.message_id);
+        return;
+    }
+    if (resolved.entry.request) {
+        await handleInteractionText(access, resolved.entry.request, chat, message, context.api);
+        return;
+    }
+    let safe;
+    try {
+        safe = sanitizeReply(message.text);
+    }
+    catch (error) {
+        await replyHint(context.api, chat, '❌ 回复没有提交', error instanceof ConfigError ? error.message : '输入无效。', message.message_id);
+        return;
+    }
+    const id = randomBytes(16).toString('hex');
+    const queued = await stateTransaction(access, state => {
+        const target = state.sessions[resolved.target.session];
+        if (!target || sessionEpoch(target) !== resolved.entry.epoch)
+            throw new ConfigError('会话已经变化，这次回复没有提交。');
+        if (state.pending[target.session] && Date.now() - state.pending[target.session].updated < 5 * 60 * 1000)
+            return null;
+        state.pending[target.session] = { hash: textHash(safe), text: safe, epoch: resolved.entry.epoch, id, updated: Date.now(), queued: target.working,
+            phase: 'queued', chat, message: message.message_id };
+        return target.working;
+    });
+    if (queued === null) {
+        await replyHint(context.api, chat, '⏳ 新回复没有提交', '这个会话已有一条待确认的回复。请先等待确认，或检查本机终端后再试。', message.message_id);
+        return;
+    }
+    if (queued)
+        await replyHint(context.api, chat, '⏳ 回复已排队', 'Claude 正在处理当前任务；本地队列将在本轮结束后尝试提交，不会把文本输入到正在等待权限的弹窗。', message.message_id);
+    else
+        await drainReplies(access, context);
+}
+export async function drainReplies(access, context) {
+    const queued = await stateTransaction(access, state => Object.entries(state.pending)
+        .filter(([session, value]) => value.phase === 'queued' && (!state.sessions[session]?.working || Date.now() - value.updated > 5 * 60 * 1000))
+        .map(([session, pending]) => ({ target: state.sessions[session], pending })));
+    for (const item of queued) {
+        const { target, pending } = item;
+        if (!target || !pending.text)
+            continue;
+        try {
+            const current = await context.fresh();
+            if (!current || current.identity !== access.identity || !current.policy.users.includes(pending.chat))
+                return;
+            if (Date.now() - pending.updated > 5 * 60 * 1000)
+                throw new ConfigError('排队的回复已超过 5 分钟，没有提交。请检查本机后重新回复。');
+            if (!target.tracked || pending.epoch !== sessionEpoch(target) || !await (context.validate ?? (value => validateTarget(value)))(target))
+                throw new ConfigError('会话已经关闭或切换，这次回复没有提交。');
+            const text = pending.text;
+            const claimed = await stateTransaction(access, state => {
+                const actual = state.pending[target.session], active = state.sessions[target.session];
+                if (!actual || actual.id !== pending.id || actual.phase !== 'queued' || active?.working || sessionEpoch(active) !== sessionEpoch(target))
+                    return false;
+                actual.phase = 'submitted';
+                delete actual.text;
+                return true;
+            });
+            if (!claimed)
+                continue;
+            // 输入前再次核验授权，撤销后不发送。原生调用一旦开始，不能撤回或保证无竞态。
+            const final = await context.fresh();
+            if (!final || final.identity !== access.identity)
+                return;
+            await (context.inject ?? ((value, content) => injectReply(value, content)))(target, text);
+            await replyHint(context.api, pending.chat, '✅ 已转发给 Claude', '终端输入已提交，正在等待 UserPromptSubmit 确认。', pending.message);
+        }
+        catch (error) {
+            await stateTransaction(access, state => {
+                const value = state.pending[target.session];
+                if (value?.id === pending.id) {
+                    value.phase = 'unknown';
+                    delete value.text;
+                }
+            });
+            await replyHint(context.api, pending.chat, '⚠️ 转发状态待确认', error instanceof ConfigError ? error.message : '提交没有完成，请检查本机终端；不会自动重复提交。', pending.message).catch(() => { });
+        }
+    }
+}

package/dist/reply-hooks.js

@@ -0,0 +1,230 @@
+import { randomBytes } from 'node:crypto';
+import { ConfigError } from './config.js';
+import { accessReplies, botKey, digest, stateTransaction, targetEpoch } from './reply-state.js';
+import { findSession } from './reply-platform.js';
+import { textHash } from './reply-engine.js';
+import { telegramApi, replyHint } from './reply-telegram.js';
+import { bridgeStatus, startBridge } from './reply-bridge.js';
+import { createInteraction, questionsContent, showInteraction, waitInteraction } from './reply-interactions.js';
+import { makePlan, deliver } from './channels.js';
+import { completeToolCall, endSessionInteractions, finishInteraction, matchingCall, registerToolCall } from './reply-outcomes.js';
+const apiFor = (access, options) => (options.api ?? (value => telegramApi(value.config.telegram.token)))(access);
+async function getTarget(data, options) {
+    return (options.session ?? (id => findSession(id, { env: options.env })))(data.session_id);
+}
+export async function lifecycleHook(data, file, options = {}) {
+    const event = data.hook_event_name;
+    if (!['SessionStart', 'UserPromptSubmit', 'SessionEnd', 'Stop', 'Notification'].includes(event) || typeof data.session_id !== 'string')
+        return;
+    const access = await accessReplies(file, options.env);
+    if (!access)
+        return;
+    if (event === 'Stop' && data.stop_hook_active === true)
+        return;
+    const target = event === 'SessionEnd' ? null : await getTarget(data, options);
+    const receipt = await stateTransaction(access, state => {
+        const previous = state.sessions[data.session_id];
+        if (event === 'SessionEnd' || !target) {
+            delete state.sessions[data.session_id];
+            delete state.pending[data.session_id];
+            endSessionInteractions(state, data.session_id, '会话已经结束，或无法核验身份');
+            return null;
+        }
+        // 同进程 / 同 TTY 已切换会话时，旧映射不再允许输入。
+        for (const [id, other] of Object.entries(state.sessions)) {
+            if (id !== target.session && (other.pid === target.pid || (target.tty && other.tty === target.tty))) {
+                endSessionInteractions(state, id, '会话已经切换');
+                delete state.sessions[id];
+                delete state.pending[id];
+            }
+        }
+        const pending = state.pending[target.session];
+        const match = event === 'UserPromptSubmit' && typeof data.prompt === 'string' && pending?.phase === 'submitted'
+            && pending.epoch === targetEpoch(target) && pending.hash === textHash(data.prompt) && Date.now() - pending.updated < 5 * 60 * 1000;
+        if (match || (pending && pending.epoch !== targetEpoch(target)))
+            delete state.pending[target.session];
+        const working = event !== 'Stop';
+        const tracked = event === 'UserPromptSubmit' || (event !== 'SessionStart' && previous?.tracked === true && targetEpoch(previous) === targetEpoch(target));
+        const latestCall = event !== 'SessionStart' && event !== 'UserPromptSubmit' && previous && targetEpoch(previous) === targetEpoch(target)
+            ? previous.latestCall : undefined;
+        state.sessions[target.session] = { ...target, working, tracked, latestCall, updated: Date.now() };
+        // 本地用户提交新任务时，尚未注入的排队回复不能抢在该任务前输入。
+        if (event === 'UserPromptSubmit' && !match && pending?.phase === 'queued')
+            delete state.pending[target.session];
+        if (event === 'UserPromptSubmit' || event === 'SessionStart' || event === 'Stop') {
+            endSessionInteractions(state, target.session, event === 'Stop' ? '本轮已结束' : '本机已开始新任务或新会话');
+        }
+        return match ? pending : null;
+    });
+    if (receipt) {
+        await replyHint(apiFor(access, options), receipt.chat, '✅ Claude 已收到回复', 'Claude 已收到你提交的回复，任务完成后会再发通知。', receipt.message).catch(() => options.err?.('Telegram：收到确认没有发送成功；已提交的输入不会重放。'));
+        if (access.config.feishu.enabled && access.config.feishu.webhook) {
+            try {
+                const result = await (options.send ?? deliver)(makePlan('feishu', { title: 'Claude 已收到回复', level: 'info',
+                    content: 'Claude 已收到你提交的回复，任务完成后会再发通知。为减少扩散，这里不转发回复原文。',
+                    footer: '会话：' + data.session_id }, access.config), access.config);
+                if (!result.ok)
+                    options.err?.('飞书：收到确认没有完整发送；已提交的输入不会重放。');
+            }
+            catch {
+                options.err?.('飞书：收到确认发送失败；已提交的输入不会重放。');
+            }
+        }
+    }
+}
+const feishuTarget = (config) => digest(JSON.stringify([config.feishu.webhook, config.feishu.secret]));
+export async function notificationCoverage(data, file, config, options = {}) {
+    const none = { telegram: [], feishu: false };
+    if (data.hook_event_name !== 'Notification' || data.notification_type !== 'permission_prompt' || typeof data.session_id !== 'string')
+        return none;
+    const access = await accessReplies(file, options.env);
+    if (!access || botKey(config) !== access.policy.bot)
+        return none;
+    return stateTransaction(access, state => {
+        const target = state.sessions[data.session_id];
+        const call = target?.latestCall && state.calls[target.latestCall];
+        if (!target || !call || call.session !== target.session || call.epoch !== targetEpoch(target) || call.tool !== 'AskUserQuestion'
+            || typeof data.tool_use_id === 'string' && data.tool_use_id !== call.id
+            || typeof data.tool_name === 'string' && data.tool_name !== call.tool
+            || typeof data.prompt_id === 'string' && data.prompt_id !== call.prompt)
+            return none;
+        const request = call.request && state.requests[call.request];
+        if (!request || request.kind !== 'question' || request.session !== target.session || request.epoch !== call.epoch || request.expires <= Date.now())
+            return none;
+        // Notification 通常没有调用 ID；仅覆盖当前最后一项调用，存在其他并行调用时保守保留提醒。
+        if (Object.entries(state.calls).some(([key, other]) => key !== target.latestCall && other.session === target.session && other.epoch === call.epoch && !other.ended))
+            return none;
+        return { telegram: (request.notified?.telegram ?? []).filter(user => access.policy.users.includes(user)),
+            feishu: request.notified?.feishu === feishuTarget(config) };
+    });
+}
+export async function attachReply(message, data, file, options = {}) {
+    const access = await accessReplies(file, options.env);
+    if (!access || data.hook_event_name !== 'Stop')
+        return null;
+    const target = await getTarget(data, options);
+    if (!target)
+        return null;
+    const saved = await stateTransaction(access, state => state.sessions[target.session]);
+    if (!saved || saved.working || !saved.tracked || targetEpoch(saved) !== targetEpoch(target))
+        return null;
+    const ready = options.bridge ? await options.bridge(file, options.env ?? process.env)
+        : (await bridgeStatus(file)).ready || await startBridge(file, options.env);
+    if (!ready) {
+        options.err?.('回复桥接还没有就绪，这条通知不会显示回复按钮。可运行 reply status 查看原因。');
+        return null;
+    }
+    const api = apiFor(access, options), bot = await api('getMe', {});
+    if (typeof bot?.username !== 'string' || !/^[A-Za-z0-9_]{5,64}$/.test(bot.username))
+        throw new ConfigError('Telegram Bot 用户名无效，回复按钮没有启用。');
+    const token = randomBytes(16).toString('hex');
+    await stateTransaction(access, state => { state.entries['token:' + token] = { session: target.session, epoch: targetEpoch(target), updated: Date.now() }; });
+    message.reply = { token, url: `https://t.me/${bot.username}?start=${token}`, users: access.policy.users };
+    return { access, token };
+}
+export function mapReplies(plan, binding) {
+    if (plan.channel !== 'telegram')
+        return;
+    plan.onSent = async (item, response) => {
+        if (!binding.access.policy.users.includes(item.recipient))
+            return;
+        if (!Number.isSafeInteger(response.result?.message_id))
+            throw new ConfigError('通知没有返回可关联的 Telegram 消息 ID。');
+        await stateTransaction(binding.access, state => {
+            const entry = state.entries['token:' + binding.token];
+            if (entry)
+                state.entries[`tg:${item.recipient}:${response.result.message_id}`] = entry;
+        });
+    };
+}
+export async function interactionHook(data, file, options = {}) {
+    if (!['PreToolUse', 'PermissionRequest', 'PostToolUse', 'PostToolUseFailure', 'PermissionDenied'].includes(data.hook_event_name))
+        return;
+    const access = await accessReplies(file, options.env);
+    if (!access)
+        return;
+    if (['PostToolUse', 'PostToolUseFailure', 'PermissionDenied'].includes(data.hook_event_name)) {
+        await completeToolCall(access, data);
+        return;
+    }
+    if (!['PreToolUse', 'PermissionRequest'].includes(data.hook_event_name))
+        return;
+    const kind = data.tool_name === 'AskUserQuestion' ? 'question' : access.policy.permissions === true ? 'permission' : null;
+    if (typeof data.session_id !== 'string' || data.hook_event_name === 'PermissionRequest' && !kind)
+        return;
+    const cached = data.hook_event_name === 'PreToolUse'
+        ? await stateTransaction(access, state => state.sessions[data.session_id]) : null;
+    // 登记阶段复用生命周期元数据；真正开启远程交互时仍重新核验进程身份。
+    const target = cached ?? await getTarget(data, options);
+    if (!target) {
+        options.err?.('没有核验到会话，结构化交互将在本机处理。');
+        return;
+    }
+    if (data.hook_event_name === 'PreToolUse') {
+        // 只登记调用身份，不发网络请求、不等待远端，原生窗口可以正常出现。
+        await registerToolCall(access, target, data);
+        return;
+    }
+    if (!kind)
+        return;
+    const call = await stateTransaction(access, state => matchingCall(state, target, data));
+    if (!call) {
+        options.err?.('没有唯一匹配到这次工具调用，远程交互没有启用；本机窗口不受影响。');
+        return;
+    }
+    const ready = options.bridge ? await options.bridge(file, options.env ?? process.env)
+        : (await bridgeStatus(file)).ready || await startBridge(file, options.env);
+    if (!ready) {
+        options.err?.('回复桥接还没有就绪，问题将在本机处理。');
+        return;
+    }
+    const api = apiFor(access, options);
+    const request = await createInteraction(access, target, kind, kind === 'question' ? data.tool_input : { tool_name: data.tool_name, tool_input: data.tool_input }, call);
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.on('SIGTERM', cancel);
+    process.on('SIGINT', cancel);
+    try {
+        for (const chat of access.policy.users)
+            await showInteraction(access, request.id, chat, api);
+        if (access.config.feishu.enabled && access.config.feishu.webhook) {
+            const bot = await api('getMe', {});
+            if (typeof bot?.username === 'string' && /^[A-Za-z0-9_]{5,64}$/.test(bot.username)) {
+                const result = await (options.send ?? deliver)(makePlan('feishu', { title: 'Claude Code 需要你处理', level: 'warn', footer: '',
+                    content: kind === 'question' ? questionsContent(request.questions) : '工具权限请求：' + data.tool_name,
+                    reply: { token: request.id, url: `https://t.me/${bot.username}?start=${request.id}`, users: access.policy.users } }, access.config), access.config);
+                if (result.ok)
+                    await stateTransaction(access, state => {
+                        const current = state.requests[request.id];
+                        if (current) {
+                            current.notified ??= {};
+                            current.notified.feishu = feishuTarget(access.config);
+                        }
+                    });
+            }
+        }
+        const response = await (options.wait ?? waitInteraction)(access, request, () => accessReplies(file, options.env), { signal: controller.signal });
+        if (response && !controller.signal.aborted)
+            options.response?.(response);
+        else
+            options.err?.('远程交互已经结束，或答案没有提交。不会自动作答，本机操作不受影响。');
+    }
+    catch (error) {
+        await stateTransaction(access, state => {
+            const current = state.requests[request.id];
+            if (current)
+                finishInteraction(current, { kind: current.claimed ? 'unknown' : 'not-applied', text: '远程交互处理失败，请在本机检查。' });
+        }).catch(() => { });
+        throw error;
+    }
+    finally {
+        process.off('SIGTERM', cancel);
+        process.off('SIGINT', cancel);
+        if (controller.signal.aborted)
+            await stateTransaction(access, state => {
+                const current = state.requests[request.id];
+                if (current)
+                    finishInteraction(current, { kind: current.claimed ? 'unknown' : 'not-applied', text: '交互等待已取消，远程答案是否生效还没有确认。' });
+            }).catch(() => { });
+    }
+}