switchroom 0.17.6 → 0.17.10

package/telegram-plugin/tests/permission-ledger.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Unit tests for the bridge-side outstanding permission-request ledger
+ * (#2861 / #2859).
+ *
+ * The ledger is the primitive that closes R2 (bridge dropped permission
+ * requests while the gateway IPC was down). bridge.ts wires it as:
+ *   - permission_request notification → ledger.add(params) (BEFORE the
+ *     connect check), then send if connected else buffer.
+ *   - onPermission (verdict delivered) → ledger.delete(requestId).
+ *   - onConnect (IPC (re)connect) → re-send ledger.all().
+ *
+ * bridge.ts has top-level side effects and isn't unit-importable, so here we
+ * (a) unit-test the ledger primitive directly and (b) drive a faithful
+ * re-implementation of the three wiring points against a fake IPC to prove the
+ * buffer / re-send / delete behaviours. The source wiring itself is pinned in
+ * permission-rearm-wiring.test.ts.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  createOutstandingPermissionLedger,
+  type OutstandingPermissionParams,
+} from '../bridge/permission-ledger.js'
+
+function params(requestId: string, tool = 'mcp__brevo__post'): OutstandingPermissionParams {
+  return {
+    request_id: requestId,
+    tool_name: tool,
+    description: `${tool} description`,
+    input_preview: '{"foo":"bar"}',
+  }
+}
+
+describe('createOutstandingPermissionLedger', () => {
+  it('starts empty', () => {
+    const led = createOutstandingPermissionLedger()
+    expect(led.size).toBe(0)
+    expect(led.all()).toEqual([])
+  })
+
+  it('add + all + has', () => {
+    const led = createOutstandingPermissionLedger()
+    led.add(params('aaaaa'))
+    led.add(params('bbbbb'))
+    expect(led.size).toBe(2)
+    expect(led.has('aaaaa')).toBe(true)
+    expect(led.has('zzzzz')).toBe(false)
+    expect(led.all().map(p => p.request_id)).toEqual(['aaaaa', 'bbbbb'])
+  })
+
+  it('add is idempotent on request_id (latest params win)', () => {
+    const led = createOutstandingPermissionLedger()
+    led.add(params('aaaaa', 'mcp__brevo__post'))
+    led.add(params('aaaaa', 'mcp__brevo__patch'))
+    expect(led.size).toBe(1)
+    expect(led.all()[0].tool_name).toBe('mcp__brevo__patch')
+  })
+
+  it('delete removes the entry (verdict delivered)', () => {
+    const led = createOutstandingPermissionLedger()
+    led.add(params('aaaaa'))
+    led.delete('aaaaa')
+    expect(led.size).toBe(0)
+    expect(led.has('aaaaa')).toBe(false)
+  })
+
+  it('delete of an unknown id is a no-op', () => {
+    const led = createOutstandingPermissionLedger()
+    led.add(params('aaaaa'))
+    led.delete('nope')
+    expect(led.size).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Faithful re-implementation of the three bridge wiring points. Mirrors
+// bridge.ts exactly so the buffer / re-send / delete contract is exercised
+// without importing the side-effecting module.
+// ---------------------------------------------------------------------------
+
+interface FakeIpc {
+  connected: boolean
+  sent: Array<{ requestId: string }>
+}
+
+function makeHarness(rearmEnabled = true) {
+  const ledger = createOutstandingPermissionLedger()
+  const ipc: FakeIpc = { connected: false, sent: [] }
+
+  // Mirrors the permission_request notification handler.
+  function onPermissionRequest(p: OutstandingPermissionParams): void {
+    if (rearmEnabled) ledger.add(p)
+    if (!ipc.connected) {
+      // BUFFER (not drop) when re-arm enabled.
+      return
+    }
+    ipc.sent.push({ requestId: p.request_id })
+  }
+
+  // Mirrors onPermission (verdict delivered).
+  function onVerdict(requestId: string): void {
+    ledger.delete(requestId)
+  }
+
+  // Mirrors flushOutstandingPermissionRequests on onConnect.
+  function onConnect(): void {
+    ipc.connected = true
+    if (!rearmEnabled) return
+    for (const p of ledger.all()) ipc.sent.push({ requestId: p.request_id })
+  }
+
+  function disconnect(): void {
+    ipc.connected = false
+  }
+
+  return { ledger, ipc, onPermissionRequest, onVerdict, onConnect, disconnect }
+}
+
+describe('bridge permission-request wiring (buffer / re-send / delete)', () => {
+  it('buffers when disconnected — no drop, request retained', () => {
+    const h = makeHarness()
+    h.onPermissionRequest(params('aaaaa'))
+    // Nothing sent (gateway down) but the ledger retained it.
+    expect(h.ipc.sent).toEqual([])
+    expect(h.ledger.has('aaaaa')).toBe(true)
+  })
+
+  it('re-sends every outstanding request on (re)connect', () => {
+    const h = makeHarness()
+    h.onPermissionRequest(params('aaaaa'))
+    h.onPermissionRequest(params('bbbbb'))
+    expect(h.ipc.sent).toEqual([]) // still down
+
+    h.onConnect() // gateway comes up
+    expect(h.ipc.sent.map(s => s.requestId).sort()).toEqual(['aaaaa', 'bbbbb'])
+  })
+
+  it('re-sends again after a disconnect/reconnect cycle (gateway restart)', () => {
+    const h = makeHarness()
+    h.onConnect() // connected
+    h.onPermissionRequest(params('aaaaa')) // sent live
+    expect(h.ipc.sent.map(s => s.requestId)).toEqual(['aaaaa'])
+
+    h.disconnect() // gateway restarts
+    h.onConnect() // reconnect → re-send outstanding
+    expect(h.ipc.sent.map(s => s.requestId)).toEqual(['aaaaa', 'aaaaa'])
+  })
+
+  it('a delivered verdict removes the entry — no re-send after resolution', () => {
+    const h = makeHarness()
+    h.onPermissionRequest(params('aaaaa'))
+    h.onVerdict('aaaaa') // operator tapped, verdict delivered
+    expect(h.ledger.has('aaaaa')).toBe(false)
+
+    h.onConnect() // reconnect
+    expect(h.ipc.sent).toEqual([]) // nothing re-sent
+  })
+
+  it('kill switch: disabled → drop-when-disconnected, no ledger, no re-send', () => {
+    const h = makeHarness(false)
+    h.onPermissionRequest(params('aaaaa')) // disconnected → dropped, not recorded
+    expect(h.ledger.size).toBe(0)
+    h.onConnect()
+    expect(h.ipc.sent).toEqual([]) // nothing to re-send
+  })
+})

package/telegram-plugin/tests/permission-no-repeat-wiring.test.ts

@@ -58,7 +58,7 @@ describe('no-repeat-on-timeout wiring', () => {
   })
 
   it('onPermissionRequest short-circuits a recent-timeout duplicate before posting a card', () => {
-    const fn = slice(GATEWAY, 'onPermissionRequest(', 4000)
+    const fn = slice(GATEWAY, 'onPermissionRequest(', 6000)
     const dupIdx = fn.indexOf('isRecentTimeoutDuplicate(')
     const cardIdx = fn.indexOf('pendingPermissions.set(requestId')
     expect(dupIdx).toBeGreaterThan(-1)

package/telegram-plugin/tests/permission-rearm-wiring.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Source-text wiring pins for the approval-card re-arm feature (#2861 / #2859).
+ *
+ * gateway.ts and bridge.ts have top-level side effects and aren't
+ * unit-importable; the decision logic is unit-tested in permission-rearm.test.ts
+ * and permission-ledger.test.ts. These pins lock the wiring that connects those
+ * primitives so the two failure modes can't silently regress:
+ *   R1 — gateway restart orphans pending approvals (boot-sweep stripped them).
+ *   R2 — bridge dropped permission requests while the gateway IPC was down.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const read = (p: string) => readFileSync(resolve(__dirname, '..', p), 'utf8')
+const GATEWAY = read('gateway/gateway.ts')
+const BRIDGE = read('bridge/bridge.ts')
+const IPC_CLIENT = read('bridge/ipc-client.ts')
+
+function slice(src: string, header: string, span = 2400): string {
+  const start = src.indexOf(header)
+  expect(start, `expected to find ${header}`).toBeGreaterThan(-1)
+  return src.slice(start, start + span)
+}
+
+// ─── Bridge: outstanding-request ledger (R2) ──────────────────────────────
+
+describe('bridge ledger wiring', () => {
+  it('imports and instantiates the outstanding-permission ledger', () => {
+    expect(BRIDGE).toMatch(/from '\.\/permission-ledger\.js'/)
+    expect(BRIDGE).toMatch(/createOutstandingPermissionLedger\(\)/)
+  })
+
+  it('records every permission_request in the ledger BEFORE the connect check', () => {
+    const handler = slice(BRIDGE, "method: z.literal('notifications/claude/channel/permission_request')", 2600)
+    const addIdx = handler.indexOf('outstandingPermissions.add(')
+    const connIdx = handler.indexOf('!ipc.isConnected()')
+    expect(addIdx, 'ledger.add must be present in the handler').toBeGreaterThan(-1)
+    expect(connIdx, 'connect check must be present').toBeGreaterThan(-1)
+    expect(addIdx, 'ledger.add must precede the connect check so a disconnected request is retained')
+      .toBeLessThan(connIdx)
+  })
+
+  it('the early-return no longer DROPS unconditionally — it buffers on reconnect', () => {
+    const handler = slice(BRIDGE, "method: z.literal('notifications/claude/channel/permission_request')", 2600)
+    // The old drop path was a bare `if (!ipc || !ipc.isConnected()) { log; return }`
+    // with no ledger/buffer. Pin the new buffer semantics instead.
+    expect(handler).toMatch(/buffered.*re-send on reconnect/i)
+    // Structural anti-regression: the legacy standalone drop message must only
+    // appear behind the kill-switch fallback, never as the sole behavior.
+    expect(handler).toMatch(/permissionRearmEnabled/)
+  })
+
+  it('deletes from the ledger when a verdict is delivered (onPermission)', () => {
+    const onPerm = slice(BRIDGE, 'function onPermission(msg: PermissionEvent)', 900)
+    expect(onPerm).toMatch(/outstandingPermissions\.delete\(msg\.requestId\)/)
+  })
+
+  it('flushes outstanding requests on every IPC (re)connect', () => {
+    expect(BRIDGE).toMatch(/function flushOutstandingPermissionRequests/)
+    expect(BRIDGE).toMatch(/onConnect:\s*flushOutstandingPermissionRequests/)
+    const flush = slice(BRIDGE, 'function flushOutstandingPermissionRequests', 900)
+    expect(flush).toMatch(/outstandingPermissions\.all\(\)/)
+    expect(flush).toMatch(/sendPermissionRequest/)
+  })
+
+  it('honours the SWITCHROOM_PERMISSION_REARM kill switch', () => {
+    expect(BRIDGE).toMatch(/SWITCHROOM_PERMISSION_REARM\s*!==\s*'0'/)
+  })
+})
+
+// ─── IPC client: onConnect hook ───────────────────────────────────────────
+
+describe('ipc-client onConnect hook', () => {
+  it('exposes an onConnect option', () => {
+    expect(IPC_CLIENT).toMatch(/onConnect\?:\s*\(\)\s*=>\s*void/)
+  })
+  it('invokes onConnect from the socket open() handler (after register)', () => {
+    const open = slice(IPC_CLIENT, 'open(sock)', 900)
+    const regIdx = open.indexOf('sendRegister()')
+    const connIdx = open.indexOf('onConnect(')
+    expect(connIdx, 'open() must call onConnect').toBeGreaterThan(-1)
+    expect(regIdx).toBeLessThan(connIdx)
+  })
+})
+
+// ─── Gateway: dedupe + re-arm (R1) ────────────────────────────────────────
+
+describe('gateway re-arm wiring', () => {
+  it('imports the pure re-arm helpers', () => {
+    expect(GATEWAY).toMatch(/from '\.\/permission-rearm\.js'/)
+    expect(GATEWAY).toMatch(/classifyPermissionRequest/)
+    expect(GATEWAY).toMatch(/computeBootSweepStripTargets/)
+  })
+
+  it('onPermissionRequest dedupes / re-arms before posting a card', () => {
+    const fn = slice(GATEWAY, 'onPermissionRequest(_client: IpcClient, msg: PermissionRequestForward)', 5200)
+    expect(fn).toMatch(/isPermissionRearmEnabled\(\)/)
+    expect(fn).toMatch(/classifyPermissionRequest/)
+    // duplicate → return (no second card); rearm → restore from store.
+    expect(fn).toMatch(/disposition === 'duplicate'/)
+    expect(fn).toMatch(/disposition === 'rearm'/)
+    expect(fn).toMatch(/rearmPermissionFromStore\(/)
+    // The dedup/re-arm block must sit before the card-post (formatPermissionCardBody).
+    const rearmIdx = fn.indexOf('classifyPermissionRequest')
+    const postIdx = fn.indexOf('formatPermissionCardBody')
+    expect(postIdx).toBeGreaterThan(-1)
+    expect(rearmIdx).toBeLessThan(postIdx)
+  })
+
+  it('re-arm preserves the ORIGINAL startedAt (TTL clock, not Date.now())', () => {
+    const fn = slice(GATEWAY, 'function rearmPermissionFromStore', 1800)
+    // startedAt is derived from the persisted entries, never re-stamped.
+    expect(fn).toMatch(/c\.startedAt/)
+    expect(fn).toMatch(/startedAt,/)
+    expect(fn).not.toMatch(/startedAt:\s*Date\.now\(\)/)
+    expect(fn).toMatch(/pendingPermissions\.set\(requestId/)
+  })
+
+  it('re-arm re-attaches the keyboard on the EXISTING message(s) via editMessageText', () => {
+    const fn = slice(GATEWAY, 'function rearmPermissionFromStore', 1800)
+    expect(fn).toMatch(/buildPermissionActionRow\(requestId/)
+    expect(fn).toMatch(/editMessageText\(/)
+    // Re-arm edits existing messages; it must NOT post a brand-new card.
+    expect(fn).not.toMatch(/sendRichMessage/)
+  })
+
+  it('never auto-answers — no dispatchPermissionVerdict inside re-arm (no-self-escalation)', () => {
+    const fn = slice(GATEWAY, 'function rearmPermissionFromStore', 1800)
+    expect(fn).not.toMatch(/dispatchPermissionVerdict/)
+  })
+})
+
+// ─── Gateway: grace-period boot-sweep (R1) ────────────────────────────────
+
+describe('gateway boot-sweep grace period', () => {
+  it('defers the strip when re-arm is enabled, keeps immediate strip as the kill-switch path', () => {
+    const sweep = slice(GATEWAY, 'Boot-sweep for permission cards from a prior gateway session', 4200)
+    expect(sweep).toMatch(/if \(!isPermissionRearmEnabled\(\)\)/)
+    // legacy immediate path still strips everything + clears the store
+    expect(sweep).toMatch(/permCardStore\.clear\(\)/)
+    // grace path: setTimeout + grace-ms knob + live-pending filter
+    expect(sweep).toMatch(/setTimeout\(/)
+    expect(sweep).toMatch(/permissionRearmGraceMs\(\)/)
+    // Preserve anything currently live in pendingPermissions — covers both
+    // re-armed AND fresh-during-grace cards (reviewer-caught blocker fix).
+    expect(sweep).toMatch(/new Set\(pendingPermissions\.keys\(\)\)/)
+    expect(sweep).toMatch(/computeBootSweepStripTargets\(remaining, liveRequestIds\)/)
+  })
+
+  it('the grace path removes only stripped request_ids, not the whole store', () => {
+    const sweep = slice(GATEWAY, 'Boot-sweep for permission cards from a prior gateway session', 4200)
+    // Per-request removal (preserves re-armed live entries) inside the deferred block.
+    expect(sweep).toMatch(/distinctRequestIds\(toStrip\)/)
+    expect(sweep).toMatch(/permCardStore\.remove\(id\)/)
+  })
+})
+
+// ─── Gateway: re-arm re-holds the #2840 inbound gate ──────────────────────
+
+describe('re-armed pending card re-holds the inbound gate (#2840)', () => {
+  it('turnInFlightForGate counts pending approvals', () => {
+    const gate = slice(GATEWAY, 'function turnInFlightForGate()', 1200)
+    expect(gate).toMatch(/pendingPermissions\.size > 0/)
+  })
+  it('re-arm restores a pendingPermissions entry → gate held automatically', () => {
+    // The gate reads pendingPermissions.size; rearmPermissionFromStore sets an
+    // entry, so a re-armed card holds the gate with no extra wiring.
+    const fn = slice(GATEWAY, 'function rearmPermissionFromStore', 1800)
+    expect(fn).toMatch(/pendingPermissions\.set\(requestId/)
+  })
+})

package/telegram-plugin/tests/permission-rearm.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Unit tests for the pure permission-card re-arm helpers (#2861 / #2859).
+ *
+ * These cover the discriminable decision logic extracted from gateway.ts
+ * (which has top-level side effects and isn't unit-importable):
+ *   - classifyPermissionRequest — duplicate / rearm / fresh
+ *   - computeBootSweepStripTargets — grace-period strip filtering
+ *   - isPermissionRearmEnabled / permissionRearmGraceMs — kill switch + knob
+ *   - distinctRequestIds
+ *
+ * The gateway/bridge WIRING that consumes these is pinned separately in
+ * permission-rearm-wiring.test.ts.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  classifyPermissionRequest,
+  computeBootSweepStripTargets,
+  isPermissionRearmEnabled,
+  permissionRearmGraceMs,
+  distinctRequestIds,
+  PERMISSION_REARM_GRACE_MS,
+} from '../gateway/permission-rearm.js'
+import type { PersistedPermCard } from '../gateway/permission-card-store.js'
+
+function card(requestId: string, messageId: number): PersistedPermCard {
+  return {
+    requestId,
+    chatId: '-100123',
+    messageId,
+    startedAt: 1_000,
+    toolName: 'mcp__brevo__post',
+    cardText: 'Marko wants to post to Brevo',
+  }
+}
+
+describe('classifyPermissionRequest', () => {
+  it('already-live request → duplicate (ignore, no second card)', () => {
+    expect(classifyPermissionRequest({ hasPending: true, persistedCount: 0 })).toBe('duplicate')
+    // hasPending wins even if the store also has it
+    expect(classifyPermissionRequest({ hasPending: true, persistedCount: 2 })).toBe('duplicate')
+  })
+
+  it('gone from memory but persisted → rearm', () => {
+    expect(classifyPermissionRequest({ hasPending: false, persistedCount: 1 })).toBe('rearm')
+    expect(classifyPermissionRequest({ hasPending: false, persistedCount: 3 })).toBe('rearm')
+  })
+
+  it('unknown request → fresh (post a new card)', () => {
+    expect(classifyPermissionRequest({ hasPending: false, persistedCount: 0 })).toBe('fresh')
+  })
+})
+
+describe('computeBootSweepStripTargets', () => {
+  it('strips only entries whose request_id is NOT currently live', () => {
+    const stale = [card('aaaaa', 10), card('bbbbb', 11), card('ccccc', 12)]
+    const live = new Set(['bbbbb']) // bbbbb re-armed / still pending
+    const targets = computeBootSweepStripTargets(stale, live)
+    expect(targets.map(t => t.requestId)).toEqual(['aaaaa', 'ccccc'])
+  })
+
+  it('a re-armed (live) entry survives the deadline (empty strip)', () => {
+    const stale = [card('aaaaa', 10)]
+    const live = new Set(['aaaaa'])
+    expect(computeBootSweepStripTargets(stale, live)).toEqual([])
+  })
+
+  it('a dead-session entry (no live pending) is stripped at the deadline', () => {
+    const stale = [card('aaaaa', 10)]
+    const live = new Set<string>()
+    expect(computeBootSweepStripTargets(stale, live).map(t => t.requestId)).toEqual(['aaaaa'])
+  })
+
+  it('a FRESH card born during the grace window (live but not in the boot set) survives', () => {
+    // Regression for the reviewer-caught blocker: a new approval posted after
+    // boot writes its own persisted row, so it appears in `remaining` at the
+    // deadline. It's live in pendingPermissions, so it must NOT be stripped —
+    // otherwise a legitimately-suspended turn gets re-wedged.
+    const remaining = [card('dead0', 10), card('fresh', 20)]
+    const live = new Set(['fresh']) // 'fresh' posted during grace, still pending
+    const targets = computeBootSweepStripTargets(remaining, live)
+    expect(targets.map(t => t.requestId)).toEqual(['dead0'])
+  })
+
+  it('keeps ALL fan-out messages for a dead-session request', () => {
+    // Same request_id, two operator surfaces → two persisted rows.
+    const stale = [card('aaaaa', 10), card('aaaaa', 20)]
+    const targets = computeBootSweepStripTargets(stale, new Set())
+    expect(targets).toHaveLength(2)
+    expect(targets.map(t => t.messageId).sort()).toEqual([10, 20])
+  })
+})
+
+describe('distinctRequestIds', () => {
+  it('dedupes request_ids across fan-out rows', () => {
+    const cards = [card('aaaaa', 10), card('aaaaa', 20), card('bbbbb', 30)]
+    expect(distinctRequestIds(cards).sort()).toEqual(['aaaaa', 'bbbbb'])
+  })
+})
+
+describe('isPermissionRearmEnabled (kill switch)', () => {
+  it('enabled by default (unset)', () => {
+    expect(isPermissionRearmEnabled({})).toBe(true)
+  })
+  it('enabled for any value other than "0"', () => {
+    expect(isPermissionRearmEnabled({ SWITCHROOM_PERMISSION_REARM: '1' })).toBe(true)
+    expect(isPermissionRearmEnabled({ SWITCHROOM_PERMISSION_REARM: 'on' })).toBe(true)
+  })
+  it('disabled only for the exact "0" kill value', () => {
+    expect(isPermissionRearmEnabled({ SWITCHROOM_PERMISSION_REARM: '0' })).toBe(false)
+  })
+})
+
+describe('permissionRearmGraceMs', () => {
+  it('defaults to PERMISSION_REARM_GRACE_MS when unset', () => {
+    expect(permissionRearmGraceMs({})).toBe(PERMISSION_REARM_GRACE_MS)
+  })
+  it('honours a finite non-negative override (test collapse)', () => {
+    expect(permissionRearmGraceMs({ SWITCHROOM_PERMISSION_REARM_GRACE_MS: '0' })).toBe(0)
+    expect(permissionRearmGraceMs({ SWITCHROOM_PERMISSION_REARM_GRACE_MS: '250' })).toBe(250)
+  })
+  it('falls back to the default on garbage / negative', () => {
+    expect(permissionRearmGraceMs({ SWITCHROOM_PERMISSION_REARM_GRACE_MS: 'nope' })).toBe(PERMISSION_REARM_GRACE_MS)
+    expect(permissionRearmGraceMs({ SWITCHROOM_PERMISSION_REARM_GRACE_MS: '-5' })).toBe(PERMISSION_REARM_GRACE_MS)
+  })
+})