gsd-pi 2.10.12 → 2.12.0

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

@@ -0,0 +1,163 @@
+/**
+ * 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 };
+}
+
+const NUMBER_EMOJIS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣"];
+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" },
+    },
+  ];
+
+  for (const q of prompt.questions) {
+    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: q.allowMultiple
+          ? "Reply in thread with comma-separated numbers (`1,3`) or free text."
+          : "Reply in thread with a number (`1`) or free text.",
+      }],
+    });
+
+    blocks.push({ type: "divider" });
+  }
+
+  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 = NUMBER_EMOJIS[i] ?? `${i + 1}.`;
+      if (supportsReactions && NUMBER_EMOJIS[i]) reactionEmojis.push(NUMBER_EMOJIS[i]);
+      return `${emoji} **${opt.label}** — ${opt.description}`;
+    });
+
+    const footerText = supportsReactions
+      ? (q.allowMultiple
+          ? "Reply with comma-separated choices (`1,3`) or react with matching numbers"
+          : "Reply with a number or react with the matching number")
+      : `Question ${questionIndex + 1}/${prompt.questions.length} — reply with one line per question or use semicolons`;
+
+    return {
+      title: q.header,
+      description: q.question,
+      color: 0x7c3aed,
+      fields: [{ name: "Options", value: optionLines.join("\n") }],
+      footer: { text: footerText },
+    };
+  });
+
+  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) => NUMBER_EMOJIS.includes(r.emoji) && r.count > 0)
+    .map((r) => q.options[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 };
+}
+
+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/manager.ts

@@ -0,0 +1,192 @@
+/**
+ * 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 { SlackAdapter } from "./slack-adapter.js";
+import { DiscordAdapter } from "./discord-adapter.js";
+import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.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,
+        status: signal?.aborted ? "cancelled" : "timed_out",
+      },
+    };
+  }
+
+  markPromptAnswered(prompt.id, answer);
+  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,
+      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 {
+  return config.channel === "slack"
+    ? new SlackAdapter(config.token, config.channelId)
+    : 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;
+}
+
+// Strip token-like strings from error messages before surfacing
+const TOKEN_PATTERNS = [
+  /xoxb-[A-Za-z0-9\-]+/g,    // Slack bot tokens
+  /xoxp-[A-Za-z0-9\-]+/g,    // Slack user tokens
+  /xoxa-[A-Za-z0-9\-]+/g,    // Slack app tokens
+  /[A-Za-z0-9_\-.]{20,}/g,   // Long opaque secrets (Discord tokens, etc.)
+];
+
+export function sanitizeError(msg: string): string {
+  let sanitized = msg;
+  for (const pattern of TOKEN_PATTERNS) {
+    sanitized = sanitized.replace(pattern, "[REDACTED]");
+  }
+  return sanitized;
+}
+
+function errorResult(message: string, channel: string): ToolResult {
+  return {
+    content: [{ type: "text", text: sanitizeError(message) }],
+    details: { remote: true, channel, error: true, status: "failed" },
+  };
+}