gsd-pi 2.18.0 → 2.20.0

package/src/resources/extensions/remote-questions/slack-adapter.ts

@@ -3,10 +3,11 @@
  */
 
 import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
-import { formatForSlack, parseSlackReply } from "./format.js";
+import { formatForSlack, parseSlackReply, parseSlackReactionResponse, SLACK_NUMBER_REACTION_NAMES } from "./format.js";
 
 const SLACK_API = "https://slack.com/api";
 const PER_REQUEST_TIMEOUT_MS = 15_000;
+const SLACK_ACK_REACTION = "white_check_mark";
 
 export class SlackAdapter implements ChannelAdapter {
   readonly name = "slack" as const;
@@ -36,6 +37,17 @@ export class SlackAdapter implements ChannelAdapter {
 
     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 this.slackApi("reactions.add", { channel, timestamp: ts, name });
+        } catch {
+          // Best-effort only
+        }
+      }
+    }
+
     return {
       ref: {
         id: prompt.id,
@@ -51,6 +63,11 @@ export class SlackAdapter implements ChannelAdapter {
   async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
     if (!this.botUserId) await this.validate();
 
+    if (prompt.questions.length === 1) {
+      const reactionAnswer = await this.checkReactions(prompt, ref);
+      if (reactionAnswer) return reactionAnswer;
+    }
+
     const res = await this.slackApi("conversations.replies", {
       channel: ref.channelId,
       ts: ref.threadTs!,
@@ -66,9 +83,48 @@ export class SlackAdapter implements ChannelAdapter {
     return parseSlackReply(String(userReplies[0].text), prompt.questions);
   }
 
+  async acknowledgeAnswer(ref: RemotePromptRef): Promise<void> {
+    try {
+      await this.slackApi("reactions.add", {
+        channel: ref.channelId,
+        timestamp: ref.messageId,
+        name: SLACK_ACK_REACTION,
+      });
+    } catch {
+      // Best-effort only
+    }
+  }
+
+  private async checkReactions(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    const res = await this.slackApi("reactions.get", {
+      channel: ref.channelId,
+      timestamp: ref.messageId,
+      full: "true",
+    });
+
+    if (!res.ok) return null;
+
+    const message = (res.message ?? {}) as {
+      reactions?: Array<{ name?: string; count?: number; users?: string[] }>;
+    };
+    const reactions = Array.isArray(message.reactions) ? message.reactions : [];
+    const picked = reactions
+      .filter((reaction) => reaction.name && SLACK_NUMBER_REACTION_NAMES.includes(reaction.name))
+      .filter((reaction) => {
+        const count = Number(reaction.count ?? 0);
+        const users = Array.isArray(reaction.users) ? reaction.users.map(String) : [];
+        const botIncluded = this.botUserId ? users.includes(this.botUserId) : false;
+        return count > (botIncluded ? 1 : 0);
+      })
+      .map((reaction) => String(reaction.name));
+
+    if (picked.length === 0) return null;
+    return parseSlackReactionResponse(picked, prompt.questions);
+  }
+
   private async slackApi(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>> {
     const url = `${SLACK_API}/${method}`;
-    const isGet = method === "conversations.replies" || method === "auth.test";
+    const isGet = method === "conversations.replies" || method === "auth.test" || method === "reactions.get";
 
     let response: Response;
     if (isGet) {

package/src/resources/extensions/remote-questions/telegram-adapter.ts

@@ -0,0 +1,161 @@
+/**
+ * Remote Questions — Telegram adapter
+ */
+
+import type { ChannelAdapter, RemotePrompt, RemoteDispatchResult, RemoteAnswer, RemotePromptRef } from "./types.js";
+import { formatForTelegram, parseTelegramResponse } from "./format.js";
+
+const TELEGRAM_API = "https://api.telegram.org";
+const PER_REQUEST_TIMEOUT_MS = 15_000;
+
+export class TelegramAdapter implements ChannelAdapter {
+  readonly name = "telegram" as const;
+  private botUserId: number | null = null;
+  private lastUpdateId = 0;
+  private lastSentText = "";
+  private readonly token: string;
+  private readonly chatId: string;
+
+  constructor(token: string, chatId: string) {
+    this.token = token;
+    this.chatId = chatId;
+  }
+
+  async validate(): Promise<void> {
+    const res = await this.telegramApi("getMe");
+    if (!res.ok || !res.result?.id) throw new Error("Telegram auth failed: invalid bot token");
+    this.botUserId = res.result.id;
+  }
+
+  async sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult> {
+    const payload = formatForTelegram(prompt);
+    this.lastSentText = payload.text;
+
+    const params: Record<string, unknown> = {
+      chat_id: this.chatId,
+      text: payload.text,
+      parse_mode: payload.parse_mode,
+    };
+    if (payload.reply_markup) {
+      params.reply_markup = payload.reply_markup;
+    }
+
+    const res = await this.telegramApi("sendMessage", params);
+    if (!res.ok || !res.result?.message_id) {
+      throw new Error(`Telegram sendMessage failed: ${JSON.stringify(res)}`);
+    }
+
+    const messageId = String(res.result.message_id);
+    const messageUrl = this.buildMessageUrl(this.chatId, messageId);
+
+    return {
+      ref: {
+        id: prompt.id,
+        channel: "telegram",
+        messageId,
+        channelId: this.chatId,
+        threadUrl: messageUrl,
+      },
+    };
+  }
+
+  async pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null> {
+    if (!this.botUserId) await this.validate();
+
+    const res = await this.telegramApi("getUpdates", {
+      offset: this.lastUpdateId + 1,
+      timeout: 0,
+      allowed_updates: ["message", "callback_query"],
+    });
+
+    if (!res.ok || !Array.isArray(res.result)) return null;
+
+    for (const update of res.result) {
+      // Advance offset for all updates to prevent reprocessing
+      if (update.update_id > this.lastUpdateId) {
+        this.lastUpdateId = update.update_id;
+      }
+
+      // Handle callback_query (inline keyboard button press)
+      if (update.callback_query) {
+        const cq = update.callback_query;
+        const msg = cq.message;
+        if (
+          msg &&
+          String(msg.chat?.id) === ref.channelId &&
+          String(msg.message_id) === ref.messageId &&
+          cq.from?.id !== this.botUserId
+        ) {
+          // Dismiss the loading spinner on the button
+          try {
+            await this.telegramApi("answerCallbackQuery", { callback_query_id: cq.id });
+          } catch { /* best-effort */ }
+
+          return parseTelegramResponse(cq.data ?? null, null, prompt.questions, prompt.id);
+        }
+      }
+
+      // Handle text reply (reply_to_message)
+      if (update.message) {
+        const msg = update.message;
+        if (
+          String(msg.chat?.id) === ref.channelId &&
+          msg.reply_to_message &&
+          String(msg.reply_to_message.message_id) === ref.messageId &&
+          msg.from?.id !== this.botUserId &&
+          msg.text
+        ) {
+          return parseTelegramResponse(null, msg.text, prompt.questions, prompt.id);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Acknowledge receipt by editing the original message to append a checkmark.
+   * Best-effort — failures are silently ignored.
+   */
+  async acknowledgeAnswer(ref: RemotePromptRef): Promise<void> {
+    try {
+      await this.telegramApi("editMessageText", {
+        chat_id: ref.channelId,
+        message_id: parseInt(ref.messageId, 10),
+        text: this.lastSentText + "\n\n✅ Answered",
+        parse_mode: "HTML",
+      });
+    } catch {
+      // Best-effort — don't let acknowledgement failures affect the flow
+    }
+  }
+
+  private buildMessageUrl(chatId: string, messageId: string): string | undefined {
+    // Supergroups have chat IDs starting with -100
+    if (chatId.startsWith("-100")) {
+      return `https://t.me/c/${chatId.slice(4)}/${messageId}`;
+    }
+    return undefined;
+  }
+
+  private async telegramApi(method: string, params?: Record<string, unknown>): Promise<any> {
+    const url = `${TELEGRAM_API}/bot${this.token}/${method}`;
+    const init: RequestInit = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(PER_REQUEST_TIMEOUT_MS),
+    };
+
+    if (params) {
+      init.body = JSON.stringify(params);
+    }
+
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      const safeText = text.length > 200 ? text.slice(0, 200) + "…" : text;
+      throw new Error(`Telegram API HTTP ${response.status}: ${safeText}`);
+    }
+    return response.json();
+  }
+}

package/src/resources/extensions/remote-questions/types.ts

@@ -2,7 +2,7 @@
  * Remote Questions — shared types
  */
 
-export type RemoteChannel = "slack" | "discord";
+export type RemoteChannel = "slack" | "discord" | "telegram";
 
 export interface RemoteQuestionOption {
   label: string;
@@ -72,4 +72,5 @@ export interface ChannelAdapter {
   validate(): Promise<void>;
   sendPrompt(prompt: RemotePrompt): Promise<RemoteDispatchResult>;
   pollAnswer(prompt: RemotePrompt, ref: RemotePromptRef): Promise<RemoteAnswer | null>;
+  acknowledgeAnswer?(ref: RemotePromptRef): Promise<void>;
 }

package/src/resources/extensions/ttsr/ttsr-manager.ts

@@ -10,6 +10,7 @@
  * per-rule JS RegExp iteration when the native module is not loaded.
  */
 import picomatch from "picomatch";
+import { debugTime, debugCount, debugPeak } from "../gsd/debug-logger.js";
 
 // ── Native TTSR engine (optional) ─────────────────────────────────────
 let nativeTtsr: {
@@ -98,6 +99,12 @@ const DEFAULT_SETTINGS: Required<TtsrSettings> = {
 /** Cap per-stream buffer at 512KB to prevent unbounded memory growth. */
 const MAX_BUFFER_BYTES = 512 * 1024;
 
+/**
+ * Minimum interval (ms) between JS-fallback regex checks on the same buffer.
+ * Prevents CPU spinning when deltas arrive faster than regex evaluation (#468).
+ */
+const JS_FALLBACK_CHECK_INTERVAL_MS = 50;
+
 const DEFAULT_SCOPE: TtsrScope = {
 	allowText: true,
 	allowThinking: false,
@@ -110,6 +117,8 @@ export class TtsrManager {
 	readonly #rules = new Map<string, TtsrEntry>();
 	readonly #injectionRecords = new Map<string, InjectionRecord>();
 	readonly #buffers = new Map<string, string>();
+	/** Tracks last JS-fallback check time per buffer key to throttle CPU (#468). */
+	readonly #lastJsCheckAt = new Map<string, number>();
 	#messageCount = 0;
 	#nativeHandle: number | null = null;
 	#nativeDirty = false;
@@ -333,6 +342,7 @@ export class TtsrManager {
 	 * remain in JS as they are lightweight and context-dependent.
 	 */
 	checkDelta(delta: string, context: TtsrMatchContext): Rule[] {
+		const stopTimer = debugTime("ttsr-check");
 		const bufferKey = this.#bufferKey(context);
 		let nextBuffer = `${this.#buffers.get(bufferKey) ?? ""}${delta}`;
 		// Cap buffer size — keep the tail so patterns still match recent output
@@ -340,6 +350,7 @@ export class TtsrManager {
 			nextBuffer = nextBuffer.slice(-MAX_BUFFER_BYTES);
 		}
 		this.#buffers.set(bufferKey, nextBuffer);
+		debugPeak("ttsrPeakBuffer", nextBuffer.length);
 
 		// Lazily compile native engine if rules changed.
 		if (this.#nativeDirty) this.#compileNative();
@@ -357,10 +368,22 @@ export class TtsrManager {
 				if (!this.#matchesGlobalPaths(entry, context)) continue;
 				matches.push(entry.rule);
 			}
+			debugCount("ttsrChecks");
+			stopTimer({ bufferSize: nextBuffer.length, native: true, rulesChecked: this.#rules.size, matched: matches.map(m => m.name) });
 			return matches;
 		}
 
 		// ── JS fallback: per-rule regex iteration ─────────────────────────
+		// Throttle JS regex checks to prevent CPU spinning on fast token
+		// streams — regex on a growing buffer is O(rules × buffer_size) (#468).
+		const now = Date.now();
+		const lastCheck = this.#lastJsCheckAt.get(bufferKey) ?? 0;
+		if (now - lastCheck < JS_FALLBACK_CHECK_INTERVAL_MS) {
+			stopTimer({ bufferSize: nextBuffer.length, throttled: true });
+			return [];
+		}
+		this.#lastJsCheckAt.set(bufferKey, now);
+
 		const matches: Rule[] = [];
 		for (const [name, entry] of this.#rules) {
 			if (!this.#canTrigger(name)) continue;
@@ -369,6 +392,8 @@ export class TtsrManager {
 			if (!this.#matchesCondition(entry, nextBuffer)) continue;
 			matches.push(entry.rule);
 		}
+		debugCount("ttsrChecks");
+		stopTimer({ bufferSize: nextBuffer.length, native: false, rulesChecked: this.#rules.size, matched: matches.map(m => m.name) });
 		return matches;
 	}
 
@@ -406,6 +431,7 @@ export class TtsrManager {
 	/** Reset stream buffers (called on new turn). */
 	resetBuffer(): void {
 		this.#buffers.clear();
+		this.#lastJsCheckAt.clear();
 	}
 
 	/** Check if any TTSR rules are registered. */

package/src/resources/extensions/voice/index.ts

@@ -7,9 +7,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 
-const SWIFT_SRC = path.join(__dirname, "speech-recognizer.swift");
-const RECOGNIZER_BIN = path.join(__dirname, "speech-recognizer");
-const PYTHON_SCRIPT = path.join(__dirname, "speech-recognizer.py");
+const __extensionDir = import.meta.dirname!;
+const SWIFT_SRC = path.join(__extensionDir, "speech-recognizer.swift");
+const RECOGNIZER_BIN = path.join(__extensionDir, "speech-recognizer");
+const PYTHON_SCRIPT = path.join(__extensionDir, "speech-recognizer.py");
 
 const IS_DARWIN = process.platform === "darwin";
 const IS_LINUX = process.platform === "linux";