gsd-pi 2.18.0 → 2.20.0

package/dist/resources/extensions/gsd/tests/remote-questions.test.ts

@@ -1,9 +1,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { parseSlackReply, parseDiscordResponse } from "../../remote-questions/format.ts";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseSlackReply, parseDiscordResponse, formatForDiscord, formatForSlack, parseSlackReactionResponse, formatForTelegram, parseTelegramResponse } from "../../remote-questions/format.ts";
 import { resolveRemoteConfig, isValidChannelId } from "../../remote-questions/config.ts";
 import { sanitizeError } from "../../remote-questions/manager.ts";
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 test("parseSlackReply handles single-number single-question answers", () => {
   const result = parseSlackReply("2", [{
     id: "choice",
@@ -88,6 +94,21 @@ test("parseDiscordResponse rejects multi-question reaction parsing", () => {
   assert.match(String(result.answers.second.user_note), /single-question prompts/i);
 });
 
+test("parseSlackReactionResponse handles single-question reactions", () => {
+  const result = parseSlackReactionResponse(["two"], [{
+    id: "choice",
+    header: "Choice",
+    question: "Pick one",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }]);
+
+  assert.deepEqual(result, { answers: { choice: { answers: ["Beta"] } } });
+});
+
 test("parseSlackReply truncates user_note longer than 500 chars", () => {
   const longText = "x".repeat(600);
   const result = parseSlackReply(longText, [{
@@ -153,3 +174,469 @@ test("sanitizeError preserves short safe messages", () => {
   assert.equal(sanitizeError("Connection refused"), "Connection refused");
 });
 
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Discord Parity Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("formatForDiscord includes context source in footer when present", () => {
+  const prompt = {
+    id: "test-1",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    context: { source: "auto-mode-dispatch" },
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.equal(embeds.length, 1);
+  assert.ok(embeds[0].footer?.text.includes("auto-mode-dispatch"), "footer should include context source");
+});
+
+test("formatForSlack includes context source when present", () => {
+  const blocks = formatForSlack({
+    id: "slack-1",
+    channel: "slack",
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    context: { source: "ask_user_questions" },
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  });
+
+  const sourceBlock = blocks.find((block) => block.type === "context" && block.elements?.some((el) => el.text.includes("Source:")));
+  assert.ok(sourceBlock, "Slack blocks should include a context source block");
+});
+
+test("formatForSlack multi-question prompts explain semicolon and newline reply format", () => {
+  const blocks = formatForSlack({
+    id: "slack-2",
+    channel: "slack",
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick one",
+        options: [
+          { label: "Alpha", description: "A" },
+          { label: "Beta", description: "B" },
+        ],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Explain",
+        options: [
+          { label: "Gamma", description: "G" },
+          { label: "Delta", description: "D" },
+        ],
+        allowMultiple: false,
+      },
+    ],
+  });
+
+  const instructionBlock = blocks.find((block) => block.type === "context" && block.elements?.some((el) => el.text.includes("one line per question")));
+  assert.ok(instructionBlock, "Slack multi-question prompts should explain one-line or semicolon reply format");
+});
+
+test("formatForDiscord omits source from footer when context is absent", () => {
+  const prompt = {
+    id: "test-2",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Choice",
+      question: "Pick one",
+      options: [
+        { label: "A", description: "Alpha" },
+        { label: "B", description: "Beta" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.ok(!embeds[0].footer?.text.includes("Source:"), "footer should not include Source when context absent");
+});
+
+test("formatForDiscord multi-question footer includes question position", () => {
+  const prompt = {
+    id: "test-3",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const { embeds } = formatForDiscord(prompt);
+  assert.equal(embeds.length, 2);
+  assert.ok(embeds[0].footer?.text.includes("1/2"), "first embed footer should show 1/2");
+  assert.ok(embeds[1].footer?.text.includes("2/2"), "second embed footer should show 2/2");
+});
+
+test("formatForDiscord single-question generates reaction emojis", () => {
+  const prompt = {
+    id: "test-4",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Pick",
+      question: "Choose",
+      options: [
+        { label: "A", description: "a" },
+        { label: "B", description: "b" },
+        { label: "C", description: "c" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const { reactionEmojis } = formatForDiscord(prompt);
+  assert.equal(reactionEmojis.length, 3, "should generate 3 reaction emojis for 3 options");
+  assert.equal(reactionEmojis[0], "1️⃣");
+  assert.equal(reactionEmojis[1], "2️⃣");
+  assert.equal(reactionEmojis[2], "3️⃣");
+});
+
+test("formatForDiscord multi-question generates no reaction emojis", () => {
+  const prompt = {
+    id: "test-5",
+    channel: "discord" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const { reactionEmojis } = formatForDiscord(prompt);
+  assert.equal(reactionEmojis.length, 0, "multi-question should not generate reaction emojis");
+});
+
+test("parseDiscordResponse handles multi-question text reply via semicolons", () => {
+  const result = parseDiscordResponse([], "1;2", [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+      ],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Pick one",
+      allowMultiple: false,
+      options: [
+        { label: "Gamma", description: "G" },
+        { label: "Delta", description: "D" },
+      ],
+    },
+  ]);
+
+  assert.deepEqual(result.answers.first.answers, ["Alpha"]);
+  assert.deepEqual(result.answers.second.answers, ["Delta"]);
+});
+
+test("parseDiscordResponse handles multiple reactions for allowMultiple question", () => {
+  const result = parseDiscordResponse(
+    [{ emoji: "1️⃣", count: 1 }, { emoji: "3️⃣", count: 1 }],
+    null,
+    [{
+      id: "choice",
+      header: "Choice",
+      question: "Pick any",
+      allowMultiple: true,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+        { label: "Gamma", description: "G" },
+      ],
+    }],
+  );
+
+  assert.deepEqual(result.answers.choice.answers, ["Alpha", "Gamma"]);
+});
+
+test("DiscordAdapter source-level: acknowledgeAnswer method exists", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("async acknowledgeAnswer"), "should have acknowledgeAnswer method");
+  assert.ok(adapterSrc.includes("✅"), "should use checkmark emoji for acknowledgement");
+});
+
+test("SlackAdapter source-level: supports reaction polling and acknowledgement", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "slack-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("reactions.get"), "should poll Slack reactions");
+  assert.ok(adapterSrc.includes("reactions.add"), "should add Slack reactions");
+  assert.ok(adapterSrc.includes("async acknowledgeAnswer"), "should acknowledge Slack answers");
+  assert.ok(adapterSrc.includes("white_check_mark"), "should use a checkmark acknowledgement reaction");
+});
+
+test("Slack setup source-level: offers channel picker with manual fallback", () => {
+  const commandSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "remote-command.ts"),
+    "utf-8",
+  );
+  assert.ok(commandSrc.includes("users.conversations"), "Slack setup should query Slack channels");
+  assert.ok(commandSrc.includes("Select a Slack channel"), "Slack setup should present a channel picker");
+  assert.ok(commandSrc.includes("Enter channel ID manually"), "Slack setup should preserve manual fallback");
+});
+
+test("DiscordAdapter source-level: resolves guild ID for message URLs", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(adapterSrc.includes("guildId"), "should track guild ID");
+  assert.ok(adapterSrc.includes("guild_id"), "should read guild_id from channel info");
+  assert.ok(
+    adapterSrc.includes("discord.com/channels/"),
+    "should construct message URL with guild/channel/message format",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Telegram Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("formatForTelegram single-question produces inline keyboard", () => {
+  const prompt = {
+    id: "tg-1",
+    channel: "telegram" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Confirm",
+      question: "Proceed?",
+      options: [
+        { label: "Yes", description: "Continue" },
+        { label: "No", description: "Stop" },
+      ],
+      allowMultiple: false,
+    }],
+  };
+
+  const msg = formatForTelegram(prompt);
+  assert.equal(msg.parse_mode, "HTML");
+  assert.ok(msg.text.includes("<b>GSD needs your input</b>"));
+  assert.ok(msg.text.includes("<b>Confirm</b>"));
+  assert.ok(msg.reply_markup, "single-question should have inline keyboard");
+  assert.equal(msg.reply_markup!.inline_keyboard.length, 2, "should have 2 button rows");
+  assert.equal(msg.reply_markup!.inline_keyboard[0][0].callback_data, "tg-1:0");
+  assert.equal(msg.reply_markup!.inline_keyboard[1][0].callback_data, "tg-1:1");
+});
+
+test("formatForTelegram multi-question omits inline keyboard", () => {
+  const prompt = {
+    id: "tg-2",
+    channel: "telegram" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [
+      {
+        id: "q1",
+        header: "First",
+        question: "Pick",
+        options: [{ label: "A", description: "a" }],
+        allowMultiple: false,
+      },
+      {
+        id: "q2",
+        header: "Second",
+        question: "Pick",
+        options: [{ label: "B", description: "b" }],
+        allowMultiple: false,
+      },
+    ],
+  };
+
+  const msg = formatForTelegram(prompt);
+  assert.equal(msg.reply_markup, undefined, "multi-question should not have inline keyboard");
+  assert.ok(msg.text.includes("1/2"), "should show question position");
+  assert.ok(msg.text.includes("2/2"), "should show question position");
+});
+
+test("formatForTelegram escapes HTML in user content", () => {
+  const prompt = {
+    id: "tg-3",
+    channel: "telegram" as const,
+    createdAt: Date.now(),
+    timeoutAt: Date.now() + 60000,
+    pollIntervalMs: 5000,
+    questions: [{
+      id: "q1",
+      header: "Test <script>",
+      question: "Is 5 > 3 & 2 < 4?",
+      options: [{ label: "<b>Yes</b>", description: "it's true" }],
+      allowMultiple: false,
+    }],
+  };
+
+  const msg = formatForTelegram(prompt);
+  assert.ok(msg.text.includes("&lt;script&gt;"), "should escape < > in header");
+  assert.ok(msg.text.includes("5 &gt; 3 &amp; 2 &lt; 4"), "should escape in question");
+  assert.ok(msg.text.includes("&lt;b&gt;Yes&lt;/b&gt;"), "should escape in option label");
+});
+
+test("parseTelegramResponse handles callback_data button press", () => {
+  const questions = [{
+    id: "choice",
+    header: "Pick",
+    question: "Choose",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }];
+
+  const result = parseTelegramResponse("prompt-123:1", null, questions, "prompt-123");
+  assert.deepEqual(result, { answers: { choice: { answers: ["Beta"] } } });
+});
+
+test("parseTelegramResponse handles text reply delegation", () => {
+  const questions = [{
+    id: "choice",
+    header: "Pick",
+    question: "Choose",
+    allowMultiple: false,
+    options: [
+      { label: "Alpha", description: "A" },
+      { label: "Beta", description: "B" },
+    ],
+  }];
+
+  const result = parseTelegramResponse(null, "1", questions, "prompt-123");
+  assert.deepEqual(result, { answers: { choice: { answers: ["Alpha"] } } });
+});
+
+test("parseTelegramResponse handles multi-question semicolons", () => {
+  const questions = [
+    {
+      id: "first",
+      header: "First",
+      question: "Pick",
+      allowMultiple: false,
+      options: [
+        { label: "Alpha", description: "A" },
+        { label: "Beta", description: "B" },
+      ],
+    },
+    {
+      id: "second",
+      header: "Second",
+      question: "Pick",
+      allowMultiple: false,
+      options: [
+        { label: "Gamma", description: "G" },
+        { label: "Delta", description: "D" },
+      ],
+    },
+  ];
+
+  const result = parseTelegramResponse(null, "2;1", questions, "prompt-123");
+  assert.deepEqual(result.answers.first.answers, ["Beta"]);
+  assert.deepEqual(result.answers.second.answers, ["Gamma"]);
+});
+
+test("isValidChannelId validates Telegram chat IDs", () => {
+  // Valid positive ID
+  assert.equal(isValidChannelId("telegram", "12345"), true);
+  // Valid negative group ID
+  assert.equal(isValidChannelId("telegram", "-1001234567890"), true);
+  // Too short
+  assert.equal(isValidChannelId("telegram", "1234"), false);
+  // Non-numeric
+  assert.equal(isValidChannelId("telegram", "abc12345"), false);
+  // URL injection
+  assert.equal(isValidChannelId("telegram", "https://evil.com"), false);
+});
+
+test("sanitizeError strips Telegram bot token patterns", () => {
+  const fakeToken = "1234567890:ABCdefGHIjklMNOpqrSTUvwxyz12345678";
+  const result = sanitizeError(`Token: ${fakeToken}`);
+  assert.ok(!result.includes("1234567890:ABC"), "should strip Telegram bot token");
+});
+
+test("DiscordAdapter source-level: sendPrompt sets threadUrl in ref", () => {
+  const adapterSrc = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "discord-adapter.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    adapterSrc.includes("threadUrl: messageUrl"),
+    "sendPrompt should set threadUrl to the constructed message URL",
+  );
+});

package/dist/resources/extensions/gsd/tests/resolve-ts-hooks.mjs

@@ -1,35 +1,23 @@
-// ESM resolve hook: .js → .ts rewriting for test environments.
-// Only rewrites relative imports from our own source files — not from node_modules.
-//
-// Handles two patterns:
-// 1. .js → .ts  (pi bundler convention: source files use .js specifiers)
-// 2. extensionless → .ts  (some source files omit extensions in relative imports)
+import { fileURLToPath } from 'node:url';
 
-export function resolve(specifier, context, nextResolve) {
-  const parentURL = context.parentURL || '';
-  const isFromNodeModules = parentURL.includes('/node_modules/');
-  const isFromPackages = parentURL.includes('/packages/');
-
-  if (!isFromNodeModules && !isFromPackages && !specifier.startsWith('node:')) {
-    // Rewrite .js → .ts
-    if (specifier.endsWith('.js')) {
-      const tsSpecifier = specifier.replace(/\.js$/, '.ts');
-      try {
-        return nextResolve(tsSpecifier, context);
-      } catch {
-        // fall through to default resolution
-      }
-    }
+const ROOT = new URL("../../../../../", import.meta.url);
+const PACKAGES_ROOT = fileURLToPath(new URL("packages/", ROOT));
 
-    // Try adding .ts to extensionless relative imports
-    if (specifier.startsWith('.') && !/\.[a-z]+$/i.test(specifier)) {
-      try {
-        return nextResolve(specifier + '.ts', context);
-      } catch {
-        // fall through to default resolution
-      }
+export function resolve(specifier, context, nextResolve) {
+  let tsSpecifier = specifier;
+  if (specifier.includes('@gsd/')) {
+    tsSpecifier = specifier.replace('@gsd/', PACKAGES_ROOT).replace('/dist/', '/src/');
+    if (tsSpecifier.includes('/packages/pi-ai') && !tsSpecifier.endsWith('.ts')) {
+        tsSpecifier = tsSpecifier.replace(/\/packages\/pi-ai$/, '/packages/pi-ai/src/index.ts');
+    } else if (!tsSpecifier.includes('/src/') && !tsSpecifier.endsWith('.ts')) {
+        // Fallback for other gsd packages like pi-coding-agent, pi-tui, pi-agent-core
+        tsSpecifier = tsSpecifier.replace(/\/packages\/([^\/]+)$/, '/packages/$1/src/index.ts');
+    } else if (!tsSpecifier.endsWith('.ts') && !tsSpecifier.endsWith('.js') && !tsSpecifier.endsWith('.mjs')) {
+        tsSpecifier += '/index.ts';
     }
+  } else if (specifier.endsWith('.js')) {
+    tsSpecifier = specifier.replace(/\.js$/, '.ts');
   }
 
-  return nextResolve(specifier, context);
+  return nextResolve(tsSpecifier, context);
 }

package/dist/resources/extensions/gsd/tests/resolve-ts.mjs

@@ -1,11 +1,5 @@
-// Custom ESM resolver: rewrites .js imports to .ts for node --test with TypeScript sources.
-// Usage: node --import ./agent/extensions/gsd/tests/resolve-ts.mjs --test ...
-//
-// This is needed because pi extension source files use .js import specifiers
-// (the pi runtime bundler convention), but only .ts files exist on disk.
-// Node's built-in TypeScript support strips types but doesn't rewrite specifiers.
-
 import { register } from 'node:module';
 import { pathToFileURL } from 'node:url';
 
-register(new URL('./resolve-ts-hooks.mjs', import.meta.url), pathToFileURL('./'));
+// Register hook to redirect imports to the dist directory
+register(new URL('./dist-redirect.mjs', import.meta.url), pathToFileURL('./'));