gsd-pi 2.33.1 → 2.34.0-dev.6769913

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

@@ -1,315 +0,0 @@
-/**
- * Remote Questions — payload formatting and parsing helpers
- */
-
-import type { RemotePrompt, RemoteQuestion, RemoteAnswer } from "./types.js";
-
-export interface SlackBlock {
-  type: string;
-  text?: { type: string; text: string };
-  elements?: Array<{ type: string; text: string }>;
-}
-
-export interface DiscordEmbed {
-  title: string;
-  description: string;
-  color: number;
-  fields: Array<{ name: string; value: string; inline?: boolean }>;
-  footer?: { text: string };
-}
-
-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: RemotePrompt): SlackBlock[] {
-  const blocks: SlackBlock[] = [
-    {
-      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: RemotePrompt): { embeds: DiscordEmbed[]; reactionEmojis: string[] } {
-  const reactionEmojis: string[] = [];
-  const embeds: DiscordEmbed[] = 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: string[] = [];
-    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: string, questions: RemoteQuestion[]): RemoteAnswer {
-  const answers: RemoteAnswer["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: Array<{ emoji: string; count: number }>,
-  replyText: string | null,
-  questions: RemoteQuestion[],
-): RemoteAnswer {
-  if (replyText) return parseSlackReply(replyText, questions);
-
-  const answers: RemoteAnswer["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) as string[];
-
-  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: string[],
-  questions: RemoteQuestion[],
-): RemoteAnswer {
-  const answers: RemoteAnswer["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) as string[];
-
-  answers[q.id] = picked.length > 0
-    ? { answers: q.allowMultiple ? picked : [picked[0]] }
-    : { answers: [], user_note: "No clear response via reactions" };
-
-  return { answers };
-}
-
-export interface TelegramInlineButton {
-  text: string;
-  callback_data: string;
-}
-
-export interface TelegramInlineKeyboardMarkup {
-  inline_keyboard: TelegramInlineButton[][];
-}
-
-export interface TelegramMessage {
-  text: string;
-  parse_mode: "HTML";
-  reply_markup?: TelegramInlineKeyboardMarkup;
-}
-
-function escapeHtml(s: string): string {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-export function formatForTelegram(prompt: RemotePrompt): TelegramMessage {
-  const lines: string[] = ["<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: TelegramMessage = {
-    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: string | null,
-  replyText: string | null,
-  questions: RemoteQuestion[],
-  promptId: string,
-): RemoteAnswer {
-  // 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: RemoteAnswer["answers"] = {};
-  for (const q of questions) {
-    answers[q.id] = { answers: [], user_note: "No response provided" };
-  }
-  return { answers };
-}
-
-function parseAnswerForQuestion(text: string, q: RemoteQuestion): { answers: string[]; user_note?: string } {
-  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: string): string {
-  return text.length > MAX_USER_NOTE_LENGTH ? text.slice(0, MAX_USER_NOTE_LENGTH) + "…" : text;
-}

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

@@ -1,76 +0,0 @@
-/**
- * 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";
-
-export interface ApiRequestOptions {
-  /** Authorization header scheme. Omit to skip the Authorization header entirely. */
-  authScheme?: "Bearer" | "Bot";
-  /** Token for the Authorization header. Ignored when authScheme is omitted. */
-  authToken?: string;
-  /** Max chars of error body to include in thrown Error. Default 200. */
-  safeErrorLength?: number;
-  /** Label used in error messages (e.g. "Discord API", "Slack API"). Default "HTTP". */
-  errorLabel?: string;
-  /** Content-Type override. Default "application/json" when body is present. */
-  contentType?: string;
-}
-
-/**
- * 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: string,
-  method: "GET" | "POST" | "PUT" | "DELETE",
-  body?: unknown,
-  options: ApiRequestOptions = {},
-): Promise<any> {
-  const {
-    authScheme,
-    authToken,
-    safeErrorLength = 200,
-    errorLabel = "HTTP",
-    contentType,
-  } = options;
-
-  const headers: Record<string, string> = {};
-  if (authScheme && authToken) {
-    headers["Authorization"] = `${authScheme} ${authToken}`;
-  }
-
-  const init: RequestInit = {
-    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.ts

@@ -1,184 +0,0 @@
-/**
- * Remote Questions — orchestration manager
- */
-
-import { randomUUID } from "node:crypto";
-import type { ChannelAdapter, RemotePrompt, RemoteQuestion, RemoteAnswer } from "./types.js";
-import { resolveRemoteConfig, type ResolvedConfig } 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";
-
-interface ToolResult {
-  content: Array<{ type: "text"; text: string }>;
-  details?: Record<string, unknown>;
-}
-
-interface QuestionInput {
-  id: string;
-  header: string;
-  question: string;
-  options: Array<{ label: string; description: string }>;
-  allowMultiple?: boolean;
-}
-
-export async function tryRemoteQuestions(
-  questions: QuestionInput[],
-  signal?: AbortSignal,
-): Promise<ToolResult | null> {
-  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 as Error).message)));
-    return errorResult(`Remote auth failed (${config.channel}): ${(err as Error).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 as Error).message)));
-    return errorResult(`Failed to send questions via ${config.channel}: ${(err as Error).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: QuestionInput[], config: ResolvedConfig): RemotePrompt {
-  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): RemoteQuestion => ({
-      id: q.id,
-      header: q.header,
-      question: q.question,
-      options: q.options,
-      allowMultiple: q.allowMultiple ?? false,
-    })),
-  };
-}
-
-function createAdapter(config: ResolvedConfig): ChannelAdapter {
-  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: ChannelAdapter,
-  prompt: RemotePrompt,
-  ref: import("./types.js").RemotePromptRef,
-  signal?: AbortSignal,
-): Promise<RemoteAnswer | null> {
-  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 as Error).message)));
-        return null;
-      }
-    }
-
-    await sleep(prompt.pollIntervalMs, signal);
-  }
-
-  return null;
-}
-
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  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: RemoteAnswer): Record<string, { answers: string[] }> {
-  const out: Record<string, { answers: string[] }> = {};
-  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: string, channel: string): ToolResult {
-  return {
-    content: [{ type: "text", text: sanitizeError(message) }],
-    details: { remote: true, channel, error: true, status: "failed" },
-  };
-}

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

@@ -1,90 +0,0 @@
-/**
- * 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 type { ResolvedConfig } 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: string, message: string): Promise<void> {
-  let config: ResolvedConfig | null;
-  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: ResolvedConfig, title: string, message: string): Promise<void> {
-  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: ResolvedConfig, title: string, message: string): Promise<void> {
-  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: ResolvedConfig, title: string, message: string): Promise<void> {
-  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}`);
-}