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

package/dist/reply-platform.js

@@ -0,0 +1,209 @@
+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 };
+}
+// 仅用于通知展示：按 sessionId 读取本地会话注册表名称，不做进程身份核验，失败时返回空。
+export async function findSessionName(session, options = {}) {
+    if (!session || !/^[A-Za-z0-9_-]{1,128}$/.test(session))
+        return '';
+    const directory = path.join(path.dirname(claudeSettingsPath(options.env, options.home ?? homedir())), 'sessions');
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return '';
+    }
+    for (const name of names) {
+        if (!/^\d+\.json$/.test(name))
+            continue;
+        try {
+            const bytes = await readFile(path.join(directory, name));
+            if (bytes.length > 128 * 1024)
+                continue;
+            const d = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+            if (d.sessionId === session && typeof d.name === 'string' && d.name.trim())
+                return d.name;
+        }
+        catch { /* 其他损坏或写入中的会话文件不提供名称。 */ }
+    }
+    return '';
+}
+export async function validateTarget(target, options = {}) {
+    const current = await findSession(target.session, options);
+    return current !== null && current.pid === target.pid && current.birth === target.birth && current.tty === target.tty;
+}
+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 没有找到目标窗口，或注入失败。不会改投其他窗口，也不会重复输入。');
+}

package/dist/reply-state.js

@@ -0,0 +1,189 @@
+import { readFile, mkdir, open, rename, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { randomBytes, createHash } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ConfigError, decodeUtf8, loadConfig, ready } from './config.js';
+import { replyHooksReady } from './claude-code.js';
+export const TTL = 24 * 60 * 60 * 1000;
+export const digest = (text) => createHash('sha256').update(text).digest('hex');
+export const botKey = (config) => digest(config.telegram.token);
+export const targetEpoch = (target) => digest(JSON.stringify([target.session, target.pid, target.birth, target.tty]));
+export const policyPath = (config) => config + '.reply.json';
+export const replyDirectory = (config) => config + '.reply-data';
+export async function readJson(file) {
+    try {
+        const bytes = await readFile(file);
+        if (bytes.length > 16 * 1024 * 1024)
+            throw new Error();
+        return JSON.parse(decodeUtf8(bytes));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new ConfigError('无法读取回复配置或状态。为了不覆盖现有数据，远程输入没有启用。');
+    }
+}
+export async function atomicJson(file, value) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = path.join(path.dirname(file), `.reply-${randomBytes(12).toString('hex')}.tmp`);
+    const handle = await open(temporary, 'wx', 0o600);
+    try {
+        try {
+            await handle.writeFile(JSON.stringify(value) + '\n', 'utf8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, file);
+    }
+    finally {
+        await unlink(temporary).catch(error => { if (error.code !== 'ENOENT')
+            throw error; });
+    }
+}
+export async function locked(file, work) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    let handle;
+    for (let attempt = 0; attempt < 100; attempt++) {
+        try {
+            handle = await open(file, 'wx', 0o600);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw new ConfigError('无法获取回复状态写入锁。');
+            if (attempt === 99)
+                throw new ConfigError('回复状态锁正忙。请确认相关进程已经退出，再处理残留锁。');
+            await delay(40);
+        }
+    }
+    try {
+        return await work();
+    }
+    finally {
+        await handle?.close();
+        await unlink(file);
+    }
+}
+export async function accessReplies(file, env = process.env) {
+    const policy = await readJson(policyPath(file));
+    if (policy === null || policy.enabled === false)
+        return null;
+    if (policy.version !== 1 || policy.enabled !== true || typeof policy.bot !== 'string' || !/^[a-f0-9]{64}$/.test(policy.bot)
+        || typeof policy.generation !== 'string' || !/^[a-f0-9]{32}$/.test(policy.generation)
+        || !Array.isArray(policy.users) || !policy.users.length || policy.users.some((id) => typeof id !== 'string' || !/^[1-9][0-9]*$/.test(id))) {
+        throw new ConfigError('回复授权配置无效，远程输入已停用。');
+    }
+    if (!await replyHooksReady(file, { env }))
+        throw new ConfigError('回复所需的 hooks 缺失、时序不安全或已禁用。请重新运行 integration claude-code install，并在 /hooks 中确认加载。');
+    const config = await loadConfig(file, true, env);
+    if (!ready(config, 'telegram') || botKey(config) !== policy.bot)
+        throw new ConfigError('Telegram Bot 已变更或不可用，请重新运行 reply setup 授权。');
+    const users = policy.users.filter((id) => config.telegram.chatIds.includes(id));
+    if (!users.length)
+        throw new ConfigError('授权用户不在当前 Telegram 接收名单中，远程输入已停用。');
+    const effective = { ...policy, users };
+    return { file, config, policy: effective, identity: digest(JSON.stringify([policy.bot, policy.generation, users, policy.permissions === true])) };
+}
+export async function stateTransaction(access, work) {
+    const directory = replyDirectory(access.file);
+    return locked(path.join(directory, 'state.lock'), async () => {
+        const policy = await readJson(policyPath(access.file));
+        if (!policy?.enabled || policy.bot !== access.policy.bot || policy.generation !== access.policy.generation
+            || (policy.permissions === true) !== (access.policy.permissions === true))
+            throw new ConfigError('回复授权已撤销或发生变化，没有写入旧状态。');
+        let state = await readJson(path.join(directory, 'state.json'));
+        if (!state || state.identity !== access.identity)
+            state = { version: 1, identity: access.identity, offset: 0, sessions: {}, entries: {}, pending: {}, requests: {}, calls: {} };
+        const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+        state.requests ??= {};
+        state.calls ??= {};
+        if (state.version !== 1 || !Number.isSafeInteger(state.offset) || state.offset < 0
+            || ![state.sessions, state.entries, state.pending, state.requests, state.calls].every(record))
+            throw new ConfigError('回复状态结构无效，远程输入已停用。');
+        const now = Date.now();
+        for (const section of [state.sessions, state.entries, state.pending, state.requests, state.calls])
+            for (const [key, value] of Object.entries(section)) {
+                if (!record(value) || typeof value.updated !== 'number' || !Number.isFinite(value.updated)
+                    || value.updated > now + 60000 || now - value.updated > TTL)
+                    delete section[key];
+            }
+        for (const [key, value] of Object.entries(state.sessions)) {
+            if (value.session !== key || !Number.isSafeInteger(value.pid) || value.pid <= 0 || typeof value.birth !== 'string'
+                || typeof value.tty !== 'string' || typeof value.working !== 'boolean')
+                delete state.sessions[key];
+        }
+        for (const [key, value] of Object.entries(state.entries)) {
+            if (typeof value.session !== 'string' || typeof value.epoch !== 'string')
+                delete state.entries[key];
+        }
+        for (const [key, value] of Object.entries(state.pending)) {
+            if (typeof value.epoch !== 'string' || !/^[1-9][0-9]*$/.test(value.chat) || typeof value.id !== 'string'
+                || !['queued', 'submitted', 'unknown'].includes(value.phase))
+                delete state.pending[key];
+        }
+        for (const [key, value] of Object.entries(state.requests)) {
+            if (value.id !== key || !['question', 'permission'].includes(value.kind) || !record(value.input)
+                || !Array.isArray(value.questions) || !record(value.answers) || !Array.isArray(value.selected)
+                || !Number.isFinite(value.expires))
+                delete state.requests[key];
+        }
+        const result = await work(state);
+        await atomicJson(path.join(directory, 'state.json'), state);
+        return result;
+    });
+}
+export async function configureReplies(file, prompts, env = process.env) {
+    if (!await replyHooksReady(file, { env }))
+        throw new ConfigError('请先运行 integration claude-code install，安装绑定此通知配置的完整 hooks，再配置回复。');
+    const config = await loadConfig(file, true, env);
+    if (!ready(config, 'telegram'))
+        throw new ConfigError('回复 Claude 需要先配置 Telegram Bot 和私聊接收人。');
+    const available = config.telegram.chatIds.filter(id => /^[1-9][0-9]*$/.test(id));
+    if (!available.length)
+        throw new ConfigError('远程回复仅支持 Telegram 私聊用户，不支持群聊。');
+    const before = await readJson(policyPath(file));
+    prompts.out('远程回复等同于在本机 Claude Code 终端输入并提交内容。它可以提交 Claude 命令，但不会自动批准工具权限。请只授权给可信用户。');
+    prompts.out('飞书按钮会跳转到 Telegram，不直接接收飞书消息。这个功能需要独占 Bot 的 getUpdates，请不要与旧版桥接或其他机器共用同一个 Bot。');
+    prompts.out('Windows 使用系统 PowerShell / 控制台 API；macOS 使用 Ghostty 或 tmux，需要相应的系统权限。');
+    prompts.out('目前不支持 VS Code 集成终端、WSL 和 SSH。目标不确定或会话已经切换时，会拒绝输入。');
+    prompts.out('通知接收人不会自动获得输入权限。可选择的私聊 chat_id：' + available.join('、'));
+    const text = await prompts.text('请输入要授权的私聊 chat_id（逗号分隔；留空取消）：');
+    if (!text.trim())
+        return false;
+    const users = [...new Set(text.split(',').map(id => id.trim()))];
+    if (users.some(id => !available.includes(id)))
+        throw new ConfigError('只能授权当前通知名单中的私聊用户。');
+    prompts.out('将授权以下用户远程输入：' + users.join('、'));
+    prompts.out('结构化问题会展示真实选项，也支持自定义回答；普通回复会在本轮结束后输入。问题、选项和工具请求参数可能包含敏感信息，会发送到授权私聊和已配置的飞书。');
+    const permissions = /^(y|yes)$/i.test(await prompts.text('是否允许这些用户逐次批准或拒绝工具权限？这不会修改永久规则。[y/N] '));
+    if (!/^(y|yes)$/i.test(await prompts.text('确认启用远程回复并接受上述权限范围？[y/N] ')))
+        return false;
+    await locked(policyPath(file) + '.lock', async () => {
+        if (JSON.stringify(before) !== JSON.stringify(await readJson(policyPath(file))))
+            throw new ConfigError('回复授权已被其他进程修改，请重试。');
+        const effective = await loadConfig(file, true, env);
+        if (botKey(effective) !== botKey(config) || users.some(id => !effective.telegram.chatIds.includes(id)))
+            throw new ConfigError('通知配置在授权期间发生了变化，请重试。');
+        await atomicJson(policyPath(file), { version: 1, enabled: true, bot: botKey(config), users, permissions, generation: randomBytes(16).toString('hex') });
+    });
+    prompts.out('授权已保存。旧消息的回复映射不会保留；请从启用后的任务完成通知进入。');
+    return true;
+}
+export async function disableReplies(file, prompts) {
+    const before = await readJson(policyPath(file));
+    if (!before?.enabled) {
+        prompts.out('远程回复尚未启用。');
+        return true;
+    }
+    if (!/^(y|yes)$/i.test(await prompts.text('确认禁用远程回复？通知和凭据都会保留。[y/N] ')))
+        return false;
+    await locked(policyPath(file) + '.lock', async () => {
+        if (JSON.stringify(before) !== JSON.stringify(await readJson(policyPath(file))))
+            throw new ConfigError('回复授权发生了变化，请重试。');
+        await atomicJson(policyPath(file), { ...before, enabled: false });
+    });
+    prompts.out('远程回复已禁用。正在进行的操作无法撤回，桥接会在下次检查时退出。');
+    return true;
+}

package/dist/reply-telegram.js

@@ -0,0 +1,19 @@
+import { requestJson } from './channels.js';
+import { ConfigError } from './config.js';
+export function telegramApi(token, request = requestJson) {
+    return async (method, payload) => {
+        if (!['sendMessage', 'editMessageReplyMarkup', 'answerCallbackQuery', 'getMe', 'getUpdates', 'getWebhookInfo'].includes(method))
+            throw new ConfigError('不支持的 Telegram 桥接方法');
+        const response = await request(`https://api.telegram.org/bot${token}/${method}`, payload);
+        if (response.ok !== true) {
+            if (response.error_code === 409)
+                throw new ConfigError('Telegram 轮询冲突；检查旧版桥接、其他机器或 webhook，桥接不会抢占或删除 webhook');
+            throw new ConfigError('Telegram 桥接请求失败；不输出服务端正文或秘密');
+        }
+        return response.result;
+    };
+}
+export async function replyHint(api, chat, title, content, replyTo, markup) {
+    return api('sendMessage', { chat_id: chat, text: title + '\n\n' + content,
+        ...(replyTo ? { reply_parameters: { message_id: replyTo } } : {}), ...(markup ? { reply_markup: markup } : {}) });
+}