@s0nderlabs/anima-plugin-telegram 0.22.0 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@s0nderlabs/anima-plugin-telegram",
-  "version": "0.22.0",
+  "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.22.0",
+    "@s0nderlabs/anima-core": "0.22.1",
     "grammy": "^1.42.0",
     "zod": "^3.23.8"
   }

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
   }