bingocode 1.0.28 → 1.0.30

package/adapters/common/__tests__/chat-queue.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'bun:test'
+import { enqueue } from '../chat-queue.js'
+
+describe('ChatQueue', () => {
+  it('executes tasks for the same chatId serially', async () => {
+    const order: number[] = []
+
+    await Promise.all([
+      enqueue('chat-1', async () => {
+        await new Promise((r) => setTimeout(r, 30))
+        order.push(1)
+      }),
+      enqueue('chat-1', async () => {
+        order.push(2)
+      }),
+      enqueue('chat-1', async () => {
+        order.push(3)
+      }),
+    ])
+
+    // Wait for all to complete
+    await new Promise((r) => setTimeout(r, 50))
+    expect(order).toEqual([1, 2, 3])
+  })
+
+  it('executes tasks for different chatIds in parallel', async () => {
+    const order: string[] = []
+
+    const p1 = enqueue('chat-a', async () => {
+      await new Promise((r) => setTimeout(r, 30))
+      order.push('a')
+    })
+
+    const p2 = enqueue('chat-b', async () => {
+      order.push('b') // should run immediately, not wait for chat-a
+    })
+
+    await Promise.all([p1, p2])
+    await new Promise((r) => setTimeout(r, 50))
+
+    // 'b' should appear before 'a' since chat-a has a delay
+    expect(order[0]).toBe('b')
+    expect(order[1]).toBe('a')
+  })
+
+  it('continues processing after a task fails', async () => {
+    const order: number[] = []
+
+    await enqueue('chat-err', async () => {
+      order.push(1)
+      throw new Error('task failed')
+    })
+
+    await enqueue('chat-err', async () => {
+      order.push(2) // should still run
+    })
+
+    await new Promise((r) => setTimeout(r, 20))
+    expect(order).toEqual([1, 2])
+  })
+})

package/adapters/common/__tests__/format.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect } from 'bun:test'
+import {
+  formatImHelp,
+  formatImStatus,
+  splitMessage,
+  formatToolUse,
+  formatPermissionRequest,
+  truncateInput,
+  escapeMarkdownV2,
+} from '../format.js'
+
+describe('splitMessage', () => {
+  it('returns single chunk for short text', () => {
+    expect(splitMessage('hello', 100)).toEqual(['hello'])
+  })
+
+  it('splits at paragraph boundary', () => {
+    const text = 'First paragraph.\n\nSecond paragraph.'
+    const chunks = splitMessage(text, 20)
+    expect(chunks.length).toBeGreaterThan(1)
+    expect(chunks.join(' ').replace(/\s+/g, ' ')).toContain('First paragraph')
+    expect(chunks.join(' ').replace(/\s+/g, ' ')).toContain('Second paragraph')
+  })
+
+  it('splits at newline if no paragraph break', () => {
+    const text = 'Line one\nLine two\nLine three\nLine four'
+    const chunks = splitMessage(text, 20)
+    expect(chunks.length).toBeGreaterThan(1)
+  })
+
+  it('hard-splits at limit if no natural break', () => {
+    const text = 'a'.repeat(50)
+    const chunks = splitMessage(text, 20)
+    expect(chunks.length).toBe(3) // 20 + 20 + 10
+    expect(chunks.every((c) => c.length <= 20)).toBe(true)
+  })
+
+  it('preserves all content after splitting', () => {
+    const text = 'Hello world. This is a test. Foo bar baz.'
+    const chunks = splitMessage(text, 15)
+    const joined = chunks.join(' ')
+    // All words should be present
+    expect(joined).toContain('Hello')
+    expect(joined).toContain('test')
+    expect(joined).toContain('baz')
+  })
+})
+
+describe('formatToolUse', () => {
+  it('includes tool name and input preview', () => {
+    const result = formatToolUse('Bash', { command: 'npm test' })
+    expect(result).toContain('🔧 Bash')
+    expect(result).toContain('npm test')
+  })
+})
+
+describe('formatPermissionRequest', () => {
+  it('includes tool name, input preview, and request ID', () => {
+    const result = formatPermissionRequest('Bash', { command: 'rm -rf /' }, 'abcde')
+    expect(result).toContain('🔐')
+    expect(result).toContain('Bash')
+    expect(result).toContain('abcde')
+    expect(result).toContain('rm -rf')
+  })
+})
+
+describe('truncateInput', () => {
+  it('returns short input as-is', () => {
+    expect(truncateInput('hello', 100)).toBe('hello')
+  })
+
+  it('truncates long input with ellipsis', () => {
+    const long = 'x'.repeat(300)
+    const result = truncateInput(long, 100)
+    expect(result.length).toBe(101) // 100 chars + '…'
+    expect(result.endsWith('…')).toBe(true)
+  })
+
+  it('handles objects by stringifying', () => {
+    const result = truncateInput({ key: 'value' }, 100)
+    expect(result).toContain('key')
+    expect(result).toContain('value')
+  })
+
+  it('handles unserializable input', () => {
+    const circular: any = {}
+    circular.self = circular
+    expect(truncateInput(circular, 100)).toBe('(unserializable)')
+  })
+})
+
+describe('escapeMarkdownV2', () => {
+  it('escapes special characters', () => {
+    expect(escapeMarkdownV2('hello_world')).toBe('hello\\_world')
+    expect(escapeMarkdownV2('a*b*c')).toBe('a\\*b\\*c')
+    expect(escapeMarkdownV2('test.md')).toBe('test\\.md')
+  })
+
+  it('leaves plain text unchanged', () => {
+    expect(escapeMarkdownV2('hello world')).toBe('hello world')
+  })
+})
+
+describe('formatImHelp', () => {
+  it('lists the lightweight IM commands', () => {
+    const text = formatImHelp()
+    expect(text).toContain('/new')
+    expect(text).toContain('/projects')
+    expect(text).toContain('/status')
+    expect(text).toContain('/clear')
+    expect(text).toContain('/stop')
+    expect(text).toContain('/help')
+  })
+})
+
+describe('formatImStatus', () => {
+  it('formats an active session summary for mobile reading', () => {
+    const text = formatImStatus({
+      sessionId: 'abc1234567890',
+      projectName: 'claude-code-haha',
+      branch: 'main',
+      model: 'claude-sonnet',
+      state: 'tool_executing',
+      verb: 'Running tests',
+      pendingPermissionCount: 1,
+      taskCounts: {
+        total: 4,
+        pending: 1,
+        inProgress: 2,
+        completed: 1,
+      },
+    })
+
+    expect(text).toContain('项目: claude-code-haha (main)')
+    expect(text).toContain('会话: abc12345…')
+    expect(text).toContain('模型: claude-sonnet')
+    expect(text).toContain('状态: 执行工具中 (Running tests)')
+    expect(text).toContain('审批: 1 个待确认')
+    expect(text).toContain('任务: 总计 4 · 进行中 2 · 待处理 1 · 已完成 1')
+  })
+
+  it('returns a friendly empty-session message when nothing is active', () => {
+    const text = formatImStatus(null)
+    expect(text).toContain('当前没有活动会话')
+    expect(text).toContain('/new')
+    expect(text).toContain('/projects')
+  })
+})

package/adapters/common/__tests__/http-client.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test'
+import { AdapterHttpClient } from '../http-client.js'
+
+describe('AdapterHttpClient', () => {
+  let client: AdapterHttpClient
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    client = new AdapterHttpClient('ws://127.0.0.1:3456')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('derives HTTP URL from WS URL', () => {
+    expect(client.httpBaseUrl).toBe('http://127.0.0.1:3456')
+
+    const secure = new AdapterHttpClient('wss://example.com:443')
+    expect(secure.httpBaseUrl).toBe('https://example.com:443')
+  })
+
+  it('createSession calls POST /api/sessions', async () => {
+    const mockSessionId = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify({ sessionId: mockSessionId }), {
+        status: 201,
+        headers: { 'Content-Type': 'application/json' },
+      }))
+    ) as any
+
+    const sessionId = await client.createSession('/path/to/project')
+    expect(sessionId).toBe(mockSessionId)
+
+    const call = (globalThis.fetch as any).mock.calls[0]
+    expect(call[0]).toBe('http://127.0.0.1:3456/api/sessions')
+    const body = JSON.parse(call[1].body)
+    expect(body.workDir).toBe('/path/to/project')
+  })
+
+  it('listRecentProjects calls GET /api/sessions/recent-projects', async () => {
+    const mockProjects = [
+      { projectName: 'my-app', realPath: '/home/user/my-app', sessionCount: 3 },
+    ]
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify({ projects: mockProjects }), {
+        headers: { 'Content-Type': 'application/json' },
+      }))
+    ) as any
+
+    const projects = await client.listRecentProjects()
+    expect(projects).toHaveLength(1)
+    expect(projects[0].projectName).toBe('my-app')
+  })
+
+  it('createSession throws on server error', async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify({ error: 'BAD_REQUEST', message: 'workDir required' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      }))
+    ) as any
+
+    expect(client.createSession('')).rejects.toThrow()
+  })
+
+  it('getGitInfo calls GET /api/sessions/:id/git-info', async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify({
+        branch: 'main',
+        repoName: 'claude-code-haha',
+        workDir: '/repo/claude-code-haha',
+        changedFiles: 2,
+      }), {
+        headers: { 'Content-Type': 'application/json' },
+      }))
+    ) as any
+
+    const gitInfo = await client.getGitInfo('session-123')
+    expect(gitInfo.repoName).toBe('claude-code-haha')
+    expect((globalThis.fetch as any).mock.calls[0][0]).toBe(
+      'http://127.0.0.1:3456/api/sessions/session-123/git-info',
+    )
+  })
+
+  it('getTasksForSession calls GET /api/tasks/lists/:id', async () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify({
+        tasks: [
+          { id: '1', subject: 'Fix bug', status: 'in_progress' },
+          { id: '2', subject: 'Write docs', status: 'pending' },
+        ],
+      }), {
+        headers: { 'Content-Type': 'application/json' },
+      }))
+    ) as any
+
+    const tasks = await client.getTasksForSession('session-123')
+    expect(tasks).toHaveLength(2)
+    expect(tasks[0]?.status).toBe('in_progress')
+    expect((globalThis.fetch as any).mock.calls[0][0]).toBe(
+      'http://127.0.0.1:3456/api/tasks/lists/session-123',
+    )
+  })
+})

package/adapters/common/__tests__/message-buffer.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach } from 'bun:test'
+import { MessageBuffer } from '../message-buffer.js'
+
+describe('MessageBuffer', () => {
+  it('accumulates text and flushes on complete', async () => {
+    const flushed: Array<{ text: string; isComplete: boolean }> = []
+    const buf = new MessageBuffer(
+      (text, isComplete) => { flushed.push({ text, isComplete }) },
+      500,  // 500ms interval
+      1000, // 1000 char threshold
+    )
+
+    buf.append('Hello ')
+    buf.append('World')
+    await buf.complete()
+
+    expect(flushed.length).toBeGreaterThanOrEqual(1)
+    const allText = flushed.map((f) => f.text).join('')
+    expect(allText).toBe('Hello World')
+    // Last flush should be marked complete
+    expect(flushed[flushed.length - 1]!.isComplete).toBe(true)
+  })
+
+  it('flushes when character threshold is reached', async () => {
+    const flushed: string[] = []
+    const buf = new MessageBuffer(
+      (text) => { flushed.push(text) },
+      10000, // very long interval (won't trigger)
+      10,    // 10 char threshold
+    )
+
+    buf.append('12345678901') // 11 chars > threshold
+
+    // Wait for microtask
+    await new Promise((r) => setTimeout(r, 10))
+    expect(flushed.length).toBeGreaterThanOrEqual(1)
+
+    buf.reset()
+  })
+
+  it('flushes on timer interval', async () => {
+    const flushed: string[] = []
+    const buf = new MessageBuffer(
+      (text) => { flushed.push(text) },
+      50, // 50ms interval
+      1000,
+    )
+
+    buf.append('hi')
+
+    // Wait for timer
+    await new Promise((r) => setTimeout(r, 80))
+    expect(flushed).toContain('hi')
+
+    buf.reset()
+  })
+
+  it('does not flush empty buffer on complete', async () => {
+    const flushed: string[] = []
+    const buf = new MessageBuffer(
+      (text) => { flushed.push(text) },
+    )
+
+    await buf.complete()
+    expect(flushed.length).toBe(0)
+  })
+
+  it('resets properly between messages', async () => {
+    const flushed: string[] = []
+    const buf = new MessageBuffer(
+      (text) => { flushed.push(text) },
+      500,
+      1000,
+    )
+
+    buf.append('first')
+    buf.reset()
+    buf.append('second')
+    await buf.complete()
+
+    const allText = flushed.map((f) => f).join('')
+    expect(allText).toBe('second')
+  })
+})

package/adapters/common/__tests__/message-dedup.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { MessageDedup } from '../message-dedup.js'
+
+describe('MessageDedup', () => {
+  let dedup: MessageDedup
+
+  beforeEach(() => {
+    dedup = new MessageDedup(1000, 100) // 1s TTL, 100 max entries
+  })
+
+  afterEach(() => {
+    dedup.destroy()
+  })
+
+  it('returns true for new messages', () => {
+    expect(dedup.tryRecord('msg-1')).toBe(true)
+    expect(dedup.tryRecord('msg-2')).toBe(true)
+  })
+
+  it('returns false for duplicate messages', () => {
+    expect(dedup.tryRecord('msg-1')).toBe(true)
+    expect(dedup.tryRecord('msg-1')).toBe(false)
+    expect(dedup.tryRecord('msg-1')).toBe(false)
+  })
+
+  it('allows same ID after TTL expires', async () => {
+    const shortDedup = new MessageDedup(50, 100) // 50ms TTL
+    expect(shortDedup.tryRecord('msg-1')).toBe(true)
+    expect(shortDedup.tryRecord('msg-1')).toBe(false)
+    await new Promise((r) => setTimeout(r, 60))
+    expect(shortDedup.tryRecord('msg-1')).toBe(true)
+    shortDedup.destroy()
+  })
+
+  it('evicts oldest entry when at capacity', () => {
+    const smallDedup = new MessageDedup(60_000, 3) // max 3 entries
+    expect(smallDedup.tryRecord('a')).toBe(true)
+    expect(smallDedup.tryRecord('b')).toBe(true)
+    expect(smallDedup.tryRecord('c')).toBe(true)
+    // Adding 4th should evict 'a'
+    expect(smallDedup.tryRecord('d')).toBe(true)
+    // 'a' was evicted, should be treated as new
+    expect(smallDedup.tryRecord('a')).toBe(true)
+    // Now store has {c, d, a} — 'b' was evicted when 'a' was re-inserted
+    // 'c' should still be deduped (was not evicted)
+    expect(smallDedup.tryRecord('c')).toBe(false)
+    smallDedup.destroy()
+  })
+
+  it('handles distinct messages independently', () => {
+    expect(dedup.tryRecord('msg-1')).toBe(true)
+    expect(dedup.tryRecord('msg-2')).toBe(true)
+    expect(dedup.tryRecord('msg-1')).toBe(false)
+    expect(dedup.tryRecord('msg-2')).toBe(false)
+    expect(dedup.tryRecord('msg-3')).toBe(true)
+  })
+})

package/adapters/common/__tests__/session-store.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import { SessionStore } from '../session-store.js'
+
+describe('SessionStore', () => {
+  let tmpDir: string
+  let store: SessionStore
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-store-'))
+    store = new SessionStore(path.join(tmpDir, 'sessions.json'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('returns null for unknown chatId', () => {
+    expect(store.get('unknown')).toBeNull()
+  })
+
+  it('stores and retrieves a session', () => {
+    store.set('chat-1', 'uuid-aaa', '/path/to/project')
+    const entry = store.get('chat-1')
+    expect(entry).not.toBeNull()
+    expect(entry!.sessionId).toBe('uuid-aaa')
+    expect(entry!.workDir).toBe('/path/to/project')
+  })
+
+  it('overwrites existing entry on set', () => {
+    store.set('chat-1', 'uuid-aaa', '/old')
+    store.set('chat-1', 'uuid-bbb', '/new')
+    expect(store.get('chat-1')!.sessionId).toBe('uuid-bbb')
+  })
+
+  it('deletes an entry', () => {
+    store.set('chat-1', 'uuid-aaa', '/path')
+    store.delete('chat-1')
+    expect(store.get('chat-1')).toBeNull()
+  })
+
+  it('persists to disk and reloads', () => {
+    store.set('chat-1', 'uuid-aaa', '/path')
+
+    const store2 = new SessionStore(path.join(tmpDir, 'sessions.json'))
+    expect(store2.get('chat-1')!.sessionId).toBe('uuid-aaa')
+  })
+
+  it('handles missing file gracefully', () => {
+    const store2 = new SessionStore(path.join(tmpDir, 'nonexistent.json'))
+    expect(store2.get('anything')).toBeNull()
+  })
+
+  it('lists all entries', () => {
+    store.set('chat-1', 'uuid-1', '/a')
+    store.set('chat-2', 'uuid-2', '/b')
+    const all = store.listAll()
+    expect(all).toHaveLength(2)
+  })
+})

package/adapters/common/__tests__/ws-bridge.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { WsBridge } from '../ws-bridge.js'
+import { WebSocketServer, type WebSocket as WsServerSocket } from 'ws'
+
+describe('WsBridge', () => {
+  let bridge: WsBridge
+
+  beforeEach(() => {
+    bridge = new WsBridge('ws://127.0.0.1:19999', 'test')
+  })
+
+  afterEach(() => {
+    bridge.destroy()
+  })
+
+  it('connectSession connects with provided sessionId', () => {
+    const result = bridge.connectSession('chat-1', 'my-uuid-session-id')
+    expect(result).toBe(true)
+    expect(bridge.hasSession('chat-1')).toBe(true)
+  })
+
+  it('connectSession for different chatIds creates separate sessions', () => {
+    bridge.connectSession('chat-1', 'uuid-1')
+    bridge.connectSession('chat-2', 'uuid-2')
+    expect(bridge.hasSession('chat-1')).toBe(true)
+    expect(bridge.hasSession('chat-2')).toBe(true)
+  })
+
+  it('resetSession removes the session', () => {
+    bridge.connectSession('chat-reset', 'uuid-reset')
+    bridge.resetSession('chat-reset')
+    expect(bridge.hasSession('chat-reset')).toBe(false)
+  })
+
+  it('sendUserMessage returns false when no open connection', () => {
+    bridge.connectSession('chat-offline', 'uuid-offline')
+    expect(bridge.sendUserMessage('chat-offline', 'hello')).toBe(false)
+  })
+
+  it('sendPermissionResponse returns false when no open connection', () => {
+    bridge.connectSession('chat-perm', 'uuid-perm')
+    expect(bridge.sendPermissionResponse('chat-perm', 'req-1', true)).toBe(false)
+  })
+
+  it('sendStopGeneration returns false when no open connection', () => {
+    bridge.connectSession('chat-stop', 'uuid-stop')
+    expect(bridge.sendStopGeneration('chat-stop')).toBe(false)
+  })
+
+  it('destroy cleans up all sessions', () => {
+    bridge.connectSession('a', 'uuid-a')
+    bridge.connectSession('b', 'uuid-b')
+    bridge.destroy()
+    expect(bridge.hasSession('a')).toBe(false)
+    expect(bridge.hasSession('b')).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Integration: per-chat handler serialization
+//
+// Reproduces the feishu text→tool→text race: a slow handler on msg 1 must
+// complete BEFORE msg 2's handler starts, otherwise msg 2 reads the stale
+// state msg 1's continuation is about to clear.
+// ---------------------------------------------------------------------------
+
+describe('WsBridge: handler serialization', () => {
+  let server: WebSocketServer
+  let port: number
+  let connections: WsServerSocket[]
+  let serverUrl: string
+
+  beforeEach(async () => {
+    connections = []
+    // port 0 → let the OS pick a free one
+    server = new WebSocketServer({ port: 0 })
+    server.on('connection', (ws) => {
+      connections.push(ws)
+    })
+    await new Promise<void>((resolve) => server.on('listening', () => resolve()))
+    port = (server.address() as { port: number }).port
+    serverUrl = `ws://127.0.0.1:${port}`
+  })
+
+  afterEach(async () => {
+    // Forcibly kill any server-side sockets (not graceful close) so
+    // WebSocketServer.close() doesn't wait for client FIN.
+    for (const ws of connections) {
+      try { ws.terminate() } catch {}
+    }
+    await new Promise<void>((resolve) => {
+      const t = setTimeout(() => resolve(), 500) // hard cap
+      server.close(() => {
+        clearTimeout(t)
+        resolve()
+      })
+    })
+  })
+
+  it('processes handler calls in strict FIFO order per chatId', async () => {
+    const bridge = new WsBridge(serverUrl, 'test')
+    const events: string[] = []
+
+    // The handler simulates an async side effect that takes varying time.
+    // If handlers ran concurrently, fast msgs could finish before slow ones,
+    // producing an out-of-order `events` array.
+    bridge.onServerMessage('chat-1', async (msg: any) => {
+      const tag = msg.tag as string
+      const delay = msg.delay as number
+      events.push(`start:${tag}`)
+      await new Promise((r) => setTimeout(r, delay))
+      events.push(`end:${tag}`)
+    })
+
+    bridge.connectSession('chat-1', 'sess-1')
+    const ok = await bridge.waitForOpen('chat-1')
+    expect(ok).toBe(true)
+    expect(connections.length).toBe(1)
+    const serverWs = connections[0]!
+
+    // Blast three messages back-to-back. msg1 is slow, msg2/msg3 are fast.
+    // With serialization: start:1, end:1, start:2, end:2, start:3, end:3
+    // Without serialization: start:1, start:2, start:3, end:2, end:3, end:1
+    serverWs.send(JSON.stringify({ tag: '1', delay: 40 }))
+    serverWs.send(JSON.stringify({ tag: '2', delay: 5 }))
+    serverWs.send(JSON.stringify({ tag: '3', delay: 5 }))
+
+    // Wait long enough for all three handlers to run serially
+    await new Promise((r) => setTimeout(r, 200))
+
+    expect(events).toEqual([
+      'start:1', 'end:1',
+      'start:2', 'end:2',
+      'start:3', 'end:3',
+    ])
+
+    bridge.destroy()
+  })
+
+  it('handler error does not break the chain (subsequent messages still run)', async () => {
+    const bridge = new WsBridge(serverUrl, 'test')
+    const events: string[] = []
+
+    bridge.onServerMessage('chat-err', async (msg: any) => {
+      if (msg.throw) {
+        events.push('throwing')
+        throw new Error('boom')
+      }
+      events.push(`ok:${msg.tag}`)
+    })
+
+    bridge.connectSession('chat-err', 'sess-err')
+    await bridge.waitForOpen('chat-err')
+    const serverWs = connections[0]!
+
+    serverWs.send(JSON.stringify({ throw: true }))
+    serverWs.send(JSON.stringify({ tag: 'after' }))
+
+    await new Promise((r) => setTimeout(r, 80))
+
+    expect(events).toEqual(['throwing', 'ok:after'])
+
+    bridge.destroy()
+  })
+
+  it('resetSession clears the handler chain', async () => {
+    const bridge = new WsBridge(serverUrl, 'test')
+    bridge.onServerMessage('chat-reset', () => {})
+    bridge.connectSession('chat-reset', 'sess-reset')
+    await bridge.waitForOpen('chat-reset')
+
+    bridge.resetSession('chat-reset')
+    expect(bridge.hasSession('chat-reset')).toBe(false)
+
+    bridge.destroy()
+  })
+})