bingocode 1.0.27 → 1.0.28

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

@@ -1,148 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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()
-  })
-})

package/adapters/common/attachment/__tests__/attachment-limits.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import {
-  checkAttachmentLimit,
-  IMAGE_MAX_BYTES,
-  FILE_MAX_BYTES,
-  IMAGE_MIME_WHITELIST,
-} from '../attachment-limits.js'
-
-describe('checkAttachmentLimit', () => {
-  it('accepts a 1 MB PNG image', () => {
-    const result = checkAttachmentLimit('image', 1024 * 1024, 'image/png')
-    expect(result.ok).toBe(true)
-  })
-
-  it('rejects an 11 MB image as too_large', () => {
-    const result = checkAttachmentLimit('image', 11 * 1024 * 1024, 'image/png')
-    expect(result.ok).toBe(false)
-    if (!result.ok) {
-      expect(result.reason).toBe('too_large')
-      expect(result.hint).toContain('10')
-    }
-  })
-
-  it('rejects an unsupported image mime', () => {
-    const result = checkAttachmentLimit('image', 500_000, 'image/svg+xml')
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toBe('unsupported_mime')
-  })
-
-  it('rejects image/heic (not supported by Claude API)', () => {
-    const result = checkAttachmentLimit('image', 500_000, 'image/heic')
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toBe('unsupported_mime')
-  })
-
-  it('accepts a 10 MB PDF file', () => {
-    const result = checkAttachmentLimit('file', 10 * 1024 * 1024, 'application/pdf')
-    expect(result.ok).toBe(true)
-  })
-
-  it('rejects a 31 MB file as too_large', () => {
-    const result = checkAttachmentLimit('file', 31 * 1024 * 1024, 'application/pdf')
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toBe('too_large')
-  })
-
-  it('exposes the limits as exports', () => {
-    expect(IMAGE_MAX_BYTES).toBe(10 * 1024 * 1024)
-    expect(FILE_MAX_BYTES).toBe(30 * 1024 * 1024)
-    expect(IMAGE_MIME_WHITELIST).toContain('image/png')
-  })
-})