switchroom 0.18.29 → 0.18.30

package/telegram-plugin/tests/catch-all-forwarded-history.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Outcome regression for the forwarded-message history row (#3300 / #3162).
+ *
+ * SCOPE (honest): this suite pins the PERSISTENCE leg of the end-to-end
+ * chain — `parseForwardOrigin` (#3162) feeding `recordInbound` against the
+ * real bun:sqlite history store. The ROUTING leg (an update reaching the
+ * pipeline at all — the layer where the 2026-07-16 silent drop happened) is
+ * pinned by `catch-all-unhandled-message.test.ts`, which drives the real
+ * production catch-all module on a real grammy composer. Together the two
+ * suites cover the chain; this one alone also passes on pre-#3300 code
+ * because #3162's persistence was always correct — it was simply never
+ * reached for the dropped message.
+ *
+ * Runs under bun (history.ts uses bun:sqlite; gateway.ts itself is a
+ * side-effecting module that cannot be imported into a test).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { mkdtempSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import {
+  initHistory,
+  recordInbound,
+  query as queryHistory,
+  _resetForTests as resetHistory,
+} from '../history.js'
+import { parseForwardOrigin } from '../gateway/forward-origin.js'
+
+let stateDir: string
+
+beforeEach(() => {
+  resetHistory()
+  stateDir = mkdtempSync(join(tmpdir(), 'catch-all-forward-'))
+  initHistory(stateDir, 0) // 0 disables the init-time prune so we can seed cleanly
+})
+
+afterEach(() => {
+  resetHistory()
+  rmSync(stateDir, { recursive: true, force: true })
+})
+
+describe('(a) a forwarded plain-text message records a history row with forwarded_from', () => {
+  it('parses the server-stamped forward_origin and persists forwarded_from', () => {
+    const chat_id = '777'
+    const message_id = 8100
+    // Telegram Bot API 7.0 forward_origin, server-stamped (untrusted body,
+    // trusted attrs) — a plain-text message forwarded from a user.
+    const forwardOrigin = parseForwardOrigin({
+      type: 'user',
+      date: 1_700_000_000,
+      sender_user: { id: 424242, is_bot: false, first_name: 'Ken', last_name: 'Thompson' },
+    })
+    expect(forwardOrigin).toBeDefined()
+    expect(forwardOrigin!.name).toBe('Ken Thompson')
+
+    recordInbound({
+      chat_id,
+      thread_id: null,
+      message_id,
+      user: 'ken',
+      user_id: '777',
+      ts: 1_700_000_100,
+      text: 'here is the brief I forwarded',
+      forwarded_from: forwardOrigin!.name,
+      forwarded_from_type: forwardOrigin!.type,
+      forwarded_from_id: forwardOrigin!.id != null ? String(forwardOrigin!.id) : null,
+    })
+
+    const rows = queryHistory({ chat_id, limit: 10 })
+    expect(rows).toHaveLength(1)
+    const row = rows[0]
+    // A delivered turn is present (the message was NOT dropped) AND carries
+    // forwarded provenance.
+    expect(row.role).toBe('user')
+    expect(row.text).toBe('here is the brief I forwarded')
+    expect(row.forwarded_from).toBe('Ken Thompson')
+    expect(row.forwarded_from_type).toBe('user')
+    expect(row.forwarded_from_id).toBe('424242')
+  })
+
+  it('a non-forwarded message leaves forwarded_from NULL (no false provenance)', () => {
+    const chat_id = '778'
+    // undefined forward_origin → parseForwardOrigin returns undefined.
+    const forwardOrigin = parseForwardOrigin(undefined)
+    expect(forwardOrigin).toBeUndefined()
+
+    recordInbound({
+      chat_id,
+      thread_id: null,
+      message_id: 8200,
+      user: 'ken',
+      user_id: '778',
+      ts: 1_700_000_200,
+      text: 'a normal message',
+      forwarded_from: forwardOrigin ?? null,
+    })
+
+    const rows = queryHistory({ chat_id, limit: 10 })
+    expect(rows).toHaveLength(1)
+    expect(rows[0].forwarded_from).toBeNull()
+  })
+})

package/telegram-plugin/tests/catch-all-unhandled-message.test.ts

@@ -0,0 +1,264 @@
+/**
+ * Regression tests for the terminal catch-all message handler + diagnostic
+ * update tap (#3300).
+ *
+ * THE CLASS OF BUG: the gateway registered ONLY content-specific handlers —
+ * `bot.on('message:text')`, `:photo`, `:document`, … `:paid_media`. grammy
+ * ^1.44 routes `bot.on` as filtering middleware (`on → filter(pred, handler)
+ * → branch(pred, handler, pass)`, verified in grammy/out/composer.js); when
+ * NO registered filter matches an inbound `message`, grammy SILENTLY drops
+ * it — no log, no ack, no history row. Live signature (2026-07-16, klanker
+ * DM): message_id 19090 was allocated between an outbound reply and the next
+ * inbound with ZERO gateway trace while polling stayed healthy.
+ *
+ * THE FIX under test is the REAL production module
+ * (`gateway/unhandled-message.ts`) — the same `installUpdateTap` /
+ * `installUnhandledMessageCatchAll` gateway.ts wires — driven through a real
+ * grammy 1.44 Bot via `bot.handleUpdate`, with a real `bot.on('message:text')`
+ * registered BEFORE the catch-all exactly like the gateway's registration
+ * order. (gateway.ts itself is a side-effecting module that cannot be
+ * imported into a unit test — the extraction into unhandled-message.ts exists
+ * precisely so the registered composer path is testable; a structural suite
+ * below guards that gateway.ts actually wires it in that order.)
+ *
+ * Outcomes asserted:
+ *   (b) an unregistered content type reaches the catch-all, is logged, and
+ *       yields a turn with the placeholder text naming the content type;
+ *   (c) a plain text message is consumed by the specific handler and does
+ *       NOT double-handle in the catch-all;
+ *   service-noise messages (forum topic lifecycle etc.) are logged but do
+ *       NOT become turns;
+ *   the tap observes every update and rate-limits with a suppression summary.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { Bot, type Context } from 'grammy'
+import type { Update } from 'grammy/types'
+import { makeMessageUpdate, resetUpdateCounters } from './update-factory.js'
+import {
+  installUpdateTap,
+  installUnhandledMessageCatchAll,
+  planUnhandledMessage,
+  SERVICE_NOISE_KEYS,
+  TAP_MAX_LINES_PER_MINUTE,
+} from '../gateway/unhandled-message.js'
+
+interface DeliveredTurn {
+  via: 'text' | 'catch-all'
+  text: string
+  update_id: number
+}
+
+/**
+ * Wire a real grammy Bot in the gateway's registration order using the REAL
+ * production install functions: tap first, specific `message:text` handler,
+ * terminal catch-all LAST. `onInbound` records what would flow into
+ * handleInboundCoalesced.
+ */
+function buildHarness() {
+  const delivered: DeliveredTurn[] = []
+  const logLines: string[] = []
+
+  const bot = new Bot('12345:TEST_TOKEN_NOT_REAL')
+  bot.botInfo = {
+    id: 999,
+    is_bot: true,
+    first_name: 'TestBot',
+    username: 'test_bot',
+    can_join_groups: true,
+    can_read_all_group_messages: false,
+    supports_inline_queries: false,
+    can_connect_to_business: false,
+    has_main_web_app: false,
+  }
+
+  // REAL production tap (same call gateway.ts makes).
+  installUpdateTap(bot, line => logLines.push(line))
+
+  // Specific handler — representative of the gateway's message:text
+  // registration, placed BEFORE the catch-all exactly as in gateway.ts.
+  bot.on('message:text', async ctx => {
+    delivered.push({ via: 'text', text: ctx.message.text, update_id: ctx.update.update_id })
+  })
+
+  // REAL production catch-all, registered LAST (same call gateway.ts makes).
+  installUnhandledMessageCatchAll(
+    bot,
+    async (ctx: Context, text: string) => {
+      delivered.push({ via: 'catch-all', text, update_id: ctx.update.update_id })
+    },
+    line => logLines.push(line),
+  )
+
+  return { bot, delivered, logLines }
+}
+
+/** A message update carrying content that no `message:*` filter covers. */
+function makeContentUpdate(update_id: number, content: Record<string, unknown>): Update {
+  return {
+    update_id,
+    message: {
+      message_id: 5000 + update_id,
+      chat: { id: 777, type: 'private' },
+      from: { id: 777, is_bot: false, first_name: 'Test' },
+      date: Math.floor(Date.now() / 1000),
+      ...content,
+    },
+  } as unknown as Update
+}
+
+describe('terminal catch-all — real module on a real grammy 1.44 composer (#3300)', () => {
+  beforeEach(() => resetUpdateCounters())
+
+  it('(c) a plain-text message is consumed by message:text and does NOT reach the catch-all', async () => {
+    const { bot, delivered, logLines } = buildHarness()
+    await bot.handleUpdate(makeMessageUpdate({ text: 'hello brief', update_id: 42 }))
+
+    expect(delivered).toHaveLength(1)
+    expect(delivered[0]).toMatchObject({ via: 'text', text: 'hello brief' })
+    // No catch-all log line — specific handler won (no double-handling).
+    expect(logLines.filter(l => l.includes('catch-all inbound'))).toHaveLength(0)
+  })
+
+  it('(b) an unregistered content type reaches the catch-all, is logged, and yields a placeholder turn', async () => {
+    const { bot, delivered, logLines } = buildHarness()
+    await bot.handleUpdate(makeContentUpdate(99, { unknown_future_type: { some: 'payload' } }))
+
+    // Logged with content KEYS + ids only (never the payload body).
+    const catchAllLines = logLines.filter(l => l.includes('catch-all inbound'))
+    expect(catchAllLines).toHaveLength(1)
+    expect(catchAllLines[0]).toContain('update_id=99')
+    expect(catchAllLines[0]).toContain('content_keys=[unknown_future_type]')
+    expect(catchAllLines[0]).not.toContain('payload')
+
+    // Produced a delivered turn with placeholder text naming the content type.
+    expect(delivered).toHaveLength(1)
+    expect(delivered[0]).toMatchObject({
+      via: 'catch-all',
+      text: '(unhandled message content: unknown_future_type)',
+    })
+  })
+
+  it('a caption on an unhandled content type is used as the turn text (best-effort)', async () => {
+    const { bot, delivered } = buildHarness()
+    await bot.handleUpdate(
+      makeContentUpdate(120, { some_new_media: { id: 'x' }, caption: 'read this brief' }),
+    )
+    expect(delivered).toHaveLength(1)
+    expect(delivered[0]).toMatchObject({ via: 'catch-all', text: 'read this brief' })
+  })
+
+  it('known-noise service messages are LOGGED but produce NO agent turn', async () => {
+    const { bot, delivered, logLines } = buildHarness()
+    await bot.handleUpdate(
+      makeContentUpdate(130, { forum_topic_created: { name: 'spam topic', icon_color: 1 } }),
+    )
+    await bot.handleUpdate(
+      makeContentUpdate(131, { new_chat_members: [{ id: 5, is_bot: false, first_name: 'X' }] }),
+    )
+
+    // No turns delivered — service noise never reaches the agent.
+    expect(delivered).toHaveLength(0)
+    // But both were explicitly logged (never silently dropped).
+    const noiseLines = logLines.filter(l => l.includes('action=log-only'))
+    expect(noiseLines).toHaveLength(2)
+    expect(noiseLines[0]).toContain('content_keys=[forum_topic_created]')
+    expect(noiseLines[1]).toContain('content_keys=[new_chat_members]')
+  })
+
+  it('the diagnostic tap observes EVERY update (pass-through, both routed and caught)', async () => {
+    const { bot, logLines } = buildHarness()
+    await bot.handleUpdate(makeMessageUpdate({ text: 'routed', update_id: 1 }))
+    await bot.handleUpdate(makeContentUpdate(2, { unknown_future_type: {} }))
+
+    const rx = logLines.filter(l => l.includes('rx update_id='))
+    expect(rx).toHaveLength(2)
+    expect(rx[0]).toContain('rx update_id=1 type=message')
+    expect(rx[1]).toContain('rx update_id=2 type=message')
+  })
+})
+
+describe('planUnhandledMessage — service-noise classification', () => {
+  it('every SERVICE_NOISE_KEYS entry classifies log-only', () => {
+    for (const key of SERVICE_NOISE_KEYS) {
+      const plan = planUnhandledMessage({ message_id: 1, chat: {}, date: 0, [key]: {} })
+      expect(plan.action, `key ${key} should be log-only`).toBe('log-only')
+    }
+  })
+
+  it('an unknown content type classifies as a turn (fail-toward-delivery)', () => {
+    const plan = planUnhandledMessage({ message_id: 1, chat: {}, date: 0, mystery_type: {} })
+    expect(plan).toMatchObject({
+      action: 'turn',
+      text: '(unhandled message content: mystery_type)',
+    })
+  })
+
+  it('a message mixing noise with real content still becomes a turn', () => {
+    const plan = planUnhandledMessage({
+      message_id: 1, chat: {}, date: 0,
+      boost_added: {}, mystery_media: {}, caption: 'look',
+    })
+    expect(plan).toMatchObject({ action: 'turn', text: 'look' })
+  })
+})
+
+describe('installUpdateTap — rate limit', () => {
+  it('caps lines per minute and emits ONE suppression summary on window rollover', async () => {
+    const logLines: string[] = []
+    let now = 1_000_000
+    const mw: Array<(ctx: unknown, next: () => Promise<void>) => Promise<void>> = []
+    const fakeBot = { use: (fn: (ctx: unknown, next: () => Promise<void>) => Promise<void>) => { mw.push(fn) } }
+    installUpdateTap(fakeBot as never, l => logLines.push(l), () => now)
+
+    const fire = (update_id: number) =>
+      mw[0]({ update: { update_id }, message: undefined } as never, async () => {})
+
+    for (let i = 0; i < TAP_MAX_LINES_PER_MINUTE + 50; i++) await fire(i)
+    expect(logLines.filter(l => l.includes('rx update_id='))).toHaveLength(TAP_MAX_LINES_PER_MINUTE)
+
+    // Roll the window: the 50 suppressed lines surface as ONE summary.
+    now += 61_000
+    await fire(9999)
+    const summaries = logLines.filter(l => l.includes('suppressed 50 update lines'))
+    expect(summaries).toHaveLength(1)
+    // And logging resumes in the fresh window.
+    expect(logLines.filter(l => l.includes('rx update_id=9999'))).toHaveLength(1)
+  })
+})
+
+// ─── Structural guard on the real gateway.ts wiring ────────────────────────
+// The functional harness above proves the composer contract using the REAL
+// production install functions; this guards that gateway.ts wires those same
+// functions in the required order. Hardened beyond a naive regex: it fails
+// if the install call disappears (e.g. refactored away) OR if ANY
+// `bot.on('message…')` registration appears after the catch-all install.
+describe('gateway.ts catch-all registration invariant', () => {
+  const SRC = readFileSync(new URL('../gateway/gateway.ts', import.meta.url), 'utf8')
+
+  it('imports and installs the real catch-all + tap from unhandled-message.ts', () => {
+    expect(SRC).toContain("from './unhandled-message.js'")
+    expect(SRC).toContain('installUpdateTap(bot,')
+    expect(SRC).toContain('installUnhandledMessageCatchAll(')
+  })
+
+  it('the catch-all install is AFTER every message handler registration', () => {
+    const installIdx = SRC.indexOf('installUnhandledMessageCatchAll(')
+    expect(installIdx).toBeGreaterThan(0)
+    const after = SRC.slice(installIdx)
+    // No message-filter registration of any spelling may follow the terminal
+    // catch-all — grammy ordering is the no-double-handling guarantee.
+    // (`message_reaction` etc. are DIFFERENT update types, not `message`
+    // filters — the pattern requires `message` exactly or `message:<sub>`.)
+    expect(after).not.toMatch(/bot\.on\(\s*['"`]message(:|['"`])/)
+    // And there must be exactly one catch-all install (no duplicate turns).
+    expect(SRC.indexOf('installUnhandledMessageCatchAll(', installIdx + 1)).toBe(-1)
+  })
+
+  it('routes the catch-all through handleInboundCoalesced (same gating + forward-origin path)', () => {
+    const installIdx = SRC.indexOf('installUnhandledMessageCatchAll(')
+    const body = SRC.slice(installIdx, installIdx + 400)
+    expect(body).toMatch(/handleInboundCoalesced\(ctx, text, undefined\)/)
+  })
+})

package/telegram-plugin/tests/gateway-session-model-relaunch.test.ts

@@ -149,7 +149,7 @@ describe('gateway boot: session-model re-hydration + confirmation + alert relay'
   it('sends ONE switch-confirmation from the ACTUAL launched model, keyed on the /model reason (F1/N4)', () => {
     const idx = GATEWAY_SRC.indexOf('const isApplyBoot = launched.length > 0')
     expect(idx).toBeGreaterThan(0)
-    const win = GATEWAY_SRC.slice(idx, idx + 3400)
+    const win = GATEWAY_SRC.slice(idx, idx + 5200)
     // Keyed on the deterministic /model switch reason, so it also fires on a
     // launched===configured apply-boot (/model default) — N4. Never optimistic.
     expect(win).toContain('if (modelSwitchReason != null && modelSwitchMarkerChat)')
@@ -158,6 +158,30 @@ describe('gateway boot: session-model re-hydration + confirmation + alert relay'
     expect(win).toContain('(the configured default)')
   })
 
+  it('warns instead of a green ✅ when a non-default switch silently reverted to the default (silent-revert fix)', () => {
+    const idx = GATEWAY_SRC.indexOf('const isApplyBoot = launched.length > 0')
+    const win = GATEWAY_SRC.slice(idx, idx + 5200)
+    // The confirmation card is derived from the pure classifier, not an inline
+    // isApplyBoot ternary — so a reverted non-default switch yields the ⚠️ card.
+    expect(win).toContain('classifyModelSwitchConfirmation({')
+    expect(win).toContain("confirmation.kind === 'applied'")
+    expect(win).toContain("confirmation.kind === 'not-applied'")
+    expect(win).toContain("⚠️ Your switch to")
+    expect(win).toContain("didn't apply")
+    // LOW-3: the re-issue hint interpolates the target inside backticks so a
+    // token containing Markdown metachars can't italicize / 400 the send.
+    expect(win).toContain('Re-issue \\`/model ${confirmation.target}\\`')
+  })
+
+  it('dedups the not-applied card against a tailored .session-model-alert (LOW-2)', () => {
+    const idx = GATEWAY_SRC.indexOf('const isApplyBoot = launched.length > 0')
+    const win = GATEWAY_SRC.slice(idx, idx + 5200)
+    // When start.sh wrote a specific alert for this revert, the classifier's
+    // generic not-applied card is suppressed (the alert relay is the message).
+    expect(win).toContain("existsSync(join(smAgentDir, '.session-model-alert'))")
+    expect(win).toContain("confirmation.kind === 'not-applied' && hasSessionModelAlert")
+  })
+
   it('N4/reason: the /model switch reason is captured from the clean-shutdown marker', () => {
     expect(GATEWAY_SRC).toContain("cleanMarker.reason.startsWith('user: /model')")
     expect(GATEWAY_SRC).toContain('let modelSwitchReason: string | null = null')
@@ -172,7 +196,7 @@ describe('gateway boot: session-model re-hydration + confirmation + alert relay'
   })
 
   it('consumes the .session-model-alert sentinel, notifies ALL operators, and deletes it', () => {
-    const idx = GATEWAY_SRC.indexOf("join(smAgentDir, '.session-model-alert')")
+    const idx = GATEWAY_SRC.indexOf("const alertPath = join(smAgentDir, '.session-model-alert')")
     expect(idx).toBeGreaterThan(0)
     const win = GATEWAY_SRC.slice(idx, idx + 1100)
     expect(win).toContain('unlinkSync(alertPath)')