@s0nderlabs/anima-plugin-telegram 0.19.17 → 0.19.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@s0nderlabs/anima-plugin-telegram",
-  "version": "0.19.17",
+  "version": "0.19.19",
   "type": "module",
   "description": "Telegram gateway plugin for anima — long-poll bot, debounced dispatch, reactions, allowlist",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@s0nderlabs/anima-core": "0.19.17",
+    "@s0nderlabs/anima-core": "0.19.19",
     "grammy": "^1.42.0",
     "zod": "^3.23.8"
   }

package/src/approval-resolution.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'bun:test'
+import { formatApprovalResolution } from './listener'
+
+/**
+ * Regression test for v0.19.19: every choice maps to a human-readable
+ * suffix so the post-click modal edit shows the operator what they tapped.
+ * v0.19.18 left modals visible after click because the listener only
+ * answered the popup but never edited the message body. v0.19.19 edits the
+ * text to append this suffix and removes the inline keyboard.
+ */
+describe('formatApprovalResolution', () => {
+  it('labels each choice distinctly with the clicker user id', () => {
+    expect(formatApprovalResolution('once', 42)).toBe('✅ Allowed once (by 42)')
+    expect(formatApprovalResolution('session', 42)).toBe('✅ Allowed for session (by 42)')
+    expect(formatApprovalResolution('always', 42)).toBe('✅ Always allowed (by 42)')
+    expect(formatApprovalResolution('deny', 42)).toBe('❌ Denied (by 42)')
+  })
+
+  it('uses ✅ for permitting choices and ❌ only for deny', () => {
+    for (const choice of ['once', 'session', 'always'] as const) {
+      expect(formatApprovalResolution(choice, 1)).toMatch(/^✅/)
+    }
+    expect(formatApprovalResolution('deny', 1)).toMatch(/^❌/)
+  })
+})

package/src/index.ts

@@ -27,7 +27,12 @@ export type {
   TelegramToolEvent,
 } from './types'
 export { ProgressTracker, PROGRESS_EDIT_INTERVAL } from './progress'
-export { TelegramListener, capForTelegram } from './listener'
+export {
+  TelegramListener,
+  TELEGRAM_ALLOWED_UPDATES,
+  capForTelegram,
+  formatApprovalResolution,
+} from './listener'
 export { buildSessionKey, sanitizeAgentName } from './session-key'
 export { formatTelegramChannel, formatInboundPreview } from './format'
 export { RateLimiter } from './limits'

package/src/listener-allowed-updates.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'bun:test'
+import { TELEGRAM_ALLOWED_UPDATES } from './listener'
+
+/**
+ * Regression test for v0.19.18 callback_query polling fix.
+ *
+ * v0.18.0 introduced inline-keyboard approvals but only subscribed to
+ * `'message'` updates in `bot.start({ allowed_updates })`. v0.19.10 fixed
+ * the handler-registration path but left the polling spec narrow, so every
+ * keyboard tap was silently filtered out by Telegram before grammY ever
+ * saw it. Operators saw the modal "do nothing" — the harness saw zero
+ * resolution events. This test pins both kinds in the polling spec so a
+ * future refactor cannot quietly drop the second one again.
+ */
+describe('TELEGRAM_ALLOWED_UPDATES', () => {
+  it('subscribes to both message and callback_query updates', () => {
+    expect(TELEGRAM_ALLOWED_UPDATES).toContain('message')
+    expect(TELEGRAM_ALLOWED_UPDATES).toContain('callback_query')
+  })
+
+  it('does not over-subscribe to update kinds we have no handler for', () => {
+    // Keep the wire payload minimal. Add new kinds only when a handler exists.
+    expect([...TELEGRAM_ALLOWED_UPDATES].sort()).toEqual(['callback_query', 'message'])
+  })
+})

package/src/listener.ts

@@ -38,6 +38,40 @@ import { startTypingLoop } from './typing'
 const RETRY_INTERVAL_MS = 30_000
 const MAX_LOCK_RETRY_ATTEMPTS = 12
 
+/**
+ * Map an `ApprovalChoice` to the human-readable resolution label appended
+ * to the approval message after a click. Mirrors the keyboard labels so
+ * operators see the same wording in the resolved message that they tapped.
+ */
+export function formatApprovalResolution(choice: ApprovalChoice, byUserId: number): string {
+  const label =
+    choice === 'once'
+      ? '✅ Allowed once'
+      : choice === 'session'
+        ? '✅ Allowed for session'
+        : choice === 'always'
+          ? '✅ Always allowed'
+          : '❌ Denied'
+  return `${label} (by ${byUserId})`
+}
+
+/**
+ * Update kinds we ask Telegram to deliver via long-poll.
+ *
+ * `'message'` covers inbound DMs we dispatch to the brain. `'callback_query'`
+ * covers inline-keyboard taps (the [Allow Once / Session / Always / Deny]
+ * buttons rendered for tool approvals). Without `'callback_query'` here,
+ * Telegram silently filters the click events out of `getUpdates`, the
+ * `bot.on('callback_query:data', ...)` handler never fires, and operator
+ * taps register on the device but never reach the harness — the modal
+ * appears stuck and the brain's tool call hangs until timeout.
+ *
+ * Latent bug from v0.18.0 (the introduction of inline-keyboard approvals);
+ * v0.19.10 fixed handler registration but not the polling spec, which is
+ * why no live drive caught it before v0.19.18.
+ */
+export const TELEGRAM_ALLOWED_UPDATES = ['message', 'callback_query'] as const
+
 export interface TelegramListenerOpts extends TelegramRuntimeContext {
   /** Optional override of the Telegram Bot API root. Used by the mock-bot test. */
   apiRoot?: string
@@ -119,6 +153,24 @@ export class TelegramListener {
     } catch {
       /* ignore */
     }
+    // Resolve the modal visually: append the choice + drop the inline
+    // keyboard. Without this, every clicked approval message stays on
+    // screen with all four buttons, leaving operators unsure whether
+    // their tap registered. Best-effort — if the edit fails (rate
+    // limit, message age, deleted), the underlying approval is still
+    // resolved at the runtime level, so we swallow the error.
+    const originalText =
+      typeof q.message?.text === 'string' && q.message.text.length > 0 ? q.message.text : null
+    const suffix = formatApprovalResolution(parsed.choice, q.from.id)
+    try {
+      if (originalText) {
+        await ctx.editMessageText(`${originalText}\n\n${suffix}`, { reply_markup: undefined })
+      } else {
+        await ctx.editMessageReplyMarkup({ reply_markup: undefined })
+      }
+    } catch {
+      /* ignore — modal was clicked, runtime already resolved; keyboard cleanup is cosmetic */
+    }
   }
 
   async start(): Promise<void> {
@@ -182,7 +234,7 @@ export class TelegramListener {
       .start({
         onStart: info => console.log(`[telegram] listener active @${info.username}`),
         drop_pending_updates: true,
-        allowed_updates: ['message'],
+        allowed_updates: [...TELEGRAM_ALLOWED_UPDATES],
       })
       .catch(err => {
         const verdict = classifyStartFailure(err)