switchroom 0.5.0

package/telegram-plugin/tests/status-accent.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Tests for the inline status-accent header feature (issue #320 fallback).
+ *
+ * Covers both the pure `buildAccentHeader` helper and the integration paths
+ * through `handleStreamReply` (stream_reply) and the server reply case
+ * (exercised via the handler directly since server.ts wires it the same way).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { buildAccentHeader, handleStreamReply, type StreamReplyDeps, type StreamReplyState } from '../stream-reply-handler.js'
+import type { DraftStreamHandle } from '../draft-stream.js'
+import { createMockBot, installBotResetHook, microtaskFlush } from './bot-api.harness.js'
+
+// ─── buildAccentHeader unit tests ────────────────────────────────────────────
+
+describe('buildAccentHeader', () => {
+  it("'in-progress' returns the blue circle header", () => {
+    expect(buildAccentHeader('in-progress')).toBe('🔵 <i>In progress…</i>\n\n')
+  })
+
+  it("'done' returns the checkmark header", () => {
+    expect(buildAccentHeader('done')).toBe('✅ <b>Done</b>\n\n')
+  })
+
+  it("'issue' returns the warning header", () => {
+    expect(buildAccentHeader('issue')).toBe('⚠️ <b>Issue</b>\n\n')
+  })
+
+  it('undefined returns empty string (no header)', () => {
+    expect(buildAccentHeader(undefined)).toBe('')
+  })
+
+  it('invalid / unrecognised value is silently ignored (returns empty string)', () => {
+    expect(buildAccentHeader('unknown')).toBe('')
+    expect(buildAccentHeader('')).toBe('')
+    expect(buildAccentHeader('DONE')).toBe('')
+  })
+})
+
+// ─── handleStreamReply integration tests ─────────────────────────────────────
+
+function makeState(): StreamReplyState {
+  return {
+    activeDraftStreams: new Map<string, DraftStreamHandle>(),
+    activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+  }
+}
+
+function makeDeps(
+  bot: ReturnType<typeof createMockBot>,
+  overrides?: Partial<StreamReplyDeps>,
+): StreamReplyDeps {
+  return {
+    bot,
+    markdownToHtml: (t) => `<b>${t}</b>`,
+    escapeMarkdownV2: (t) => `\\${t}\\`,
+    repairEscapedWhitespace: (t) => t,
+    takeHandoffPrefix: () => '',
+    assertAllowedChat: () => {},
+    resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
+    disableLinkPreview: true,
+    defaultFormat: 'html',
+    logStreamingEvent: () => {},
+    endStatusReaction: () => {},
+    historyEnabled: false,
+    recordOutbound: () => {},
+    writeError: () => {},
+    throttleMs: 600,
+    ...overrides,
+  }
+}
+
+describe('handleStreamReply accent integration', () => {
+  const bot = createMockBot()
+  installBotResetHook(bot)
+
+  beforeEach(() => vi.useFakeTimers())
+  afterEach(() => vi.useRealTimers())
+
+  it("accent='in-progress' prepends the blue-circle header before the body", async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Still working...', accent: 'in-progress' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    const sent = bot.api.sendMessage.mock.calls[0][1] as string
+    expect(sent).toMatch(/^🔵 <i>In progress…<\/i>\n\n/)
+    expect(sent).toBe('🔵 <i>In progress…</i>\n\n<b>Still working...</b>')
+  })
+
+  it("accent='done' prepends the checkmark header before the body", async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Task complete.', accent: 'done' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    const sent = bot.api.sendMessage.mock.calls[0][1] as string
+    expect(sent).toBe('✅ <b>Done</b>\n\n<b>Task complete.</b>')
+  })
+
+  it("accent='issue' prepends the warning header before the body", async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Blocked on X.', accent: 'issue' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    const sent = bot.api.sendMessage.mock.calls[0][1] as string
+    expect(sent).toBe('⚠️ <b>Issue</b>\n\n<b>Blocked on X.</b>')
+  })
+
+  it('no accent — output is unchanged from today (regression guard)', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Hello world' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    const sent = bot.api.sendMessage.mock.calls[0][1] as string
+    expect(sent).toBe('<b>Hello world</b>')
+  })
+
+  it('invalid accent is silently ignored — output equals no-accent path', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Hello world', accent: 'rainbow' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    const sent = bot.api.sendMessage.mock.calls[0][1] as string
+    expect(sent).toBe('<b>Hello world</b>')
+  })
+
+  it('accent header is included on every call that passes it (full-text replace model)', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    // First call
+    const p1 = handleStreamReply(
+      { chat_id: '1', text: 'Part one', accent: 'in-progress' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await p1
+
+    // Second call — same turn, same accent
+    vi.advanceTimersByTime(1000)
+    const p2 = handleStreamReply(
+      { chat_id: '1', text: 'Part one Part two', accent: 'in-progress' },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await p2
+
+    const edited = bot.api.editMessageText.mock.calls[0][2] as string
+    expect(edited).toBe('🔵 <i>In progress…</i>\n\n<b>Part one Part two</b>')
+  })
+})

package/telegram-plugin/tests/status-reactions-allowed-filter.test.ts

@@ -0,0 +1,132 @@
+/**
+ * StatusReactionController — allowedReactions filter (#542 fix path).
+ *
+ * Background: Telegram supergroups can restrict `available_reactions`
+ * to a small set. When the bot calls `setMessageReaction` with an
+ * emoji outside that set, Telegram returns 400 REACTION_INVALID.
+ * Production silently catches and continues — only the emojis that
+ * happen to be in the allowed set ever land. Result: the user sees
+ * `👀 → 👍` instead of `👀 → 🤔 → 🔥 → 👍`.
+ *
+ * The controller has fallback logic in `resolveEmoji` for exactly
+ * this case — but it was DEAD CODE because gateway.ts:4458 didn't
+ * pass `allowedReactions`. The fix wires `chatAvailableReactions`
+ * cache (populated by getChat probe) into the controller constructor.
+ *
+ * These tests pin the controller's behavior under the filter so the
+ * dead-code path stops being dead.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { StatusReactionController } from '../status-reactions.js'
+
+describe('StatusReactionController — allowedReactions filter', () => {
+  it('with no filter (null), every state emits its preferred emoji', async () => {
+    const emits: string[] = []
+    const ctrl = new StatusReactionController(
+      async (emoji) => { emits.push(emoji) },
+      null, // no filter — current production default before #542 fix
+      { debounceMs: 0 },
+    )
+    ctrl.setQueued()
+    ctrl.setThinking()
+    ctrl.setTool('Bash')
+    ctrl.setDone()
+    // Drain any queued emits.
+    await new Promise((r) => setTimeout(r, 10))
+    expect(emits).toContain('👀')
+    expect(emits[emits.length - 1]).toBe('👍')
+  })
+
+  it('with allowedReactions=[👍], non-allowed states fall back to a permitted emoji', async () => {
+    // The #542 reproducer: chat only allows 👍. With the filter wired,
+    // resolveEmoji's fallback path activates: it walks REACTION_VARIANTS
+    // for each state, skipping anything not in allowedReactions, and
+    // falls through to the last-resort set ['👍', '👀', '✍'].
+    //
+    // fails when: someone removes the fallback in resolveEmoji, or the
+    // controller stops respecting the filter. Either way the user
+    // would see emojis Telegram is going to reject.
+    const emits: string[] = []
+    const ctrl = new StatusReactionController(
+      async (emoji) => { emits.push(emoji) },
+      new Set(['👍']),
+      { debounceMs: 0 },
+    )
+    ctrl.setQueued()
+    ctrl.setThinking()
+    ctrl.setTool('Bash')
+    ctrl.setDone()
+    await new Promise((r) => setTimeout(r, 10))
+
+    // Every emit must be 👍 — no 👀/🤔/🔥 should slip through to a chat
+    // that doesn't allow them. The chain may collapse to a single 👍
+    // (the controller dedups consecutive same-emoji emits).
+    for (const emoji of emits) {
+      expect(emoji).toBe('👍')
+    }
+    expect(emits).toContain('👍') // and at least one 👍 lands
+  })
+
+  it('with allowedReactions=[👀, 👍], intermediate states use 👀 fallback', async () => {
+    // A chat allowing only 👀 + 👍. Intermediates that are normally
+    // 🤔 / 🔥 should fall back to 👀 (the only intermediate-class
+    // emoji in the allowed set), and terminal stays 👍.
+    const emits: string[] = []
+    const ctrl = new StatusReactionController(
+      async (emoji) => { emits.push(emoji) },
+      new Set(['👀', '👍']),
+      { debounceMs: 0 },
+    )
+    ctrl.setQueued()
+    ctrl.setThinking()
+    ctrl.setTool('Bash')
+    ctrl.setDone()
+    await new Promise((r) => setTimeout(r, 10))
+
+    for (const emoji of emits) {
+      expect(['👀', '👍']).toContain(emoji)
+    }
+    expect(emits[emits.length - 1]).toBe('👍')
+  })
+
+  it('with allowedReactions=[] (empty set, no reactions allowed), emits are no-ops', async () => {
+    // Edge case: chat has explicitly EMPTY available_reactions
+    // (extremely rare — e.g., admin set "no reactions allowed").
+    // resolveEmoji returns null for every state; the controller
+    // chain skips emit. No exception, no Telegram call attempt.
+    const emits: string[] = []
+    const ctrl = new StatusReactionController(
+      async (emoji) => { emits.push(emoji) },
+      new Set(),
+      { debounceMs: 0 },
+    )
+    ctrl.setQueued()
+    ctrl.setThinking()
+    ctrl.setDone()
+    await new Promise((r) => setTimeout(r, 10))
+    expect(emits).toEqual([])
+  })
+
+  it('with allowedReactions excluding 👍 entirely, terminal falls back to first allowed', async () => {
+    // Bizarre: allow 🎉 only. Terminal 👍 has to fall back to 🎉
+    // (which is in the variants of `done` per REACTION_VARIANTS).
+    // Or fall back to the last-resort set if 🎉 isn't even in
+    // ['👍', '👀', '✍']. Document actual behavior.
+    const emits: string[] = []
+    const ctrl = new StatusReactionController(
+      async (emoji) => { emits.push(emoji) },
+      new Set(['🎉']),
+      { debounceMs: 0 },
+    )
+    ctrl.setDone()
+    await new Promise((r) => setTimeout(r, 10))
+    // Either 🎉 (if it's a `done` variant) or empty (if no allowed
+    // emoji matches any `done` variant or the last-resort set).
+    // Pin actual behavior — current REACTION_VARIANTS for `done`
+    // determines this.
+    if (emits.length > 0) {
+      expect(emits[0]).toBe('🎉')
+    }
+  })
+})

package/telegram-plugin/tests/status-reactions.test.ts

@@ -0,0 +1,314 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  StatusReactionController,
+  resolveToolReactionState,
+  REACTION_VARIANTS,
+  TELEGRAM_REACTION_WHITELIST,
+} from '../status-reactions.js'
+
+function makeEmitter() {
+  const calls: string[] = []
+  const emit = vi.fn(async (emoji: string) => {
+    calls.push(emoji)
+  })
+  return { emit, calls }
+}
+
+async function flush() {
+  // Drain the microtask queue (chainPromise.then callbacks). Cannot use
+  // setTimeout here because vi.useFakeTimers() would freeze it.
+  for (let i = 0; i < 8; i++) {
+    await Promise.resolve()
+  }
+}
+
+describe('resolveToolReactionState', () => {
+  it('maps shell-class tools to coding', () => {
+    expect(resolveToolReactionState('Bash')).toBe('coding')
+    expect(resolveToolReactionState('exec_command')).toBe('coding')
+    expect(resolveToolReactionState('shell_run')).toBe('coding')
+  })
+
+  it('maps file-class tools to coding', () => {
+    expect(resolveToolReactionState('Read')).toBe('coding')
+    expect(resolveToolReactionState('Write')).toBe('coding')
+    expect(resolveToolReactionState('Edit')).toBe('coding')
+    expect(resolveToolReactionState('MultiEdit')).toBe('coding')
+    expect(resolveToolReactionState('Glob')).toBe('coding')
+    expect(resolveToolReactionState('Grep')).toBe('coding')
+  })
+
+  it('maps web-class tools to web', () => {
+    expect(resolveToolReactionState('WebFetch')).toBe('web')
+    expect(resolveToolReactionState('WebSearch')).toBe('web')
+    expect(resolveToolReactionState('browser_navigate')).toBe('web')
+  })
+
+  it('falls back to generic tool for everything else', () => {
+    expect(resolveToolReactionState('mcp__hindsight__remember')).toBe('tool')
+    expect(resolveToolReactionState('TodoCreate')).toBe('tool')
+    // TodoWrite contains "write" so it correctly maps to coding
+    expect(resolveToolReactionState('TodoWrite')).toBe('coding')
+  })
+})
+
+describe('REACTION_VARIANTS', () => {
+  it('every variant in every state is in the Telegram whitelist', () => {
+    for (const [state, variants] of Object.entries(REACTION_VARIANTS)) {
+      for (const v of variants) {
+        expect(TELEGRAM_REACTION_WHITELIST.has(v),
+          `${state} variant "${v}" is not in Telegram's reaction whitelist`,
+        ).toBe(true)
+      }
+    }
+  })
+
+  it('🔥 is not in active-work states (queued/tool/coding/web) — #320', () => {
+    const activeWorkStates = ['queued', 'tool', 'coding', 'web'] as const
+    for (const state of activeWorkStates) {
+      expect(REACTION_VARIANTS[state]).not.toContain('🔥')
+    }
+  })
+
+  it('done includes at least one positive completion emoji (👍 or 💯)', () => {
+    const done = REACTION_VARIANTS['done']
+    const hasPositive = done.includes('👍') || done.includes('💯')
+    expect(hasPositive).toBe(true)
+  })
+})
+
+describe('StatusReactionController', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('setQueued emits the queued emoji immediately', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+    expect(calls).toEqual(['👀'])
+  })
+
+  it('setThinking is debounced by 700ms', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+    expect(calls).toEqual(['👀'])
+
+    ctrl.setThinking()
+    await flush()
+    // Not yet — debounce window
+    expect(calls).toEqual(['👀'])
+
+    vi.advanceTimersByTime(700)
+    await flush()
+    expect(calls).toEqual(['👀', '🤔'])
+  })
+
+  it('rapid intermediate transitions only emit the last one (coalesces)', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    // Simulate model flashing thinking → tool → thinking → coding within 200ms
+    ctrl.setThinking()
+    vi.advanceTimersByTime(100)
+    ctrl.setTool('Bash')
+    vi.advanceTimersByTime(100)
+    ctrl.setThinking()
+    vi.advanceTimersByTime(100)
+    ctrl.setTool('Read')
+    await flush()
+
+    // Still nothing — debounce hasn't elapsed
+    expect(calls).toEqual(['👀'])
+
+    vi.advanceTimersByTime(700)
+    await flush()
+    // Only the final state lands (Read → coding 👨‍💻)
+    expect(calls).toEqual(['👀', '👨‍💻'])
+  })
+
+  it('setDone is terminal and bypasses debounce', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    ctrl.setDone()
+    await flush()
+    expect(calls).toEqual(['👀', '👍'])
+
+    // Subsequent calls are no-ops
+    ctrl.setThinking()
+    vi.advanceTimersByTime(5000)
+    await flush()
+    expect(calls).toEqual(['👀', '👍'])
+  })
+
+  it('setError is terminal', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    ctrl.setError()
+    await flush()
+    expect(calls).toEqual(['👀', '😱'])
+
+    ctrl.setThinking()
+    vi.advanceTimersByTime(5000)
+    await flush()
+    expect(calls).toEqual(['👀', '😱'])
+  })
+
+  it('issue #132: setSilent is terminal and uses 🙊 (distinct from 👍 done)', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+    ctrl.setTool('Bash')
+    vi.advanceTimersByTime(800)
+    await flush()
+
+    // Turn ends without producing a reply.
+    ctrl.setSilent()
+    await flush()
+    // 🙊 is in the Telegram bot reaction whitelist (speak-no-evil monkey).
+    // The choice signals "agent ran tools but said nothing" — distinct
+    // from 👍 which the user reads as "agent acknowledged with a reply".
+    // setTool('Bash') resolves to the 'coding' state → 👨‍💻 (first variant).
+    expect(calls).toEqual(['👀', '👨‍💻', '🙊'])
+
+    // Subsequent calls are no-ops (terminal).
+    ctrl.setThinking()
+    vi.advanceTimersByTime(5000)
+    await flush()
+    expect(calls).toEqual(['👀', '👨‍💻', '🙊'])
+  })
+
+  it('promotes to stallSoft after 30s of no progress', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    // No further calls — stall watchdog should fire at 30s
+    vi.advanceTimersByTime(30000)
+    await flush()
+    expect(calls).toContain('🥱')
+  })
+
+  it('promotes to stallHard after 90s of no progress', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    vi.advanceTimersByTime(30000) // stallSoft
+    await flush()
+    vi.advanceTimersByTime(60000) // total 90s → stallHard
+    await flush()
+    expect(calls).toContain('😨')
+  })
+
+  it('progress signals reset the stall timer', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    // Tick 25s, then signal progress
+    vi.advanceTimersByTime(25000)
+    ctrl.setThinking() // resets stall timers
+    vi.advanceTimersByTime(800)
+    await flush()
+    // We should have queued + thinking, but no stall yet
+    expect(calls).toEqual(['👀', '🤔'])
+
+    // Now wait another 20s (total 45s since queued, but only 20s since thinking)
+    vi.advanceTimersByTime(20000)
+    await flush()
+    // Still no stall — the tick reset the watchdog
+    expect(calls).toEqual(['👀', '🤔'])
+  })
+
+  it('cancel stops further reactions silently', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+
+    ctrl.cancel()
+    ctrl.setThinking()
+    vi.advanceTimersByTime(5000)
+    await flush()
+    // Only the queued emoji landed; thinking was suppressed
+    expect(calls).toEqual(['👀'])
+  })
+
+  it('skips emoji not in the chat allowed set', async () => {
+    const { emit, calls } = makeEmitter()
+    // This chat only allows 👍 and 🔥
+    const allowed = new Set(['👍', '🔥'])
+    const ctrl = new StatusReactionController(emit, allowed)
+
+    ctrl.setQueued() // wants 👀, then 🤔, then 🤓 — none allowed; broad fallback picks 👍
+    await flush()
+    // 👀, 🤔, 🤓 — none in allowed; broad fallback hits 👍 → 👍
+    expect(calls).toEqual(['👍'])
+
+    ctrl.setThinking() // wants 🤔, falls back through variants, then generic — none in allowed
+    vi.advanceTimersByTime(700)
+    await flush()
+    // 🤔, 🤓, 👀 — none allowed; broad fallback hits 👍 but it's already current → no emit
+    expect(calls).toEqual(['👍'])
+  })
+
+  it('serializes API calls through the chain promise', async () => {
+    let resolveFirst: () => void = () => {}
+    const firstPromise = new Promise<void>(r => (resolveFirst = r))
+    const order: string[] = []
+
+    const emit = vi.fn(async (emoji: string) => {
+      if (emoji === '👀') {
+        await firstPromise
+      }
+      order.push(emoji)
+    })
+
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued() // immediate
+    await flush()
+    // First call is in flight, blocked on firstPromise
+
+    ctrl.setDone() // also immediate (terminal)
+    await flush()
+
+    // The done call should be queued behind the in-flight queued call
+    expect(order).toEqual([])
+
+    resolveFirst()
+    await flush()
+    expect(order).toEqual(['👀', '👍'])
+  })
+
+  it('does not re-emit the same emoji', async () => {
+    const { emit, calls } = makeEmitter()
+    const ctrl = new StatusReactionController(emit)
+    ctrl.setQueued()
+    await flush()
+    ctrl.setQueued()
+    await flush()
+    ctrl.setQueued()
+    await flush()
+    expect(calls).toEqual(['👀'])
+  })
+})