@s0nderlabs/anima-plugin-telegram 0.21.21 → 0.22.1

package/package.json

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

package/src/format.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'bun:test'
-import { formatInboundPreview, formatTelegramChannel } from './format'
+import { formatInboundPreview, formatTelegramChannel, stripTelegramChannelEnvelope } from './format'
+import { parseBypassCommand } from './session-state'
 
 describe('formatTelegramChannel', () => {
   it('wraps text in channel tags with username', () => {
@@ -44,6 +45,51 @@ describe('formatTelegramChannel', () => {
   })
 })
 
+describe('stripTelegramChannelEnvelope', () => {
+  it('strips the envelope and returns inner text', () => {
+    expect(
+      stripTelegramChannelEnvelope(
+        '<channel source="telegram" chat="42" user="el">hello world</channel>',
+      ),
+    ).toBe('hello world')
+  })
+  it('returns input unchanged when no envelope present', () => {
+    expect(stripTelegramChannelEnvelope('hello world')).toBe('hello world')
+    expect(stripTelegramChannelEnvelope('/yolo')).toBe('/yolo')
+  })
+  it('preserves multi-line + nested-bracket content', () => {
+    expect(
+      stripTelegramChannelEnvelope(
+        '<channel source="telegram" chat="1" user="a">line 1\nline 2 with &lt;br&gt; tag</channel>',
+      ),
+    ).toBe('line 1\nline 2 with &lt;br&gt; tag')
+  })
+  // v0.22.0 regression: TG bypass commands (/yolo /perms /reset) fell through
+  // to the brain because parseBypassCommand was given the wrapped string. The
+  // wrapped string starts with '<channel' not '/', so the bypass parser
+  // returns null. After the strip, parseBypassCommand intercepts correctly.
+  it('lets parseBypassCommand intercept after strip (regression)', () => {
+    const wrapped = '<channel source="telegram" chat="1" user="el">/yolo</channel>'
+    expect(parseBypassCommand(wrapped)).toBeNull()
+    expect(parseBypassCommand(stripTelegramChannelEnvelope(wrapped))).toEqual({
+      command: '/yolo',
+      args: [],
+    })
+  })
+  it('handles /perms strict and /reset the same way', () => {
+    const yolo = '<channel source="telegram" chat="1" user="el">/perms strict</channel>'
+    expect(parseBypassCommand(stripTelegramChannelEnvelope(yolo))).toEqual({
+      command: '/perms',
+      args: ['strict'],
+    })
+    const reset = '<channel source="telegram" chat="1" user="el">/reset</channel>'
+    expect(parseBypassCommand(stripTelegramChannelEnvelope(reset))).toEqual({
+      command: '/reset',
+      args: [],
+    })
+  })
+})
+
 describe('formatInboundPreview', () => {
   it('renders short message verbatim', () => {
     expect(

package/src/format.ts

@@ -20,6 +20,24 @@ export function formatTelegramChannel(input: FormatTelegramChannelInput): string
   return `<channel source="telegram" chat="${input.chatId}" user="${safeUser}">${safeText}</channel>`
 }
 
+/**
+ * Inverse of `formatTelegramChannel`: strip the channel envelope and return
+ * the raw inner text. Used by the gateway's TG slot to feed bypass-command
+ * parsing the un-wrapped string (the wrapper would make `parseBypassCommand`'s
+ * `startsWith('/')` check fail and silently drop `/yolo` etc).
+ *
+ * v0.22.0: extracted into plugin-telegram so the regex source lives next to
+ * its forward counterpart `formatTelegramChannel`. If we ever change the
+ * envelope shape (add fields, swap quoting), both stay in sync.
+ *
+ * Returns the input unchanged when there is no envelope (idempotent — safe to
+ * call on already-stripped or non-TG input).
+ */
+const CHANNEL_ENVELOPE_RE = /^<channel[^>]*>([\s\S]*)<\/channel>$/
+export function stripTelegramChannelEnvelope(text: string): string {
+  return text.replace(CHANNEL_ENVELOPE_RE, '$1')
+}
+
 /**
  * One-line preview of an inbound TG message for TUI rows + activity log.
  * Truncated to 80 chars; never includes the bot token or any envelope bytes.

package/src/index.ts

@@ -34,7 +34,11 @@ export {
   formatApprovalResolution,
 } from './listener'
 export { buildSessionKey, sanitizeAgentName } from './session-key'
-export { formatTelegramChannel, formatInboundPreview } from './format'
+export {
+  formatTelegramChannel,
+  formatInboundPreview,
+  stripTelegramChannelEnvelope,
+} from './format'
 export { RateLimiter } from './limits'
 export { sanitizeInbound, type SanitizeReason, type SanitizeResult } from './sanitize'
 export { formatPairingMessage } from './pairing-flow'

package/src/markdown.test.ts

@@ -4,8 +4,47 @@ import {
   formatMarkdownV2,
   isMarkdownParseError,
   stripMarkdownV2,
+  wrapGfmTablesInCodeBlocks,
 } from './markdown'
 
+describe('wrapGfmTablesInCodeBlocks (v0.22.1)', () => {
+  it('wraps a basic 3x3 GFM table in fences', () => {
+    const input = `Here you go:
+
+| Mode   | Behavior | Modal |
+|--------|----------|-------|
+| yolo   | auto     | no    |
+| prompt | approve  | yes   |
+| strict | deny     | no    |
+
+That's the table.`
+    const out = wrapGfmTablesInCodeBlocks(input)
+    expect(out).toContain('```\n| Mode')
+    expect(out).toContain('| strict | deny     | no    |\n```')
+    expect(out).toContain("That's the table.")
+  })
+
+  it('passes through text with no tables unchanged', () => {
+    expect(wrapGfmTablesInCodeBlocks('just prose')).toBe('just prose')
+    expect(wrapGfmTablesInCodeBlocks('| not | a table without separator')).toBe(
+      '| not | a table without separator',
+    )
+  })
+
+  it('handles alignment colons in separator row', () => {
+    const input = `| a | b |
+|:--|--:|
+| 1 | 2 |`
+    const out = wrapGfmTablesInCodeBlocks(input)
+    expect(out.startsWith('```')).toBe(true)
+    expect(out.endsWith('```')).toBe(true)
+  })
+
+  it('keeps non-table pipes intact', () => {
+    expect(wrapGfmTablesInCodeBlocks('use | as separator')).toBe('use | as separator')
+  })
+})
+
 describe('escapeMarkdownV2', () => {
   it('escapes all reserved characters', () => {
     expect(escapeMarkdownV2('a_b*c')).toBe('a\\_b\\*c')

package/src/markdown.ts

@@ -64,6 +64,13 @@ export function isMarkdownParseError(err: unknown): boolean {
 export function formatMarkdownV2(content: string): string {
   if (!content) return content
 
+  // GFM tables don't render in MarkdownV2 — pipes show literally and columns
+  // misalign. Wrap detected table blocks in ``` fences so TG renders them
+  // monospace + preserves column alignment. Detection: a line starting with
+  // `|` followed by a separator row (`|---|---|`) makes the start of a table;
+  // contiguous `|...|` lines are pulled in until the first non-table line.
+  const wrapped = wrapGfmTablesInCodeBlocks(content)
+
   const placeholders: string[] = []
   const ph = (value: string): string => {
     const key = `\x00PH${placeholders.length}\x00`
@@ -71,7 +78,7 @@ export function formatMarkdownV2(content: string): string {
     return key
   }
 
-  let text = content
+  let text = wrapped
 
   text = text.replace(/```(?:[^\n]*\n)?[\s\S]*?```/g, raw => {
     const newlineIdx = raw.indexOf('\n', 3)
@@ -145,6 +152,48 @@ function escapeStrayParens(text: string): string {
     .join('')
 }
 
+/**
+ * Detect GFM table blocks in the brain's reply and wrap them in ``` fences.
+ * TG MarkdownV2 doesn't render tables; without the fence, pipes show literally
+ * and columns drift. With the fence, TG renders monospace + preserves the
+ * brain's space padding so columns line up.
+ *
+ * Table boundary: a `|...|` row immediately followed by a separator row
+ * `|---|---|` (or `:---:`, `---|---`, etc.) is the start. Contiguous `|...|`
+ * data rows are pulled into the same block. First non-pipe line ends it.
+ */
+const TABLE_SEPARATOR_RE = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/
+const TABLE_ROW_RE = /^\s*\|.+\|?\s*$/
+
+export function wrapGfmTablesInCodeBlocks(text: string): string {
+  const lines = text.split('\n')
+  const out: string[] = []
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i] ?? ''
+    if (
+      TABLE_ROW_RE.test(line) &&
+      i + 1 < lines.length &&
+      TABLE_SEPARATOR_RE.test(lines[i + 1] ?? '')
+    ) {
+      const block: string[] = [line, lines[i + 1] ?? '']
+      let j = i + 2
+      while (j < lines.length && TABLE_ROW_RE.test(lines[j] ?? '')) {
+        block.push(lines[j] ?? '')
+        j += 1
+      }
+      out.push('```')
+      out.push(...block)
+      out.push('```')
+      i = j
+      continue
+    }
+    out.push(line)
+    i += 1
+  }
+  return out.join('\n')
+}
+
 function isInsideLinkUrl(seg: string, closeIdx: number): boolean {
   let depth = 0
   for (let j = closeIdx - 1; j >= Math.max(closeIdx - 2000, 0); j--) {

package/src/progress.ts

@@ -94,6 +94,15 @@ export class ProgressTracker {
   private canEdit = true
   private pendingTimer: ReturnType<typeof setTimeout> | null = null
   private finalized = false
+  /**
+   * Serialize all flush operations so the start-event's sendMessage finishes
+   * (assigning messageId) before any end-event's flush runs. Without this
+   * lock, fast tools that fire start+end within ~5ms (e.g. strict-deny path)
+   * would race two parallel sendMessage calls, producing a duplicate "tool
+   * starting" message followed by a separate "tool ended ✗" message instead
+   * of one in-place edit. v0.22.1 fix.
+   */
+  private flushLock: Promise<void> = Promise.resolve()
 
   constructor(
     private readonly bot: Bot,
@@ -118,7 +127,13 @@ export class ProgressTracker {
       if (idx == null || this.lines[idx] == null) return
       this.lines[idx] = `${this.lines[idx]} ${ev.ok === false ? '✗' : '✓'}`
     }
-    await this.flush()
+    // Serialize: subsequent flushes wait for any in-flight sendMessage to
+    // resolve so the second flush sees the assigned messageId and routes to
+    // editMessageText, not a second sendMessage. v0.22.1 fix for fast-tool
+    // double-message regression.
+    const previous = this.flushLock
+    this.flushLock = previous.then(() => this.flush()).catch(() => {})
+    await this.flushLock
   }
 
   /**
@@ -131,7 +146,12 @@ export class ProgressTracker {
       clearTimeout(this.pendingTimer)
       this.pendingTimer = null
     }
-    await this.flush(true)
+    // Serialize through the lock so finalize doesn't race a still-flying
+    // push from the brain. Important for fast tools where end-event flush
+    // and finalize() race the same scratch message edit.
+    const previous = this.flushLock
+    this.flushLock = previous.then(() => this.flush(true)).catch(() => {})
+    await this.flushLock
     this.finalized = true
   }