bingocode 1.0.29 → 1.0.30

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

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

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

@@ -0,0 +1,115 @@
+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/feishu/__tests__/card-errors.test.ts

@@ -0,0 +1,194 @@
+/**
+ * card-errors 单元测试
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  CARD_ERROR,
+  CARD_CONTENT_SUB_ERROR,
+  extractLarkApiCode,
+  extractSubCode,
+  parseCardApiError,
+  isCardRateLimitError,
+  isCardTableLimitError,
+} from '../card-errors.js'
+
+describe('extractLarkApiCode', () => {
+  it('从 err.code 直接提取', () => {
+    expect(extractLarkApiCode({ code: 230020 })).toBe(230020)
+  })
+
+  it('从 err.data.code 提取', () => {
+    expect(extractLarkApiCode({ data: { code: 230099 } })).toBe(230099)
+  })
+
+  it('从 err.response.data.code 提取（Axios 风格）', () => {
+    expect(extractLarkApiCode({ response: { data: { code: 99991672 } } })).toBe(99991672)
+  })
+
+  it('数字字符串被强制转成 number', () => {
+    expect(extractLarkApiCode({ code: '230020' })).toBe(230020)
+  })
+
+  it('三层结构优先级: err.code > err.data.code > err.response.data.code', () => {
+    const err = {
+      code: 1,
+      data: { code: 2 },
+      response: { data: { code: 3 } },
+    }
+    expect(extractLarkApiCode(err)).toBe(1)
+  })
+
+  it('none → undefined', () => {
+    expect(extractLarkApiCode({})).toBeUndefined()
+    expect(extractLarkApiCode(null)).toBeUndefined()
+    expect(extractLarkApiCode(undefined)).toBeUndefined()
+    expect(extractLarkApiCode('just a string')).toBeUndefined()
+    expect(extractLarkApiCode(new Error('plain'))).toBeUndefined()
+  })
+
+  it('非有限数字被忽略', () => {
+    expect(extractLarkApiCode({ code: NaN })).toBeUndefined()
+    expect(extractLarkApiCode({ code: 'not-a-number' })).toBeUndefined()
+  })
+})
+
+describe('extractSubCode', () => {
+  it('识别标准的 ErrCode: 11310', () => {
+    const msg = 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit'
+    expect(extractSubCode(msg)).toBe(11310)
+  })
+
+  it('无 ErrCode 时返回 null', () => {
+    expect(extractSubCode('random error message')).toBeNull()
+    expect(extractSubCode('')).toBeNull()
+  })
+
+  it('ErrCode 大小写容错（冒号后多空格）', () => {
+    expect(extractSubCode('ErrCode:  42')).toBe(42)
+  })
+})
+
+describe('parseCardApiError', () => {
+  it('从 SDK 风格错误提取完整结构', () => {
+    const err = { code: 230099, msg: 'ErrCode: 11310; ErrMsg: card table number over limit' }
+    const parsed = parseCardApiError(err)
+    expect(parsed).toEqual({
+      code: 230099,
+      subCode: 11310,
+      errMsg: 'ErrCode: 11310; ErrMsg: card table number over limit',
+    })
+  })
+
+  it('从 Axios 风格错误（response.data.msg）提取', () => {
+    const err = {
+      response: {
+        data: {
+          code: 230020,
+          msg: 'rate limited',
+        },
+      },
+    }
+    const parsed = parseCardApiError(err)
+    expect(parsed?.code).toBe(230020)
+    expect(parsed?.errMsg).toBe('rate limited')
+    expect(parsed?.subCode).toBeNull()
+  })
+
+  it('无 code 时返回 null', () => {
+    expect(parseCardApiError({})).toBeNull()
+    expect(parseCardApiError(null)).toBeNull()
+    expect(parseCardApiError('string')).toBeNull()
+  })
+
+  it('有 code 无 msg 时 errMsg 为空字符串', () => {
+    const parsed = parseCardApiError({ code: 230020 })
+    expect(parsed).toEqual({ code: 230020, subCode: null, errMsg: '' })
+  })
+
+  it('fallback 到 err.message', () => {
+    const err = Object.assign(new Error('fallback text'), { code: 230099 })
+    const parsed = parseCardApiError(err)
+    expect(parsed?.errMsg).toBe('fallback text')
+  })
+})
+
+describe('isCardRateLimitError', () => {
+  it('识别 230020', () => {
+    expect(isCardRateLimitError({ code: 230020 })).toBe(true)
+  })
+
+  it('识别 Axios 风格 230020', () => {
+    expect(isCardRateLimitError({ response: { data: { code: 230020 } } })).toBe(true)
+  })
+
+  it('不匹配其他 code', () => {
+    expect(isCardRateLimitError({ code: 230099 })).toBe(false)
+    expect(isCardRateLimitError({ code: 99991672 })).toBe(false)
+  })
+
+  it('非错误对象返回 false', () => {
+    expect(isCardRateLimitError(null)).toBe(false)
+    expect(isCardRateLimitError({})).toBe(false)
+    expect(isCardRateLimitError(new Error('random'))).toBe(false)
+  })
+})
+
+describe('isCardTableLimitError', () => {
+  const validMsg = 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit; ErrorValue: table; '
+
+  it('严格三条件匹配: code=230099 + subCode=11310 + msg 含 table number over limit', () => {
+    const err = { code: CARD_ERROR.CARD_CONTENT_FAILED, msg: validMsg }
+    expect(isCardTableLimitError(err)).toBe(true)
+  })
+
+  it('从 Axios 风格的 response.data 匹配', () => {
+    const err = {
+      response: {
+        data: {
+          code: 230099,
+          msg: validMsg,
+        },
+      },
+    }
+    expect(isCardTableLimitError(err)).toBe(true)
+  })
+
+  it('230099 + 11310 但没有 "table number over limit" 字样 → false（其它元素超限）', () => {
+    const err = {
+      code: CARD_ERROR.CARD_CONTENT_FAILED,
+      msg: 'ErrCode: 11310; ErrMsg: some other element limit; ',
+    }
+    expect(isCardTableLimitError(err)).toBe(false)
+  })
+
+  it('code 不是 230099 → false', () => {
+    const err = { code: 230020, msg: validMsg }
+    expect(isCardTableLimitError(err)).toBe(false)
+  })
+
+  it('没有 subCode → false', () => {
+    const err = { code: 230099, msg: 'card table number over limit (no ErrCode)' }
+    expect(isCardTableLimitError(err)).toBe(false)
+  })
+
+  it('不区分 "table number" 的大小写', () => {
+    const err = {
+      code: 230099,
+      msg: 'ErrCode: 11310; ErrMsg: CARD TABLE NUMBER OVER LIMIT; ',
+    }
+    expect(isCardTableLimitError(err)).toBe(true)
+  })
+})
+
+describe('常量值', () => {
+  it('CARD_ERROR.RATE_LIMITED === 230020', () => {
+    expect(CARD_ERROR.RATE_LIMITED).toBe(230020)
+  })
+  it('CARD_ERROR.CARD_CONTENT_FAILED === 230099', () => {
+    expect(CARD_ERROR.CARD_CONTENT_FAILED).toBe(230099)
+  })
+  it('CARD_CONTENT_SUB_ERROR.ELEMENT_LIMIT === 11310', () => {
+    expect(CARD_CONTENT_SUB_ERROR.ELEMENT_LIMIT).toBe(11310)
+  })
+})