bingocode 1.0.40 → 1.1.42

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')
-  })
-})

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

@@ -1,108 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
-import * as fs from 'node:fs/promises'
-import * as fsSync from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import { AttachmentStore } from '../attachment-store.js'
-
-let tmpRoot: string
-
-beforeEach(async () => {
-  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'att-store-test-'))
-})
-
-afterEach(async () => {
-  await fs.rm(tmpRoot, { recursive: true, force: true })
-})
-
-describe('AttachmentStore', () => {
-  it('writes a buffer and returns the absolute path', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('feishu', 'sess-1', 'hello.png')
-    const written = await store.write(target, Buffer.from('PNGDATA'))
-    expect(path.isAbsolute(written)).toBe(true)
-    const content = await fs.readFile(written)
-    expect(content.toString()).toBe('PNGDATA')
-  })
-
-  it('writes under {root}/{platform}/{sessionId}/', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('telegram', 'sess-42', 'foo.pdf')
-    expect(target).toContain(path.join('telegram', 'sess-42'))
-    expect(target.endsWith('foo.pdf')).toBe(true)
-  })
-
-  it('sanitizes unsafe filenames (strips path separators and ..)', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('feishu', 'sess-1', '../../etc/passwd')
-    // The resulting target must still live inside the store root.
-    const root = path.resolve(tmpRoot)
-    expect(path.resolve(target).startsWith(root)).toBe(true)
-    expect(path.basename(target)).not.toContain('..')
-    expect(path.basename(target)).not.toContain('/')
-  })
-
-  it('collapses name collisions by prefixing timestamps', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const a = store.resolvePath('feishu', 'sess-1', 'image.png')
-    await store.write(a, Buffer.from('first'))
-    const b = store.resolvePath('feishu', 'sess-1', 'image.png')
-    expect(b).not.toBe(a)
-    await store.write(b, Buffer.from('second'))
-    const contentB = await fs.readFile(b)
-    expect(contentB.toString()).toBe('second')
-  })
-
-  it('gc() removes files older than retentionMs and reports counts', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 50 })
-    const target = store.resolvePath('feishu', 'sess-1', 'stale.png')
-    await store.write(target, Buffer.from('STALE'))
-    // Age the file manually
-    const past = new Date(Date.now() - 10_000)
-    await fs.utimes(target, past, past)
-    const result = await store.gc()
-    expect(result.removed).toBe(1)
-    expect(result.bytes).toBe(5)
-    await expect(fs.access(target)).rejects.toThrow()
-  })
-
-  it('gc() keeps fresh files', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    const target = store.resolvePath('feishu', 'sess-1', 'fresh.png')
-    await store.write(target, Buffer.from('FRESH'))
-    const result = await store.gc()
-    expect(result.removed).toBe(0)
-    await fs.access(target)
-  })
-
-  it('resolvePath under heavy collision pressure returns unique paths', () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
-    // First create a file so subsequent resolves hit the collision branch
-    const a = store.resolvePath('feishu', 'sess-1', 'race.png')
-    fsSync.writeFileSync(a, 'first')
-    // Collect 50 resolved paths in a tight loop — none should clash
-    const seen = new Set<string>()
-    for (let i = 0; i < 50; i++) {
-      seen.add(store.resolvePath('feishu', 'sess-1', 'race.png'))
-    }
-    expect(seen.size).toBe(50)
-    for (const p of seen) {
-      expect(p).not.toBe(a)
-    }
-  })
-
-  it('gc() cleans orphan .part files after a short grace period', async () => {
-    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 10_000, orphanGraceMs: 50 })
-    // Simulate a crashed write — leave a .part tmp file behind
-    const dir = path.join(tmpRoot, 'feishu', 'sess-1')
-    await fs.mkdir(dir, { recursive: true })
-    const orphan = path.join(dir, 'image.png.1234.5678.part')
-    await fs.writeFile(orphan, 'ORPHAN')
-    // Age the orphan so gc considers it stale
-    const past = new Date(Date.now() - 1000)
-    await fs.utimes(orphan, past, past)
-    const result = await store.gc()
-    expect(result.removed).toBeGreaterThanOrEqual(1)
-    await expect(fs.access(orphan)).rejects.toThrow()
-  })
-})

package/adapters/common/attachment/__tests__/image-block-watcher.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import { ImageBlockWatcher } from '../image-block-watcher.js'
-
-describe('ImageBlockWatcher', () => {
-  it('extracts a markdown image with http URL', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('Here is ![alt](https://example.com/foo.png) an image.')
-    expect(out.length).toBe(1)
-    const source = out[0]!.source
-    expect(source.kind).toBe('url')
-    if (source.kind === 'url') {
-      expect(source.url).toBe('https://example.com/foo.png')
-    }
-    expect(out[0]!.alt).toBe('alt')
-  })
-
-  it('extracts a markdown image with absolute local path', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![cat](/tmp/cat.jpg)')
-    expect(out.length).toBe(1)
-    const source = out[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') {
-      expect(source.path).toBe('/tmp/cat.jpg')
-    }
-  })
-
-  it('extracts a markdown image with file:// URL as path', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![x](file:///var/img/x.png)')
-    const source = out[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') expect(source.path).toBe('/var/img/x.png')
-  })
-
-  it('extracts a data URI as base64', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![inline](data:image/png;base64,AAAA)')
-    const source = out[0]!.source
-    expect(source.kind).toBe('base64')
-    if (source.kind === 'base64') {
-      expect(source.mime).toBe('image/png')
-      expect(source.data).toBe('AAAA')
-    }
-  })
-
-  it('deduplicates the same image across multiple feeds', () => {
-    const w = new ImageBlockWatcher()
-    const a = w.feed('![](https://x/y.png)')
-    const b = w.feed(' repeated ![](https://x/y.png) again')
-    expect(a.length).toBe(1)
-    expect(b.length).toBe(0)
-  })
-
-  it('handles images split across feed boundaries', () => {
-    const w = new ImageBlockWatcher()
-    const a = w.feed('a ![al')
-    const b = w.feed('t](/tmp/x.png) b')
-    expect(a.length).toBe(0)
-    expect(b.length).toBe(1)
-    const source = b[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') expect(source.path).toBe('/tmp/x.png')
-  })
-
-  it('skips non-image markdown links', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('See [docs](https://example.com).')
-    expect(out.length).toBe(0)
-  })
-
-  it('drain() returns all accumulated uploads', () => {
-    const w = new ImageBlockWatcher()
-    w.feed('![a](/tmp/a.png)')
-    w.feed(' and ![b](/tmp/b.png)')
-    const all = w.drain()
-    expect(all.length).toBe(2)
-  })
-
-  it('reset() clears buffer, seen set, and accumulated list', () => {
-    const w = new ImageBlockWatcher()
-    w.feed('![a](/tmp/a.png)')
-    w.reset()
-    // After reset, drain() is empty
-    expect(w.drain().length).toBe(0)
-    // And re-feeding the same image yields a fresh emit (dedup state cleared)
-    const out = w.feed('![a](/tmp/a.png)')
-    expect(out.length).toBe(1)
-  })
-
-  it('skips relative paths (cannot be resolved safely)', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![rel](relative/path.png) and ![ok](/tmp/ok.png)')
-    expect(out.length).toBe(1)
-    const source = out[0]!.source
-    expect(source.kind).toBe('path')
-    if (source.kind === 'path') expect(source.path).toBe('/tmp/ok.png')
-  })
-
-  it('extracts multiple images from a single feed chunk in order', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![a](/tmp/a.png) ![b](https://x/b.png) ![c](data:image/png;base64,QQ==)')
-    expect(out.length).toBe(3)
-    expect(out[0]!.source.kind).toBe('path')
-    expect(out[1]!.source.kind).toBe('url')
-    expect(out[2]!.source.kind).toBe('base64')
-  })
-
-  it('rejects malformed data URI (not base64)', () => {
-    const w = new ImageBlockWatcher()
-    const out = w.feed('![bad](data:image/png,ABC)')
-    // Not in `;base64,` form → classify returns null → skipped
-    expect(out.length).toBe(0)
-  })
-})

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

@@ -1,58 +0,0 @@
-/**
- * Size and MIME restrictions for IM attachments.
- *
- * Limits chosen to sit safely under both Feishu (10 MB image / 30 MB file)
- * and Telegram Bot API (10 MB image / 50 MB file), and under Claude API's
- * own image size bounds.
- */
-
-export const IMAGE_MAX_BYTES = 10 * 1024 * 1024 // 10 MB
-export const FILE_MAX_BYTES = 30 * 1024 * 1024  // 30 MB
-
-export const IMAGE_MIME_WHITELIST = [
-  'image/jpeg',
-  'image/png',
-  'image/gif',
-  'image/webp',
-] as const
-
-export type LimitCheckResult =
-  | { ok: true }
-  | { ok: false; reason: 'too_large' | 'unsupported_mime'; hint: string }
-
-function formatMb(bytes: number): string {
-  return (bytes / (1024 * 1024)).toFixed(1)
-}
-
-export function checkAttachmentLimit(
-  kind: 'image' | 'file',
-  size: number,
-  mime?: string,
-): LimitCheckResult {
-  if (kind === 'image') {
-    if (size > IMAGE_MAX_BYTES) {
-      return {
-        ok: false,
-        reason: 'too_large',
-        hint: `📎 图片过大(${formatMb(size)} MB),请控制在 10 MB 以内`,
-      }
-    }
-    if (mime && !IMAGE_MIME_WHITELIST.includes(mime as (typeof IMAGE_MIME_WHITELIST)[number])) {
-      return {
-        ok: false,
-        reason: 'unsupported_mime',
-        hint: `📎 暂不支持此图片格式(${mime})`,
-      }
-    }
-    return { ok: true }
-  }
-  // kind === 'file'
-  if (size > FILE_MAX_BYTES) {
-    return {
-      ok: false,
-      reason: 'too_large',
-      hint: `📎 文件过大(${formatMb(size)} MB),请控制在 30 MB 以内`,
-    }
-  }
-  return { ok: true }
-}