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

package/dist/reply-interactions.js

@@ -0,0 +1,262 @@
+import { randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ConfigError } from './config.js';
+import { stateTransaction, targetEpoch } from './reply-state.js';
+import { replyHint } from './reply-telegram.js';
+import { finishInteraction } from './reply-outcomes.js';
+export const INTERACTION_MS = 5 * 60 * 1000;
+export function questionsFrom(input) {
+    if (!Array.isArray(input.questions) || input.questions.length < 1 || input.questions.length > 4)
+        throw new ConfigError('问题结构无效，请在本机回答');
+    const questions = input.questions;
+    const seen = new Set();
+    for (const q of questions) {
+        if (!q || typeof q.question !== 'string' || !q.question.trim() || seen.has(q.question)
+            || typeof q.header !== 'string' || (q.multiSelect !== undefined && typeof q.multiSelect !== 'boolean') || !Array.isArray(q.options)
+            || q.options.length < 2 || q.options.length > 4 || q.options.some(o => !o || typeof o.label !== 'string' || !o.label.trim()
+            || typeof o.description !== 'string') || new Set(q.options.map(o => o.label)).size !== q.options.length) {
+            throw new ConfigError('问题结构无效，请在本机回答');
+        }
+        seen.add(q.question);
+    }
+    return structuredClone(questions);
+}
+export async function createInteraction(access, target, kind, input, call) {
+    if (kind === 'permission' && access.policy.permissions !== true)
+        throw new ConfigError('未授权远程工具权限处理');
+    const questions = kind === 'question' ? questionsFrom(input) : [];
+    const value = { id: randomBytes(16).toString('hex'), session: target.session, epoch: targetEpoch(target),
+        updated: Date.now(), expires: Date.now() + INTERACTION_MS, kind, input: structuredClone(input), questions,
+        answers: {}, selected: [], index: 0, call, receipts: [], messages: [] };
+    await stateTransaction(access, state => {
+        const current = state.sessions[target.session];
+        if (!current || targetEpoch(current) !== value.epoch)
+            throw new ConfigError('会话目标已变化');
+        if (call) {
+            const bound = state.calls[call];
+            if (!bound || bound.ended || bound.request || bound.epoch !== value.epoch)
+                throw new ConfigError('调用已结束或已绑定；未创建远程问题');
+            bound.request = value.id;
+        }
+        // 不同 tool_use_id 可并行；无绑定的单元级调用仍只保留一个活动交互。
+        if (!call)
+            for (const old of Object.values(state.requests))
+                if (old.session === target.session && !old.result) {
+                    finishInteraction(old, { kind: old.claimed ? 'unknown' : 'not-applied', text: '问题已切换，旧请求不再接受答案。' });
+                }
+        state.requests[value.id] = value;
+        state.entries['token:' + value.id] = { session: target.session, epoch: value.epoch, request: value.id, updated: Date.now() };
+    });
+    return value;
+}
+function active(value) {
+    return !!value && !value.result && !value.response && !value.claimed && value.expires > Date.now();
+}
+export function interactionMarkup(value) {
+    const prefix = `dn:q:${value.id}:${value.index}:`;
+    const buttons = [];
+    if (value.kind === 'permission') {
+        buttons.push([{ text: '✅ 本次允许', callback_data: prefix + 'a' }, { text: '⛔ 拒绝', callback_data: prefix + 'd' }]);
+        buttons.push([{ text: '✍️ 自定义拒绝说明', callback_data: prefix + 'c' }]);
+    }
+    else {
+        const q = value.questions[value.index];
+        q.options.forEach((option, index) => buttons.push([{ text: (value.selected.includes(index) ? '☑ ' : '') + Array.from(option.label).slice(0, 60).join(''), callback_data: prefix + 'o' + index }]));
+        if (q.multiSelect)
+            buttons.push([{ text: '提交所选项', callback_data: prefix + 's' }]);
+        buttons.push([{ text: '✍️ 自定义输入', callback_data: prefix + 'c' }]);
+    }
+    buttons.push([{ text: '关闭远程答题（本机仍可操作）', callback_data: prefix + 'l' }]);
+    return { inline_keyboard: buttons };
+}
+export function interactionContent(value) {
+    if (value.kind === 'permission')
+        return '工具：' + String(value.input.tool_name || '未知') + '\n\n' + JSON.stringify(value.input.tool_input ?? {}, null, 2)
+            + '\n\n仅支持本次允许、拒绝或自定义拒绝说明；官方未提供完整本地按钮列表。不会创建永久权限规则。';
+    const q = value.questions[value.index];
+    return `问题 ${value.index + 1}/${value.questions.length}：${q.question}\n\n`
+        + q.options.map((o, i) => `${i + 1}. ${o.label}\n${o.description}${o.preview ? '\n' + o.preview : ''}`).join('\n\n')
+        + (q.multiSelect ? '\n\n可多选，选好后点击「提交所选项」；也可自定义输入。' : '\n\n点击选项直接回答，或选择自定义输入。')
+        + '\n本机原生窗口同时可答；Claude 先收到的完整答案生效。远程窗口 5 分钟有效，不会默认选择。';
+}
+export async function showInteraction(access, id, chat, api) {
+    const value = await stateTransaction(access, state => state.requests[id]);
+    if (!active(value)) {
+        await replyHint(api, chat, '⚠️ 交互已失效', '请从最新通知进入，或回到本机处理。');
+        return;
+    }
+    // 使用通知分段器发送较长选项，所有选项正文保留，只有最后一段附选择按钮。
+    const { makePlan, deliver } = await import('./channels.js');
+    const { config } = access;
+    const plan = makePlan('telegram', { title: 'Claude Code 需要你处理', content: interactionContent(value), footer: '', level: 'warn' }, { ...config, telegram: { ...config.telegram, chatIds: [chat] } });
+    plan.items[plan.items.length - 1].payload.reply_markup = interactionMarkup(value);
+    plan.onSent = async (item, response) => {
+        const message = response.result?.message_id;
+        if (!Number.isSafeInteger(message))
+            throw new ConfigError('交互通知未返回消息 ID');
+        await stateTransaction(access, state => {
+            const current = state.requests[id];
+            if (current) {
+                state.entries[`tg:${chat}:${message}`] = { session: value.session, epoch: value.epoch, request: id, question: value.index, updated: Date.now() };
+                // 发送期间可能由本机先答；仍登记消息，随后移除过期按钮。
+                (current.messages ??= []).push({ chat, message });
+            }
+        });
+    };
+    // 完整分段及按钮投递成功后才覆盖通用提醒；重发失败时恢复该接收人的兜底提醒。
+    await stateTransaction(access, state => {
+        const current = state.requests[id];
+        if (current?.notified?.telegram)
+            current.notified.telegram = current.notified.telegram.filter(user => user !== chat);
+    });
+    // API 封装由测试或真实桥接注入，不另建网络连接。
+    const result = await deliver(plan, config, async (_url, payload) => ({ ok: true, result: await api('sendMessage', payload) }));
+    if (!result.ok)
+        throw new ConfigError('交互通知未完整发送，请回到本机处理');
+    await stateTransaction(access, state => {
+        const current = state.requests[id];
+        if (!current)
+            return;
+        current.notified ??= {};
+        const users = current.notified.telegram ??= [];
+        if (!users.includes(chat))
+            users.push(chat);
+    });
+}
+function answer(value, text) {
+    const q = value.questions[value.index];
+    Object.defineProperty(value.answers, q.question, { value: text, enumerable: true, writable: true, configurable: true });
+    value.selected = [];
+    value.index++;
+    if (value.index === value.questions.length)
+        value.response = {
+            hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'allow', updatedInput: { ...value.input, questions: value.input.questions, answers: { ...value.answers } } } },
+        };
+}
+export async function handleInteractionCallback(access, callback, chat, api) {
+    if (typeof callback.data !== 'string' || !callback.data.startsWith('dn:q:'))
+        return false;
+    const match = callback.data.match(/^dn:q:([a-f0-9]{32}):(\d):([adcls]|o[0-3])$/);
+    if (!match || typeof callback.id !== 'string')
+        return true;
+    const [, id, index, operation] = match;
+    const outcome = await stateTransaction(access, state => {
+        const value = state.requests[id], target = value && state.sessions[value.session];
+        if (!active(value) || value.index !== Number(index) || !target || targetEpoch(target) !== value.epoch)
+            return 'expired';
+        if (operation === 'l') {
+            finishInteraction(value, { kind: 'not-applied', text: '已关闭远程答题，本机仍可正常处理。' });
+            return 'local';
+        }
+        const question = value.questions[value.index]?.question;
+        const previousIndex = value.index;
+        if (value.kind === 'permission') {
+            if (access.policy.permissions !== true)
+                return 'expired';
+            if (operation === 'a' || operation === 'd') {
+                value.response = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: operation === 'a' ? 'allow' : 'deny' } } };
+            }
+            else if (operation !== 'c')
+                return 'expired';
+        }
+        else {
+            const q = value.questions[value.index];
+            if (operation.startsWith('o')) {
+                const selected = Number(operation.slice(1));
+                if (!q.options[selected])
+                    return 'expired';
+                if (q.multiSelect)
+                    value.selected = value.selected.includes(selected) ? value.selected.filter(i => i !== selected) : [...value.selected, selected].sort();
+                else
+                    answer(value, q.options[selected].label);
+            }
+            else if (operation === 's' && q.multiSelect && value.selected.length)
+                answer(value, value.selected.map(i => q.options[i].label).join(','));
+            else if (operation !== 'c')
+                return 'expired';
+        }
+        if (value.index !== previousIndex || value.response)
+            (value.receipts ??= []).push({ id: callback.id, chat,
+                message: callback.message.message_id, question, answer: value.kind === 'question' ? value.answers[question] : operation === 'a' ? 'allow' : 'deny' });
+        return operation === 'c' ? 'custom' : value.response ? 'done' : value.index !== previousIndex ? 'answered' : 'next';
+    });
+    await api('answerCallbackQuery', { callback_query_id: callback.id,
+        text: outcome === 'expired' ? '未提交：按钮已失效或已有答案待确认' : outcome === 'local' ? '已关闭远程答题，本机不受影响' : outcome === 'done' || outcome === 'answered' ? '答案已登记，尚未确认生效' : '已更新' }).catch(() => { });
+    if (outcome === 'done' || outcome === 'answered')
+        await replyHint(api, chat, '⏳ 答案已登记，等待确认', (outcome === 'answered' ? '仍需完成其余问题，之后才回传整份答案。' : '已进入回传流程，尚不代表 Claude 采用。')
+            + '\n稍后反馈生效、未生效或结果未知；若未收到最终反馈，请检查终端。\n请求：' + id.slice(0, 8)).catch(() => { });
+    if (outcome === 'expired')
+        await replyHint(api, chat, '⚠️ 本次提交未生效', '此操作未提交：问题已处理、过期、题目已切换或已有答案等待确认。\n请求：' + id.slice(0, 8)).catch(() => { });
+    if (outcome === 'custom') {
+        const value = await stateTransaction(access, state => state.requests[id]);
+        if (!active(value))
+            return true;
+        const sent = await replyHint(api, chat, '✍️ 自定义输入', value.kind === 'permission' ? '请回复此消息填写拒绝说明；此输入不会批准权限。' : '请回复此消息输入这个问题的完整答案。', callback.message.message_id, { force_reply: true, selective: true });
+        if (Number.isSafeInteger(sent?.message_id))
+            await stateTransaction(access, state => {
+                state.entries[`tg:${chat}:${sent.message_id}`] = { session: value.session, epoch: value.epoch, request: id, question: value.index, updated: Date.now() };
+            });
+    }
+    else if (outcome === 'next' || outcome === 'answered')
+        await showInteraction(access, id, chat, api);
+    return true;
+}
+export async function handleInteractionText(access, id, chat, message, api) {
+    const text = message.text;
+    if (!text.trim() || Array.from(text).length > 4000) {
+        await replyHint(api, chat, '❌ 未提交答案', '请输入不超过 4000 字符的答案；不会截断。', message.message_id);
+        return;
+    }
+    const outcome = await stateTransaction(access, state => {
+        const value = state.requests[id], target = value && state.sessions[value.session];
+        const entry = state.entries[`tg:${chat}:${message.reply_to_message.message_id}`];
+        if (!active(value) || !target || targetEpoch(target) !== value.epoch || entry?.question !== value.index)
+            return 'expired';
+        const question = value.questions[value.index]?.question;
+        if (value.kind === 'permission') {
+            if (access.policy.permissions !== true)
+                return 'expired';
+            value.response = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: { behavior: 'deny', message: text } } };
+        }
+        else
+            answer(value, text);
+        (value.receipts ??= []).push({ id: `text:${chat}:${message.message_id}`, chat, message: message.message_id,
+            question, answer: value.kind === 'question' ? text : 'deny', custom: true });
+        return value.response ? 'done' : 'next';
+    });
+    await replyHint(api, chat, outcome === 'expired' ? '⚠️ 本次提交未生效' : '⏳ 答案已登记，等待确认', (outcome === 'done' ? '等待 Claude 确认，稍后反馈最终结果；若未收到反馈请检查终端。'
+        : outcome === 'next' ? '仍需完成其余问题，之后才回传整份答案；尚未生效。'
+            : '此操作未提交：对应问题已结束、过期、已切换或已有答案等待确认。') + '\n请求：' + id.slice(0, 8));
+    if (outcome === 'next')
+        await showInteraction(access, id, chat, api);
+}
+export async function waitInteraction(access, value, fresh, options = {}) {
+    const end = Math.min(value.expires, Date.now() + (options.timeout ?? INTERACTION_MS));
+    while (Date.now() < end && !options.signal?.aborted) {
+        const current = await fresh();
+        if (!current || current.identity !== access.identity || (value.kind === 'permission' && current.policy.permissions !== true))
+            return null;
+        const response = await stateTransaction(access, state => {
+            const request = state.requests[value.id], target = state.sessions[value.session];
+            if (!request || request.result || !target || targetEpoch(target) !== value.epoch || (request.call && (!state.calls[request.call] || state.calls[request.call].ended)))
+                return { ended: true };
+            if (!request.response || request.claimed || options.signal?.aborted)
+                return null;
+            request.claimed = true;
+            // 回传后等待独立的完成事件确认；不能在这里删除请求或报告成功。
+            request.expires = Date.now() + INTERACTION_MS;
+            return { response: request.response };
+        });
+        if (response?.ended)
+            return null;
+        if (response?.response)
+            return response.response;
+        await (options.sleep ?? delay)(200);
+    }
+    await stateTransaction(access, state => {
+        const request = state.requests[value.id];
+        if (request && !request.result)
+            finishInteraction(request, { kind: request.claimed ? 'unknown' : 'not-applied', text: options.signal?.aborted ? '交互等待已取消；远程答案未确认生效。' : '远程交互等待超时；未确认生效，本机仍可继续处理。' });
+    });
+    return null;
+}

package/dist/reply-outcomes.js

@@ -0,0 +1,182 @@
+import { digest, stateTransaction, targetEpoch } from './reply-state.js';
+import { replyHint } from './reply-telegram.js';
+// PermissionRequest 没有 tool_use_id：只接受唯一且尚未结束的同输入调用，歧义时保留本机处理。
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])]));
+    return value;
+}
+export const inputFingerprint = (value) => digest(JSON.stringify(canonical(value)) ?? 'null');
+export const callKey = (session, id) => digest(JSON.stringify([session, id]));
+export function finishInteraction(value, result) {
+    if (value.result)
+        return;
+    value.result = result;
+    for (const receipt of value.receipts ?? [])
+        receipt.result ??= result;
+    // 留下短期结果和消息 ID，用于反馈及旧按钮；不保留已结束的问题、参数和答案正文。
+    value.input = {};
+    value.questions = [];
+    value.answers = {};
+    value.selected = [];
+    delete value.response;
+    for (const receipt of value.receipts ?? []) {
+        receipt.answer = '';
+        delete receipt.question;
+    }
+}
+export function endSessionInteractions(state, session, reason) {
+    for (const call of Object.values(state.calls))
+        if (call.session === session)
+            call.ended = true;
+    for (const value of Object.values(state.requests))
+        if (value.session === session && !value.result)
+            finishInteraction(value, {
+                kind: value.claimed ? 'unknown' : 'not-applied',
+                text: value.claimed ? reason + '；没有收到本次答案的生效确认，请检查终端。不会重复提交。' : reason + '；本次远程答案未回传。',
+            });
+}
+export async function registerToolCall(access, target, data) {
+    if (typeof data.tool_use_id !== 'string' || !data.tool_use_id || typeof data.tool_name !== 'string' || !data.tool_input)
+        return;
+    const key = callKey(target.session, data.tool_use_id);
+    await stateTransaction(access, state => {
+        if (state.calls[key])
+            return;
+        const previous = state.sessions[target.session];
+        state.sessions[target.session] = { ...target, working: true, latestCall: key, tracked: previous?.tracked === true && targetEpoch(previous) === targetEpoch(target) };
+        state.calls[key] = { id: data.tool_use_id, session: target.session, epoch: targetEpoch(target), tool: data.tool_name,
+            fingerprint: inputFingerprint(data.tool_input), prompt: typeof data.prompt_id === 'string' ? data.prompt_id : undefined, updated: Date.now() };
+        // 正常工具不一定有权限请求，限制关联索引大小。丢失索引只会回到本机，不会猜目标。
+        const old = Object.entries(state.calls).filter(([, call]) => !call.request).sort((a, b) => a[1].updated - b[1].updated);
+        for (const [id] of old.slice(0, Math.max(0, old.length - 256)))
+            delete state.calls[id];
+    });
+}
+export function matchingCall(state, target, data) {
+    const fingerprint = inputFingerprint(data.tool_input);
+    const matches = Object.entries(state.calls).filter(([, call]) => call.session === target.session && call.epoch === targetEpoch(target)
+        && call.tool === data.tool_name && call.fingerprint === fingerprint
+        && (typeof data.prompt_id !== 'string' || call.prompt === data.prompt_id));
+    // 包括已结束的同内容记录，防止迟到的 PermissionRequest 误绑到重复的新题。
+    if (matches.length !== 1 || matches[0][1].ended || matches[0][1].request || Date.now() - matches[0][1].updated > 300000)
+        return;
+    return matches[0][0];
+}
+function sameAnswer(actual, expected, multi) {
+    if (!multi)
+        return actual === expected;
+    const parts = (value) => [...(Array.isArray(value) ? value : value.split(',')).map(s => s.trim())].sort();
+    return (typeof actual === 'string' || Array.isArray(actual) && actual.every(s => typeof s === 'string'))
+        && JSON.stringify(parts(actual)) === JSON.stringify(parts(expected));
+}
+export async function completeToolCall(access, data) {
+    if (typeof data.session_id !== 'string' || typeof data.tool_use_id !== 'string')
+        return;
+    await stateTransaction(access, state => {
+        const call = state.calls[callKey(data.session_id, data.tool_use_id)];
+        if (!call || call.tool !== data.tool_name)
+            return;
+        call.ended = true;
+        const value = call.request && state.requests[call.request];
+        if (!value || value.result)
+            return;
+        if (data.hook_event_name === 'PostToolUse' && value.kind === 'question') {
+            const output = data.tool_response;
+            const answers = output?.answers;
+            const valid = answers && typeof answers === 'object' && !Array.isArray(answers);
+            const answered = !output?.afkTimeoutMs && output?.followUp !== true && !(typeof output?.response === 'string' && output.response.trim());
+            for (const receipt of value.receipts ?? []) {
+                const q = value.questions.find(q => q.question === receipt.question);
+                const exists = valid && answered && receipt.question !== undefined && Object.hasOwn(answers, receipt.question)
+                    && !output.annotations?.[receipt.question]?.unanswered;
+                receipt.result = !value.claimed ? { kind: 'not-applied', text: '本机或其他应答端已先处理；本次 Telegram 答案未回传。' }
+                    : !valid ? { kind: 'unknown', text: 'Claude 已结束问题，但未提供可核实的答案结果。请检查终端；不会重复提交。' }
+                        : exists && sameAnswer(answers[receipt.question], receipt.answer, q?.multiSelect === true && receipt.custom !== true && q.options.every(o => !o.label.includes(',')))
+                            ? { kind: 'applied', text: 'Claude 已确认采用与你提交内容一致的答案。若本机同时提交了相同内容，无法仅凭结果区分来源。' }
+                            : { kind: 'not-applied', text: 'Claude 已结束问题，但没有采用你提交的答案；本机或其他应答端可能已先处理。' };
+            }
+            finishInteraction(value, { kind: 'not-applied', text: '问题已处理，旧按钮已失效。' });
+        }
+        else if (data.hook_event_name === 'PostToolUse' && value.kind === 'permission') {
+            const allow = value.claimed && value.receipts?.some(r => r.answer === 'allow');
+            finishInteraction(value, allow
+                ? { kind: 'applied', text: '已确认该工具获准并执行完成；无法仅凭完成事件区分是否由本机同时批准。' }
+                : { kind: 'not-applied', text: '该工具已获准执行；本次远程决定未阻止执行。' });
+        }
+        else
+            finishInteraction(value, { kind: value.claimed ? 'unknown' : 'not-applied', text: value.claimed
+                    ? '工具失败、拒绝或取消；此事件不能确认远程决定是否被采用。请检查终端，不会重复提交。'
+                    : '请求已失败、拒绝或取消，本次远程决定未回传。' });
+    });
+}
+export async function drainInteractionFeedback(access, api, fresh, log = () => { }) {
+    const current = await fresh();
+    if (!current || current.identity !== access.identity)
+        return;
+    const work = await stateTransaction(access, state => {
+        for (const value of Object.values(state.requests)) {
+            const target = state.sessions[value.session];
+            if (!value.result && (!target || targetEpoch(target) !== value.epoch || value.expires <= Date.now()))
+                finishInteraction(value, {
+                    kind: value.claimed ? 'unknown' : 'not-applied', text: value.claimed
+                        ? '等待生效确认超时或会话已切换；结果未知，请检查终端。不会自动重复提交。'
+                        : '交互已过期或会话已结束；远程答案未回传，本机仍可按实际界面处理。',
+                });
+        }
+        return Object.values(state.requests).filter(value => value.result || value.receipts?.some(r => r.result));
+    });
+    for (const value of work) {
+        for (const receipt of value.receipts ?? []) {
+            if (!receipt.result || receipt.delivery)
+                continue;
+            const authorized = await fresh();
+            if (!authorized || authorized.identity !== access.identity || !authorized.policy.users.includes(receipt.chat))
+                return;
+            const claimed = await stateTransaction(access, state => {
+                const actual = state.requests[value.id]?.receipts?.find(r => r.id === receipt.id);
+                if (!actual?.result || actual.delivery)
+                    return false;
+                actual.delivery = 'sending';
+                return true;
+            });
+            if (!claimed)
+                continue;
+            let delivery = 'sent';
+            try {
+                const title = receipt.result.kind === 'applied' ? '✅ 答案内容已生效' : receipt.result.kind === 'not-applied' ? '⚠️ 本次提交未生效' : '⚠️ 提交结果暂时无法确认';
+                await replyHint(api, receipt.chat, title, receipt.result.text + '\n请求：' + value.id.slice(0, 8));
+            }
+            catch {
+                delivery = 'unknown';
+                log('Telegram 交互结果反馈发送失败或结果未知；不自动重发，不影响已采用的答案。');
+            }
+            await stateTransaction(access, state => {
+                const actual = state.requests[value.id]?.receipts?.find(r => r.id === receipt.id);
+                if (actual)
+                    actual.delivery = delivery;
+            });
+        }
+        if (!value.result)
+            continue;
+        for (const message of value.messages ?? []) {
+            if (message.cleared)
+                continue;
+            const authorized = await fresh();
+            if (!authorized || authorized.identity !== access.identity || !authorized.policy.users.includes(message.chat))
+                return;
+            // 最多尝试一次移除按钮；编辑失败时旧回调仍由服务端状态拒绝。
+            await stateTransaction(access, state => {
+                const actual = state.requests[value.id]?.messages?.find(m => m.chat === message.chat && m.message === message.message);
+                if (actual)
+                    actual.cleared = true;
+            });
+            const label = value.result.kind === 'unknown' ? '已关闭 · 结果待核实' : value.result.text.includes('过期') ? '已过期 · 不再接受答案' : '已处理 · 不再接受答案';
+            await api('editMessageReplyMarkup', { chat_id: message.chat, message_id: message.message,
+                reply_markup: { inline_keyboard: [[{ text: label, callback_data: `dn:q:${value.id}:0:l` }]] } })
+                .catch(() => log('Telegram 旧按钮移除失败；服务端状态仍拒绝该请求。'));
+        }
+    }
+}

package/dist/reply-platform.js

@@ -0,0 +1,182 @@
+import { spawn } from 'node:child_process';
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { ConfigError } from './config.js';
+import { claudeSettingsPath } from './claude-code.js';
+export const runCommand = (command, args, input = '') => new Promise((resolve, reject) => {
+    const child = spawn(command, args, { windowsHide: true, shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '', overflow = false;
+    const timer = setTimeout(() => { child.kill(); reject(new ConfigError('系统会话操作超时；输入可能已部分送达，不会自动重试')); }, 15000);
+    const fail = () => { clearTimeout(timer); reject(new ConfigError('系统会话操作失败；未输出底层命令或输入')); };
+    child.on('error', fail);
+    child.stdin.on('error', () => { });
+    child.stdout.on('data', data => { if (stdout.length + data.length > 1024 * 1024) {
+        overflow = true;
+        child.kill();
+    }
+    else
+        stdout += data.toString('utf8'); });
+    child.stderr.resume();
+    child.once('close', code => { clearTimeout(timer); overflow ? fail() : resolve({ code: code ?? 1, stdout }); });
+    child.stdin.end(input, 'utf8');
+});
+function powershell(script, input, runner) {
+    const executable = path.win32.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    return runner(executable, ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], JSON.stringify(input));
+}
+const READ_PROCESS = `$ErrorActionPreference='Stop'; [Console]::InputEncoding=[Text.UTF8Encoding]::new($false); $x=[Console]::In.ReadToEnd()|ConvertFrom-Json; $p=Get-Process -Id $x.pid; if($p.ProcessName -ne 'claude'){exit 3}; @{birth=$p.StartTime.ToUniversalTime().Ticks.ToString()}|ConvertTo-Json -Compress`;
+export function sanitizeReply(text) {
+    if (typeof text !== 'string' || !text.trim())
+        throw new ConfigError('回复内容为空');
+    if (Array.from(text).length > 4000)
+        throw new ConfigError('回复超过 4000 字符，未提交；不会截断或拆成多次任务');
+    const value = text.replace(/\r\n|[\r\n\u2028\u2029]/g, ' ').replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').trim();
+    if (!value)
+        throw new ConfigError('回复清理后为空');
+    return value;
+}
+export async function processIdentity(pid, platform = process.platform, runner = runCommand) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        if (platform === 'win32') {
+            const result = await powershell(READ_PROCESS, { pid }, runner);
+            if (result.code !== 0)
+                return null;
+            const d = JSON.parse(result.stdout);
+            return typeof d.birth === 'string' && /^\d+$/.test(d.birth) ? { birth: d.birth, tty: '' } : null;
+        }
+        if (platform === 'darwin') {
+            const result = await runner('/bin/ps', ['-p', String(pid), '-o', 'lstart=', '-o', 'tty=', '-o', 'comm=']);
+            const match = result.stdout.trim().match(/^(\S+\s+\S+\s+\d+\s+\d+:\d+:\d+\s+\d+)\s+(\S+)\s+(.+)$/);
+            if (result.code !== 0 || !match || path.posix.basename(match[3]) !== 'claude' || !/^ttys\d+$/.test(match[2]))
+                return null;
+            const groups = await runner('/bin/ps', ['-p', String(pid), '-o', 'pgid=', '-o', 'tpgid=']);
+            const group = groups.stdout.trim().match(/^(\d+)\s+(\d+)$/);
+            if (groups.code !== 0 || !group || group[1] !== group[2])
+                return null;
+            return { birth: match[1].replace(/\s+/g, ' '), tty: '/dev/' + match[2] };
+        }
+    }
+    catch { /* 目标不确定时拒绝，不向任意前台终端回退。 */ }
+    return null;
+}
+export async function findSession(session, options = {}) {
+    if (!session || !/^[A-Za-z0-9_-]{1,128}$/.test(session))
+        return null;
+    const directory = path.join(path.dirname(claudeSettingsPath(options.env, options.home ?? homedir())), 'sessions');
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return null;
+    }
+    const matches = [];
+    for (const name of names) {
+        if (!/^\d+\.json$/.test(name))
+            continue;
+        try {
+            const bytes = await readFile(path.join(directory, name));
+            if (bytes.length > 128 * 1024)
+                continue;
+            const d = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+            if (d.sessionId === session && d.pid === Number(name.slice(0, -5)))
+                matches.push(d);
+        }
+        catch { /* 其他损坏或写入中的会话文件不作为目标。 */ }
+    }
+    if (matches.length !== 1)
+        return null;
+    const d = matches[0], identity = await processIdentity(d.pid, options.platform, options.runner);
+    if (!identity)
+        return null;
+    return { session, pid: d.pid, ...identity, title: typeof d.name === 'string' ? Array.from(d.name).slice(0, 60).join('') : '',
+        cwd: typeof d.cwd === 'string' ? d.cwd : '', updated: Date.now(), working: false };
+}
+export async function validateTarget(target, options = {}) {
+    const current = await findSession(target.session, options);
+    return current !== null && current.pid === target.pid && current.birth === target.birth && current.tty === target.tty;
+}
+const WINDOWS_INJECT = `$ErrorActionPreference='Stop';[Console]::InputEncoding=[Text.UTF8Encoding]::new($false);$x=[Console]::In.ReadToEnd()|ConvertFrom-Json;$p=Get-Process -Id $x.pid;if($p.ProcessName -ne 'claude' -or $p.StartTime.ToUniversalTime().Ticks.ToString() -ne $x.birth){exit 3}
+Add-Type -TypeDefinition @'
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+public static class DevNotifyConsole {
+ [StructLayout(LayoutKind.Explicit, Size=20, CharSet=CharSet.Unicode)] public struct Record {
+  [FieldOffset(0)] public ushort type;
+  [FieldOffset(4)] public int down;
+  [FieldOffset(8)] public ushort repeat;
+  [FieldOffset(10)] public ushort key;
+  [FieldOffset(14)] public char ch;
+ }
+ [DllImport("kernel32.dll")] static extern bool FreeConsole();
+ [DllImport("kernel32.dll")] static extern bool AttachConsole(uint pid);
+ [DllImport("kernel32.dll",CharSet=CharSet.Unicode)] static extern IntPtr CreateFileW(string n,uint a,uint s,IntPtr p,uint c,uint f,IntPtr t);
+ [DllImport("kernel32.dll",CharSet=CharSet.Unicode)] static extern bool WriteConsoleInputW(IntPtr h,Record[] r,uint n,out uint written);
+ [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
+ [DllImport("kernel32.dll")] static extern uint GetConsoleProcessList([Out] uint[] ids,uint count);
+ public static bool Send(uint pid,string text) {
+  FreeConsole(); if(!AttachConsole(pid))return false;
+  IntPtr h=new IntPtr(-1);
+  try {
+   var ids=new uint[1024];uint count=GetConsoleProcessList(ids,(uint)ids.Length);
+   if(count==0||count>ids.Length)return false;
+   foreach(uint id in ids){if(id==0||id==pid)continue;try{if(System.Diagnostics.Process.GetProcessById((int)id).ProcessName=="claude")return false;}catch{return false;}}
+   h=CreateFileW("CONIN$",0xC0000000,3,IntPtr.Zero,3,0,IntPtr.Zero);
+   if(h==new IntPtr(-1))return false;
+   var records=new List<Record>();
+   foreach(char c in text){records.Add(new Record{type=1,down=1,repeat=1,ch=c});records.Add(new Record{type=1,repeat=1});}
+   records.Add(new Record{type=1,down=1,repeat=1,key=13,ch='\\r'});records.Add(new Record{type=1,repeat=1,key=13});
+   uint written;var all=records.ToArray();return WriteConsoleInputW(h,all,(uint)all.Length,out written)&&written==all.Length;
+  } finally {if(h!=new IntPtr(-1))CloseHandle(h);FreeConsole();}
+ }
+}
+'@
+if([DevNotifyConsole]::Send([uint32]$x.pid,[string]$x.text)){exit 0}else{exit 4}`;
+export async function injectReply(target, text, options = {}) {
+    const safe = sanitizeReply(text), runner = options.runner ?? runCommand, platform = options.platform ?? process.platform;
+    if (!await validateTarget(target, options))
+        throw new ConfigError('会话已关闭、切换或无法核验，请从最新通知回复');
+    if (platform === 'win32') {
+        const result = await powershell(WINDOWS_INJECT, { pid: target.pid, birth: target.birth, text: safe }, runner);
+        if (result.code !== 0)
+            throw new ConfigError('Windows 控制台注入失败或部分写入；不会自动重试，请检查终端');
+        return;
+    }
+    if (platform !== 'darwin')
+        throw new ConfigError('远程回复仅支持 Windows 与 macOS');
+    // 先确定 tmux pane，字面文本通过 stdin 缓冲区传入，绝不作为 shell 或按键名称执行。
+    let listing = null;
+    try {
+        listing = await runner('tmux', ['list-panes', '-a', '-F', '#{pane_id} #{pane_tty}']);
+    }
+    catch { /* Ghostty 回退仅在尚未发送任何输入时使用。 */ }
+    const pane = listing?.code === 0 ? listing.stdout.split('\n').map(line => line.trim().split(/\s+/)).find(parts => parts[1] === target.tty && /^%\d+$/.test(parts[0]))?.[0] : undefined;
+    if (pane) {
+        const name = 'dev-notify-' + target.pid + '-' + Date.now();
+        const loaded = await runner('tmux', ['load-buffer', '-b', name, '-'], safe);
+        if (loaded.code !== 0)
+            throw new ConfigError('tmux 输入缓冲区创建失败，未提交');
+        try {
+            if (!await validateTarget(target, options))
+                throw new ConfigError('会话已变化，未提交');
+            if ((await runner('tmux', ['paste-buffer', '-d', '-b', name, '-t', pane])).code !== 0)
+                throw new ConfigError('tmux 粘贴失败，可能部分送达，不重试');
+            if ((await runner('tmux', ['send-keys', '-t', pane, 'Enter'])).code !== 0)
+                throw new ConfigError('tmux 提交失败，文本可能已输入，不重试');
+        }
+        finally {
+            await runner('tmux', ['delete-buffer', '-b', name]).catch(() => { });
+        }
+        return;
+    }
+    const escape = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const action = 'text:' + safe.replace(/\\/g, '\\\\') + '\\x0d';
+    const script = `tell application "Ghostty"\nrepeat with w in windows\nrepeat with t in terminals of w\nif tty of t is "${escape(target.tty)}" then\nperform action "${escape(action)}" on t\nreturn "ok"\nend if\nend repeat\nend repeat\nreturn "notfound"\nend tell`;
+    const result = await runner('/usr/bin/osascript', ['-'], script);
+    if (result.code !== 0 || result.stdout.trim() !== 'ok')
+        throw new ConfigError('Ghostty 未找到目标或注入失败；不会回退到任意窗口或重复输入');
+}