gsd-pi 2.76.0-dev.76f9a2dc5 → 2.76.0-dev.97807402

package/packages/mcp-server/dist/remote-questions.js

@@ -0,0 +1,732 @@
+/**
+ * Remote Questions — self-contained MCP-server adapter
+ *
+ * Mirrors the routing logic from src/resources/extensions/ask-user-questions.ts
+ * but without any dependency on @gsd/pi-coding-agent or the main src/ tree.
+ * All channel adapters (Discord, Slack, Telegram), config resolution, HTTP
+ * calls, and polling are inlined here so packages/mcp-server remains a
+ * standalone package.
+ *
+ * Entry points consumed by server.ts:
+ *   isRemoteConfigured()     — cheap synchronous config check
+ *   tryRemoteQuestions(...)  — dispatch + poll + return result
+ */
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const PER_REQUEST_TIMEOUT_MS = 15_000;
+const DISCORD_API = 'https://discord.com/api/v10';
+const SLACK_API = 'https://slack.com/api';
+const TELEGRAM_API = 'https://api.telegram.org';
+const DISCORD_NUMBER_EMOJIS = ['1️⃣', '2️⃣', '3️⃣', '4️⃣', '5️⃣'];
+const SLACK_NUMBER_REACTION_NAMES = ['one', 'two', 'three', 'four', 'five'];
+const DEFAULT_TIMEOUT_MINUTES = 5;
+const DEFAULT_POLL_INTERVAL_SECONDS = 5;
+const MIN_TIMEOUT_MINUTES = 1;
+const MAX_TIMEOUT_MINUTES = 30;
+const MIN_POLL_INTERVAL_SECONDS = 2;
+const MAX_POLL_INTERVAL_SECONDS = 30;
+const CHANNEL_ID_PATTERNS = {
+    slack: /^[A-Z0-9]{9,12}$/,
+    discord: /^\d{17,20}$/,
+    telegram: /^-?\d{5,20}$/,
+};
+const ENV_KEYS = {
+    slack: 'SLACK_BOT_TOKEN',
+    discord: 'DISCORD_BOT_TOKEN',
+    telegram: 'TELEGRAM_BOT_TOKEN',
+};
+// ---------------------------------------------------------------------------
+// Config resolution — reads ~/.gsd/PREFERENCES.md YAML frontmatter
+// ---------------------------------------------------------------------------
+function clampNumber(value, fallback, min, max) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.max(min, Math.min(max, n));
+}
+/**
+ * Minimal YAML frontmatter reader. Handles:
+ *   ---
+ *   key: value
+ *   nested_key:
+ *     child: value
+ *   ---
+ * Sufficient for the flat remote_questions config block.
+ */
+function parseSimpleFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/m);
+    if (!match)
+        return {};
+    const yaml = match[1];
+    const result = {};
+    let currentSection = null;
+    const sectionData = {};
+    for (const rawLine of yaml.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (!line.trim() || line.trim().startsWith('#'))
+            continue;
+        // Top-level key (no indent)
+        const topMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)$/);
+        if (topMatch) {
+            currentSection = topMatch[1];
+            const val = topMatch[2].trim();
+            if (val) {
+                result[currentSection] = parseSimpleScalar(val);
+                currentSection = null; // scalar, no children
+            }
+            else {
+                sectionData[currentSection] = {};
+                result[currentSection] = sectionData[currentSection];
+            }
+            continue;
+        }
+        // Indented child key
+        const childMatch = line.match(/^\s+([a-zA-Z_][a-zA-Z0-9_]*):\s*(.*)$/);
+        if (childMatch && currentSection && sectionData[currentSection]) {
+            const childKey = childMatch[1];
+            const childVal = childMatch[2].trim();
+            sectionData[currentSection][childKey] = parseSimpleScalar(childVal);
+        }
+    }
+    return result;
+}
+function parseSimpleScalar(raw) {
+    const s = raw.replace(/^["']|["']$/g, '').trim();
+    if (s === 'true')
+        return true;
+    if (s === 'false')
+        return false;
+    if (s === 'null' || s === '~')
+        return null;
+    const n = Number(s);
+    if (s !== '' && !Number.isNaN(n))
+        return n;
+    return s;
+}
+function loadPreferencesFromFile(path) {
+    try {
+        const content = readFileSync(path, 'utf-8');
+        return parseSimpleFrontmatter(content);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveRemoteConfig() {
+    const gsdHome = process.env['GSD_HOME'] ?? join(homedir(), '.gsd');
+    const globalPath = join(gsdHome, 'PREFERENCES.md');
+    const prefs = loadPreferencesFromFile(globalPath);
+    if (!prefs)
+        return null;
+    const rq = prefs['remote_questions'];
+    if (!rq || !rq['channel'] || !rq['channel_id'])
+        return null;
+    const channel = String(rq['channel']);
+    if (channel !== 'slack' && channel !== 'discord' && channel !== 'telegram')
+        return null;
+    const channelId = String(rq['channel_id']);
+    if (!CHANNEL_ID_PATTERNS[channel].test(channelId))
+        return null;
+    const token = process.env[ENV_KEYS[channel]];
+    if (!token)
+        return null;
+    const timeoutMs = clampNumber(rq['timeout_minutes'], DEFAULT_TIMEOUT_MINUTES, MIN_TIMEOUT_MINUTES, MAX_TIMEOUT_MINUTES) * 60 * 1000;
+    const pollIntervalMs = clampNumber(rq['poll_interval_seconds'], DEFAULT_POLL_INTERVAL_SECONDS, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS) * 1000;
+    return { channel, channelId, timeoutMs, pollIntervalMs, token };
+}
+/**
+ * Cheap synchronous check — does not make any HTTP requests.
+ */
+export function isRemoteConfigured() {
+    return resolveRemoteConfig() !== null;
+}
+// ---------------------------------------------------------------------------
+// HTTP helper
+// ---------------------------------------------------------------------------
+async function apiRequest(url, method, body, authScheme, authToken, errorLabel) {
+    const headers = {
+        Authorization: `${authScheme} ${authToken}`,
+    };
+    const init = {
+        method,
+        headers,
+        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    };
+    if (body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        init.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, init);
+    if (response.status === 204)
+        return {};
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        const safeText = text.length > 200 ? text.slice(0, 200) + '\u2026' : text;
+        throw new Error(`${errorLabel} HTTP ${response.status}: ${safeText}`);
+    }
+    return response.json();
+}
+// ---------------------------------------------------------------------------
+// Payload formatting
+// ---------------------------------------------------------------------------
+function formatForDiscord(prompt) {
+    const reactionEmojis = [];
+    const embeds = prompt.questions.map((q, questionIndex) => {
+        const supportsReactions = prompt.questions.length === 1;
+        const optionLines = q.options.map((opt, i) => {
+            const emoji = DISCORD_NUMBER_EMOJIS[i] ?? `${i + 1}.`;
+            if (supportsReactions && DISCORD_NUMBER_EMOJIS[i])
+                reactionEmojis.push(DISCORD_NUMBER_EMOJIS[i]);
+            return `${emoji} **${opt.label}** — ${opt.description}`;
+        });
+        const footerParts = [];
+        if (supportsReactions) {
+            footerParts.push(q.allowMultiple
+                ? 'Reply with comma-separated choices (`1,3`) or react with matching numbers'
+                : 'Reply with a number or react with the matching number');
+        }
+        else {
+            footerParts.push(`Question ${questionIndex + 1}/${prompt.questions.length} — reply with one line per question or use semicolons`);
+        }
+        footerParts.push(`Source: ${prompt.context.source}`);
+        return {
+            title: q.header,
+            description: q.question,
+            color: 0x7c3aed,
+            fields: [{ name: 'Options', value: optionLines.join('\n') }],
+            footer: { text: footerParts.join(' · ') },
+        };
+    });
+    return { embeds, reactionEmojis };
+}
+function formatForSlack(prompt) {
+    const blocks = [
+        { type: 'header', text: { type: 'plain_text', text: 'GSD needs your input' } },
+    ];
+    if (prompt.questions.length > 1) {
+        blocks.push({
+            type: 'context',
+            elements: [{ type: 'mrkdwn', text: 'Reply once in thread using one line per question or semicolons (`1; 2; custom note`).' }],
+        });
+    }
+    for (const q of prompt.questions) {
+        const supportsReactions = prompt.questions.length === 1;
+        blocks.push({ type: 'section', text: { type: 'mrkdwn', text: `*${q.header}*\n${q.question}` } });
+        blocks.push({
+            type: 'section',
+            text: { type: 'mrkdwn', text: q.options.map((opt, i) => `${i + 1}. *${opt.label}* — ${opt.description}`).join('\n') },
+        });
+        blocks.push({
+            type: 'context',
+            elements: [{
+                    type: 'mrkdwn',
+                    text: prompt.questions.length > 1
+                        ? (q.allowMultiple ? 'For this question, use comma-separated numbers (`1,3`) or free text.' : 'For this question, use one number (`1`) or free text.')
+                        : (q.allowMultiple
+                            ? (supportsReactions ? 'Reply in thread with comma-separated numbers (`1,3`) or react with matching number emoji.' : 'Reply in thread with comma-separated numbers (`1,3`) or free text.')
+                            : (supportsReactions ? 'Reply in thread with a number (`1`) or react with the matching number emoji.' : 'Reply in thread with a number (`1`) or free text.')),
+                }],
+        });
+        blocks.push({ type: 'divider' });
+    }
+    return blocks;
+}
+function formatForTelegram(prompt) {
+    const escape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const lines = ['<b>GSD needs your input</b>', ''];
+    for (let qi = 0; qi < prompt.questions.length; qi++) {
+        const q = prompt.questions[qi];
+        lines.push(`<b>${escape(q.header)}</b>`);
+        lines.push(escape(q.question));
+        lines.push('');
+        for (let i = 0; i < q.options.length; i++) {
+            lines.push(`${i + 1}. <b>${escape(q.options[i].label)}</b> — ${escape(q.options[i].description)}`);
+        }
+        lines.push('');
+        if (prompt.questions.length === 1) {
+            lines.push(q.allowMultiple ? 'Reply with comma-separated numbers (1,3) or free text.' : 'Reply with a number or tap a button below.');
+        }
+        else {
+            lines.push(`Question ${qi + 1}/${prompt.questions.length} — reply with one line per question or use semicolons.`);
+        }
+        if (qi < prompt.questions.length - 1)
+            lines.push('');
+    }
+    const result = {
+        text: lines.join('\n'),
+        parse_mode: 'HTML',
+    };
+    if (prompt.questions.length === 1 && prompt.questions[0].options.length <= 5) {
+        result.reply_markup = {
+            inline_keyboard: prompt.questions[0].options.map((opt, i) => [{
+                    text: `${i + 1}. ${opt.label}`,
+                    callback_data: `${prompt.id}:${i}`,
+                }]),
+        };
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Response parsing
+// ---------------------------------------------------------------------------
+function parseAnswerForQuestion(text, q) {
+    if (!text)
+        return { answers: [], user_note: 'No response provided' };
+    if (/^[\d,\s]+$/.test(text)) {
+        const nums = text
+            .split(',')
+            .map((s) => parseInt(s.trim(), 10))
+            .filter((n) => !Number.isNaN(n) && n >= 1 && n <= q.options.length);
+        if (nums.length > 0) {
+            const selected = nums.map((n) => q.options[n - 1].label);
+            return { answers: q.allowMultiple ? selected : [selected[0]] };
+        }
+    }
+    const single = parseInt(text, 10);
+    if (!Number.isNaN(single) && single >= 1 && single <= q.options.length) {
+        return { answers: [q.options[single - 1].label] };
+    }
+    const truncated = text.length > 500 ? text.slice(0, 500) + '\u2026' : text;
+    return { answers: [], user_note: truncated };
+}
+function parseTextReply(text, questions) {
+    const answers = {};
+    const trimmed = text.trim();
+    if (questions.length === 1) {
+        answers[questions[0].id] = parseAnswerForQuestion(trimmed, questions[0]);
+        return { answers };
+    }
+    const parts = trimmed.includes(';')
+        ? trimmed.split(';').map((s) => s.trim()).filter(Boolean)
+        : trimmed.split('\n').map((s) => s.trim()).filter(Boolean);
+    for (let i = 0; i < questions.length; i++) {
+        answers[questions[i].id] = parseAnswerForQuestion(parts[i] ?? '', questions[i]);
+    }
+    return { answers };
+}
+function parseDiscordReactions(reactions, questions) {
+    const answers = {};
+    if (questions.length !== 1) {
+        for (const q of questions) {
+            answers[q.id] = { answers: [], user_note: 'Discord reactions are only supported for single-question prompts' };
+        }
+        return { answers };
+    }
+    const q = questions[0];
+    const picked = reactions
+        .filter((r) => DISCORD_NUMBER_EMOJIS.includes(r.emoji) && r.count > 0)
+        .map((r) => q.options[DISCORD_NUMBER_EMOJIS.indexOf(r.emoji)]?.label)
+        .filter((l) => Boolean(l));
+    answers[q.id] = picked.length > 0
+        ? { answers: q.allowMultiple ? picked : [picked[0]] }
+        : { answers: [], user_note: 'No clear response via reactions' };
+    return { answers };
+}
+function parseSlackReactions(reactionNames, questions) {
+    const answers = {};
+    if (questions.length !== 1) {
+        for (const q of questions) {
+            answers[q.id] = { answers: [], user_note: 'Slack reactions are only supported for single-question prompts' };
+        }
+        return { answers };
+    }
+    const q = questions[0];
+    const picked = reactionNames
+        .filter((name) => SLACK_NUMBER_REACTION_NAMES.includes(name))
+        .map((name) => q.options[SLACK_NUMBER_REACTION_NAMES.indexOf(name)]?.label)
+        .filter((l) => Boolean(l));
+    answers[q.id] = picked.length > 0
+        ? { answers: q.allowMultiple ? picked : [picked[0]] }
+        : { answers: [], user_note: 'No clear response via reactions' };
+    return { answers };
+}
+function parseTelegramCallbackData(callbackData, questions, promptId) {
+    const pattern = new RegExp(`^${promptId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:(\\d+)$`);
+    const match = callbackData.match(pattern);
+    if (match && questions.length === 1) {
+        const idx = parseInt(match[1], 10);
+        const q = questions[0];
+        if (idx >= 0 && idx < q.options.length) {
+            return { answers: { [q.id]: { answers: [q.options[idx].label] } } };
+        }
+    }
+    return null;
+}
+// --- Discord ---
+async function discordValidate(token, channelId) {
+    const meRes = await apiRequest(`${DISCORD_API}/users/@me`, 'GET', undefined, 'Bot', token, 'Discord API');
+    if (!meRes['id'])
+        throw new Error('Discord auth failed: invalid token');
+    const botUserId = String(meRes['id']);
+    let guildId = null;
+    try {
+        const chanRes = await apiRequest(`${DISCORD_API}/channels/${channelId}`, 'GET', undefined, 'Bot', token, 'Discord API');
+        if (chanRes['guild_id'])
+            guildId = String(chanRes['guild_id']);
+    }
+    catch { /* non-fatal */ }
+    return { botUserId, guildId };
+}
+async function discordSend(prompt, token, channelId, guildId) {
+    const { embeds, reactionEmojis } = formatForDiscord(prompt);
+    const res = await apiRequest(`${DISCORD_API}/channels/${channelId}/messages`, 'POST', { content: '**GSD needs your input** — reply to this message with your answer', embeds }, 'Bot', token, 'Discord API');
+    if (!res['id'])
+        throw new Error(`Discord send failed: ${JSON.stringify(res)}`);
+    const messageId = String(res['id']);
+    if (prompt.questions.length === 1) {
+        for (const emoji of reactionEmojis) {
+            try {
+                await apiRequest(`${DISCORD_API}/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`, 'PUT', undefined, 'Bot', token, 'Discord API');
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    const threadUrl = guildId ? `https://discord.com/channels/${guildId}/${channelId}/${messageId}` : undefined;
+    return { ref: { id: prompt.id, channel: 'discord', messageId, channelId, threadUrl } };
+}
+async function discordPoll(prompt, ref, token, botUserId) {
+    // Try reactions first for single-question prompts
+    if (prompt.questions.length === 1) {
+        const reactions = [];
+        for (const emoji of DISCORD_NUMBER_EMOJIS) {
+            try {
+                const users = await apiRequest(`${DISCORD_API}/channels/${ref.channelId}/messages/${ref.messageId}/reactions/${encodeURIComponent(emoji)}`, 'GET', undefined, 'Bot', token, 'Discord API');
+                if (Array.isArray(users)) {
+                    const humanUsers = users.filter((u) => u['id'] !== botUserId);
+                    if (humanUsers.length > 0)
+                        reactions.push({ emoji, count: humanUsers.length });
+                }
+            }
+            catch (err) {
+                const msg = String(err.message ?? '');
+                if (msg.includes('HTTP 404'))
+                    continue;
+                if (msg.includes('HTTP 401') || msg.includes('HTTP 403'))
+                    throw err;
+            }
+        }
+        if (reactions.length > 0)
+            return parseDiscordReactions(reactions, prompt.questions);
+    }
+    // Try text replies
+    const messages = await apiRequest(`${DISCORD_API}/channels/${ref.channelId}/messages?after=${ref.messageId}&limit=10`, 'GET', undefined, 'Bot', token, 'Discord API');
+    if (!Array.isArray(messages))
+        return null;
+    const replies = messages.filter((m) => {
+        const msg = m;
+        const author = msg['author'];
+        const msgRef = msg['message_reference'];
+        return author?.['id'] && author['id'] !== botUserId && msgRef?.['message_id'] === ref.messageId && msg['content'];
+    });
+    if (replies.length === 0)
+        return null;
+    const first = replies[0];
+    return parseTextReply(String(first['content']), prompt.questions);
+}
+async function discordAcknowledge(ref, token) {
+    try {
+        await apiRequest(`${DISCORD_API}/channels/${ref.channelId}/messages/${ref.messageId}/reactions/${encodeURIComponent('✅')}/@me`, 'PUT', undefined, 'Bot', token, 'Discord API');
+    }
+    catch { /* best-effort */ }
+}
+// --- Slack ---
+async function slackValidate(token) {
+    const res = await apiRequest(`${SLACK_API}/auth.test`, 'GET', undefined, 'Bearer', token, 'Slack API');
+    if (!res['ok'])
+        throw new Error(`Slack auth failed: ${res['error'] ?? 'invalid token'}`);
+    return String(res['user_id'] ?? '');
+}
+async function slackSend(prompt, token, channelId) {
+    const res = await apiRequest(`${SLACK_API}/chat.postMessage`, 'POST', { channel: channelId, text: 'GSD needs your input', blocks: formatForSlack(prompt) }, 'Bearer', token, 'Slack API');
+    if (!res['ok'])
+        throw new Error(`Slack postMessage failed: ${res['error'] ?? 'unknown'}`);
+    const ts = String(res['ts']);
+    const channel = String(res['channel']);
+    if (prompt.questions.length === 1) {
+        const reactionNames = SLACK_NUMBER_REACTION_NAMES.slice(0, prompt.questions[0].options.length);
+        for (const name of reactionNames) {
+            try {
+                await apiRequest(`${SLACK_API}/reactions.add`, 'POST', { channel, timestamp: ts, name }, 'Bearer', token, 'Slack API');
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    return {
+        ref: {
+            id: prompt.id,
+            channel: 'slack',
+            messageId: ts,
+            threadTs: ts,
+            channelId: channel,
+            threadUrl: `https://slack.com/archives/${channel}/p${ts.replace('.', '')}`,
+        },
+    };
+}
+async function slackPoll(prompt, ref, token, botUserId) {
+    // Check reactions for single-question prompts
+    if (prompt.questions.length === 1) {
+        const qs = new URLSearchParams({ channel: ref.channelId, timestamp: ref.messageId, full: 'true' }).toString();
+        const res = await apiRequest(`${SLACK_API}/reactions.get?${qs}`, 'GET', undefined, 'Bearer', token, 'Slack API');
+        if (res['ok']) {
+            const message = (res['message'] ?? {});
+            const reactions = Array.isArray(message.reactions) ? message.reactions : [];
+            const picked = reactions
+                .filter((r) => r.name && SLACK_NUMBER_REACTION_NAMES.includes(r.name))
+                .filter((r) => {
+                const count = Number(r.count ?? 0);
+                const users = Array.isArray(r.users) ? r.users.map(String) : [];
+                const botIncluded = botUserId ? users.includes(botUserId) : false;
+                return count > (botIncluded ? 1 : 0);
+            })
+                .map((r) => String(r.name));
+            if (picked.length > 0)
+                return parseSlackReactions(picked, prompt.questions);
+        }
+    }
+    // Check thread replies
+    const qs = new URLSearchParams({ channel: ref.channelId, ts: ref.threadTs, limit: '20' }).toString();
+    const res = await apiRequest(`${SLACK_API}/conversations.replies?${qs}`, 'GET', undefined, 'Bearer', token, 'Slack API');
+    if (!res['ok'])
+        return null;
+    const messages = (res['messages'] ?? []);
+    const userReplies = messages.filter((m) => m.ts !== ref.threadTs && m.user && m.user !== botUserId && m.text);
+    if (userReplies.length === 0)
+        return null;
+    return parseTextReply(String(userReplies[0].text), prompt.questions);
+}
+async function slackAcknowledge(ref, token) {
+    try {
+        await apiRequest(`${SLACK_API}/reactions.add`, 'POST', { channel: ref.channelId, timestamp: ref.messageId, name: 'white_check_mark' }, 'Bearer', token, 'Slack API');
+    }
+    catch { /* best-effort */ }
+}
+// --- Telegram ---
+async function telegramValidate(token) {
+    const res = await apiRequest(`${TELEGRAM_API}/bot${token}/getMe`, 'GET', undefined, 'Bearer', token, 'Telegram API');
+    const result = res['result'];
+    if (!res['ok'] || !result?.['id'])
+        throw new Error('Telegram auth failed: invalid bot token');
+    return result['id'];
+}
+async function telegramSend(prompt, token, chatId) {
+    const payload = formatForTelegram(prompt);
+    const params = { chat_id: chatId, text: payload.text, parse_mode: payload.parse_mode };
+    if (payload.reply_markup)
+        params['reply_markup'] = payload.reply_markup;
+    const res = await apiRequest(`${TELEGRAM_API}/bot${token}/sendMessage`, 'POST', params, 'Bearer', token, 'Telegram API');
+    const result = res['result'];
+    if (!res['ok'] || !result?.['message_id'])
+        throw new Error(`Telegram sendMessage failed: ${JSON.stringify(res)}`);
+    const messageId = String(result['message_id']);
+    // Build public URL only for public channels (negative IDs are private groups)
+    const isPublic = !chatId.startsWith('-');
+    const messageUrl = isPublic ? `https://t.me/${chatId.replace('@', '')}/${messageId}` : undefined;
+    return { ref: { id: prompt.id, channel: 'telegram', messageId, channelId: chatId, threadUrl: messageUrl } };
+}
+async function telegramPoll(prompt, ref, token, botUserId, lastUpdateId) {
+    const params = {
+        offset: lastUpdateId.value + 1,
+        timeout: 0,
+        allowed_updates: ['message', 'callback_query'],
+    };
+    const res = await apiRequest(`${TELEGRAM_API}/bot${token}/getUpdates`, 'POST', params, 'Bearer', token, 'Telegram API');
+    if (!res['ok'] || !Array.isArray(res['result']))
+        return null;
+    for (const update of res['result']) {
+        if (update['update_id'] > lastUpdateId.value) {
+            lastUpdateId.value = update['update_id'];
+        }
+        // Callback query (inline keyboard button press)
+        if (update['callback_query']) {
+            const cq = update['callback_query'];
+            const msg = cq['message'];
+            const from = cq['from'];
+            if (msg && String(msg['chat']?.['id']) === ref.channelId &&
+                String(msg['message_id']) === ref.messageId && from?.['id'] !== botUserId) {
+                // Dismiss loading spinner
+                try {
+                    await apiRequest(`${TELEGRAM_API}/bot${token}/answerCallbackQuery`, 'POST', { callback_query_id: cq['id'] }, 'Bearer', token, 'Telegram API');
+                }
+                catch { /* best-effort */ }
+                const callbackData = cq['data'] ? String(cq['data']) : null;
+                if (callbackData) {
+                    const parsed = parseTelegramCallbackData(callbackData, prompt.questions, prompt.id);
+                    if (parsed)
+                        return parsed;
+                }
+            }
+        }
+        // Text message reply
+        if (update['message']) {
+            const msg = update['message'];
+            const from = msg['from'];
+            if (String(msg['chat']?.['id']) === ref.channelId &&
+                from?.['id'] !== botUserId && msg['text']) {
+                return parseTextReply(String(msg['text']), prompt.questions);
+            }
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Polling loop
+// ---------------------------------------------------------------------------
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => { clearTimeout(timer); resolve(); };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+async function pollUntilDone(config, prompt, ref, state, signal) {
+    while (Date.now() < prompt.timeoutAt && !signal?.aborted) {
+        try {
+            let answer = null;
+            if (config.channel === 'discord') {
+                answer = await discordPoll(prompt, ref, config.token, String(state.botUserId));
+            }
+            else if (config.channel === 'slack') {
+                answer = await slackPoll(prompt, ref, config.token, String(state.botUserId));
+            }
+            else {
+                answer = await telegramPoll(prompt, ref, config.token, state.botUserId, state.lastUpdateId);
+            }
+            if (answer)
+                return answer;
+        }
+        catch {
+            // Non-fatal poll error — wait and retry
+        }
+        await sleep(prompt.pollIntervalMs, signal);
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+function buildPrompt(questions, config) {
+    const createdAt = Date.now();
+    return {
+        id: randomUUID(),
+        channel: config.channel,
+        createdAt,
+        timeoutAt: createdAt + config.timeoutMs,
+        pollIntervalMs: config.pollIntervalMs,
+        context: { source: 'ask_user_questions' },
+        questions: questions.map((q) => ({
+            id: q.id,
+            header: q.header,
+            question: q.question,
+            options: q.options,
+            allowMultiple: q.allowMultiple ?? false,
+        })),
+    };
+}
+function formatForTool(answer) {
+    const out = {};
+    for (const [id, data] of Object.entries(answer.answers)) {
+        const list = [...data.answers];
+        if (data.user_note)
+            list.push(`user_note: ${data.user_note}`);
+        out[id] = { answers: list };
+    }
+    return out;
+}
+/**
+ * Dispatch questions to the configured remote channel and wait for a response.
+ *
+ * Returns null when no remote channel is configured.
+ * Returns a tool result shaped like { content, details } on success or
+ * timeout — callers should check details.timed_out before trusting the result.
+ */
+export async function tryRemoteQuestions(questions, signal) {
+    const config = resolveRemoteConfig();
+    if (!config)
+        return null;
+    const prompt = buildPrompt(questions, config);
+    // Validate auth and send the prompt
+    let ref;
+    let state;
+    try {
+        if (config.channel === 'discord') {
+            const { botUserId, guildId } = await discordValidate(config.token, config.channelId);
+            state = { botUserId, guildId };
+            const dispatch = await discordSend(prompt, config.token, config.channelId, guildId);
+            ref = dispatch.ref;
+        }
+        else if (config.channel === 'slack') {
+            const botUserId = await slackValidate(config.token);
+            state = { botUserId };
+            const dispatch = await slackSend(prompt, config.token, config.channelId);
+            ref = dispatch.ref;
+        }
+        else {
+            const botUserId = await telegramValidate(config.token);
+            state = { botUserId, lastUpdateId: { value: 0 } };
+            const dispatch = await telegramSend(prompt, config.token, config.channelId);
+            ref = dispatch.ref;
+        }
+    }
+    catch (err) {
+        return {
+            content: [{ type: 'text', text: `Remote questions failed (${config.channel}): ${err.message}` }],
+            details: { remote: true, channel: config.channel, error: true, status: 'failed' },
+        };
+    }
+    const answer = await pollUntilDone(config, prompt, ref, state, signal);
+    if (!answer) {
+        const timedOut = !signal?.aborted;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        timed_out: timedOut,
+                        channel: config.channel,
+                        prompt_id: prompt.id,
+                        timeout_minutes: config.timeoutMs / 60000,
+                        thread_url: ref.threadUrl ?? null,
+                        message: `User did not respond within ${config.timeoutMs / 60000} minutes.`,
+                    }),
+                }],
+            details: {
+                remote: true,
+                channel: config.channel,
+                timed_out: timedOut,
+                promptId: prompt.id,
+                threadUrl: ref.threadUrl ?? null,
+                status: signal?.aborted ? 'cancelled' : 'timed_out',
+            },
+        };
+    }
+    // Best-effort acknowledgement
+    try {
+        if (config.channel === 'discord')
+            await discordAcknowledge(ref, config.token);
+        else if (config.channel === 'slack')
+            await slackAcknowledge(ref, config.token);
+    }
+    catch { /* best-effort */ }
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ answers: formatForTool(answer) }) }],
+        details: {
+            remote: true,
+            channel: config.channel,
+            timed_out: false,
+            promptId: prompt.id,
+            threadUrl: ref.threadUrl ?? null,
+            questions,
+            status: 'answered',
+        },
+    };
+}
+//# sourceMappingURL=remote-questions.js.map