gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/remote-questions/format.js

@@ -0,0 +1,234 @@
+/**
+ * Remote Questions — payload formatting and parsing helpers
+ */
+export const DISCORD_NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
+export const SLACK_NUMBER_REACTION_NAMES = ["one", "two", "three", "four", "five"];
+const MAX_USER_NOTE_LENGTH = 500;
+export 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" });
+    }
+    if (prompt.context?.source) {
+        blocks.push({
+            type: "context",
+            elements: [{
+                    type: "mrkdwn",
+                    text: `Source: \`${prompt.context.source}\``,
+                }],
+        });
+    }
+    return blocks;
+}
+export 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`);
+        }
+        if (prompt.context?.source) {
+            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 };
+}
+export function parseSlackReply(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 };
+}
+export function parseDiscordResponse(reactions, replyText, questions) {
+    if (replyText)
+        return parseSlackReply(replyText, 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(Boolean);
+    answers[q.id] = picked.length > 0
+        ? { answers: q.allowMultiple ? picked : [picked[0]] }
+        : { answers: [], user_note: "No clear response via reactions" };
+    return { answers };
+}
+export function parseSlackReactionResponse(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(Boolean);
+    answers[q.id] = picked.length > 0
+        ? { answers: q.allowMultiple ? picked : [picked[0]] }
+        : { answers: [], user_note: "No clear response via reactions" };
+    return { answers };
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function formatForTelegram(prompt) {
+    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>${escapeHtml(q.header)}</b>`);
+        lines.push(escapeHtml(q.question));
+        lines.push("");
+        for (let i = 0; i < q.options.length; i++) {
+            lines.push(`${i + 1}. <b>${escapeHtml(q.options[i].label)}</b> — ${escapeHtml(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",
+    };
+    // Inline keyboard for single-question with <=5 options
+    const isSingle = prompt.questions.length === 1;
+    if (isSingle && 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;
+}
+export function parseTelegramResponse(callbackData, replyText, questions, promptId) {
+    // Handle callback_data from inline keyboard button press
+    if (callbackData) {
+        const match = callbackData.match(new RegExp(`^${promptId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:(\\d+)$`));
+        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] } } };
+            }
+        }
+    }
+    // Handle text reply — delegate to parseSlackReply (text parsing is format-agnostic)
+    if (replyText)
+        return parseSlackReply(replyText, questions);
+    const answers = {};
+    for (const q of questions) {
+        answers[q.id] = { answers: [], user_note: "No response provided" };
+    }
+    return { answers };
+}
+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] };
+    }
+    return { answers: [], user_note: truncateNote(text) };
+}
+function truncateNote(text) {
+    return text.length > MAX_USER_NOTE_LENGTH ? text.slice(0, MAX_USER_NOTE_LENGTH) + "…" : text;
+}

package/dist/resources/extensions/remote-questions/http-client.js

@@ -0,0 +1,43 @@
+/**
+ * Remote Questions — shared HTTP client
+ *
+ * Centralizes timeout, error handling, and JSON serialization logic
+ * used by all channel adapters (Discord, Slack, Telegram).
+ */
+import { PER_REQUEST_TIMEOUT_MS } from "./types.js";
+/**
+ * Makes an HTTP request with standardized timeout, error handling, and JSON
+ * serialization.
+ *
+ * - Sets `AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS)` on every request.
+ * - Serializes `body` as JSON and sets Content-Type when provided.
+ * - Returns `{}` for 204 No Content responses.
+ * - Truncates error response bodies to `safeErrorLength` chars (default 200).
+ */
+export async function apiRequest(url, method, body, options = {}) {
+    const { authScheme, authToken, safeErrorLength = 200, errorLabel = "HTTP", contentType, } = options;
+    const headers = {};
+    if (authScheme && authToken) {
+        headers["Authorization"] = `${authScheme} ${authToken}`;
+    }
+    const init = {
+        method,
+        headers,
+        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    };
+    if (body !== undefined) {
+        headers["Content-Type"] = contentType ?? "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 > safeErrorLength
+            ? text.slice(0, safeErrorLength) + "\u2026"
+            : text;
+        throw new Error(`${errorLabel} HTTP ${response.status}: ${safeText}`);
+    }
+    return response.json();
+}

package/dist/resources/extensions/remote-questions/manager.js

@@ -0,0 +1,156 @@
+/**
+ * Remote Questions — orchestration manager
+ */
+import { randomUUID } from "node:crypto";
+import { resolveRemoteConfig } from "./config.js";
+import { DiscordAdapter } from "./discord-adapter.js";
+import { SlackAdapter } from "./slack-adapter.js";
+import { TelegramAdapter } from "./telegram-adapter.js";
+import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
+import { sanitizeError } from "../shared/sanitize.js";
+export async function tryRemoteQuestions(questions, signal) {
+    const config = resolveRemoteConfig();
+    if (!config)
+        return null;
+    const prompt = createPrompt(questions, config);
+    writePromptRecord(createPromptRecord(prompt));
+    const adapter = createAdapter(config);
+    try {
+        await adapter.validate();
+    }
+    catch (err) {
+        markPromptStatus(prompt.id, "failed", sanitizeError(String(err.message)));
+        return errorResult(`Remote auth failed (${config.channel}): ${err.message}`, config.channel);
+    }
+    let dispatch;
+    try {
+        dispatch = await adapter.sendPrompt(prompt);
+        markPromptDispatched(prompt.id, dispatch.ref);
+    }
+    catch (err) {
+        markPromptStatus(prompt.id, "failed", sanitizeError(String(err.message)));
+        return errorResult(`Failed to send questions via ${config.channel}: ${err.message}`, config.channel);
+    }
+    const answer = await pollUntilDone(adapter, prompt, dispatch.ref, signal);
+    if (!answer) {
+        markPromptStatus(prompt.id, signal?.aborted ? "cancelled" : "timed_out");
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        timed_out: true,
+                        channel: config.channel,
+                        prompt_id: prompt.id,
+                        timeout_minutes: config.timeoutMs / 60000,
+                        thread_url: dispatch.ref.threadUrl ?? null,
+                        message: `User did not respond within ${config.timeoutMs / 60000} minutes.`,
+                    }),
+                }],
+            details: {
+                remote: true,
+                channel: config.channel,
+                timed_out: true,
+                promptId: prompt.id,
+                threadUrl: dispatch.ref.threadUrl ?? null,
+                status: signal?.aborted ? "cancelled" : "timed_out",
+            },
+        };
+    }
+    markPromptAnswered(prompt.id, answer);
+    // Best-effort acknowledgement gives remote users a visible receipt signal.
+    try {
+        await adapter.acknowledgeAnswer?.(dispatch.ref);
+    }
+    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: dispatch.ref.threadUrl ?? null,
+            questions,
+            response: answer,
+            status: "answered",
+        },
+    };
+}
+function createPrompt(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 createAdapter(config) {
+    if (config.channel === "slack")
+        return new SlackAdapter(config.token, config.channelId);
+    if (config.channel === "telegram")
+        return new TelegramAdapter(config.token, config.channelId);
+    return new DiscordAdapter(config.token, config.channelId);
+}
+async function pollUntilDone(adapter, prompt, ref, signal) {
+    let retryCount = 0;
+    while (Date.now() < prompt.timeoutAt && !signal?.aborted) {
+        try {
+            const answer = await adapter.pollAnswer(prompt, ref);
+            updatePromptRecord(prompt.id, { lastPollAt: Date.now() });
+            retryCount = 0;
+            if (answer)
+                return answer;
+        }
+        catch (err) {
+            retryCount++;
+            if (retryCount > 1) {
+                markPromptStatus(prompt.id, "failed", sanitizeError(String(err.message)));
+                return null;
+            }
+        }
+        await sleep(prompt.pollIntervalMs, signal);
+    }
+    return null;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(() => {
+            if (signal)
+                signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+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;
+}
+function errorResult(message, channel) {
+    return {
+        content: [{ type: "text", text: sanitizeError(message) }],
+        details: { remote: true, channel, error: true, status: "failed" },
+    };
+}

package/dist/resources/extensions/remote-questions/{mod.ts → mod.js}

@@ -1,16 +1,7 @@
 // Barrel file — re-exports consumed by external modules
-
 export { handleRemote } from "./remote-command.js";
 export { createPromptRecord, writePromptRecord } from "./store.js";
 export { getLatestPromptSummary } from "./status.js";
-export {
-	parseSlackReply,
-	parseDiscordResponse,
-	formatForDiscord,
-	formatForSlack,
-	parseSlackReactionResponse,
-	formatForTelegram,
-	parseTelegramResponse,
-} from "./format.js";
+export { parseSlackReply, parseDiscordResponse, formatForDiscord, formatForSlack, parseSlackReactionResponse, formatForTelegram, parseTelegramResponse, } from "./format.js";
 export { resolveRemoteConfig, isValidChannelId } from "./config.js";
 export { sendRemoteNotification } from "./notify.js";

package/dist/resources/extensions/remote-questions/notify.js

@@ -0,0 +1,89 @@
+/**
+ * Remote Notifications — one-way alert delivery to configured channels.
+ *
+ * Sends informational messages to Slack/Discord/Telegram without expecting
+ * a reply. Used for auto-mode events like secrets-required pauses where
+ * the user needs to be notified but should NOT send sensitive data back
+ * through the channel.
+ */
+import { resolveRemoteConfig } from "./config.js";
+import { PER_REQUEST_TIMEOUT_MS } from "./types.js";
+/**
+ * Send a one-way notification to the configured remote channel.
+ * Non-blocking, non-fatal — failures are silently ignored.
+ *
+ * SECURITY: This is intentionally one-way. Never use remote channels
+ * to collect secrets or sensitive values.
+ */
+export async function sendRemoteNotification(title, message) {
+    let config;
+    try {
+        config = resolveRemoteConfig();
+    }
+    catch {
+        return; // Remote not configured — skip silently
+    }
+    if (!config)
+        return;
+    try {
+        switch (config.channel) {
+            case "slack":
+                await sendSlackNotification(config, title, message);
+                break;
+            case "discord":
+                await sendDiscordNotification(config, title, message);
+                break;
+            case "telegram":
+                await sendTelegramNotification(config, title, message);
+                break;
+        }
+    }
+    catch {
+        // Non-fatal — remote notifications are best-effort
+    }
+}
+async function sendSlackNotification(config, title, message) {
+    const response = await fetch(`https://slack.com/api/chat.postMessage`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+            "Content-Type": "application/json; charset=utf-8",
+        },
+        body: JSON.stringify({
+            channel: config.channelId,
+            text: `⚠️ *${title}*\n${message}`,
+        }),
+        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        throw new Error(`Slack HTTP ${response.status}`);
+}
+async function sendDiscordNotification(config, title, message) {
+    const response = await fetch(`https://discord.com/api/v10/channels/${config.channelId}/messages`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bot ${config.token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            content: `⚠️ **${title}**\n${message}`,
+        }),
+        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        throw new Error(`Discord HTTP ${response.status}`);
+}
+async function sendTelegramNotification(config, title, message) {
+    const response = await fetch(`https://api.telegram.org/bot${config.token}/sendMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            chat_id: config.channelId,
+            text: `⚠️ *${title}*\n${message}`,
+            parse_mode: "Markdown",
+        }),
+        signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        throw new Error(`Telegram HTTP ${response.status}`);
+}