bingocode 1.0.41 → 1.1.42

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

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

@@ -1,121 +0,0 @@
-/**
- * Local staging directory for IM-downloaded resources.
- *
- * Layout: {root}/{platform}/{sessionId}/{safeName}
- * Default root: ~/.claude/im-downloads
- *
- * Responsibilities:
- *  - Generate unique, safe paths from (platform, sessionId, originalName)
- *  - Atomic write (tmp → rename) so concurrent downloads never corrupt each other
- *  - GC files that haven't been touched for `retentionMs` (default 24h)
- */
-
-import * as fs from 'node:fs/promises'
-import * as fsSync from 'node:fs'
-import type { Dirent } from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import type { ImPlatform } from './attachment-types.js'
-
-export interface AttachmentStoreConfig {
-  root: string
-  retentionMs: number
-  /** Grace window before a `.part` orphan (left behind by a crashed writer)
-   *  is eligible for GC. Default 10 minutes. */
-  orphanGraceMs: number
-}
-
-const DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1000
-const DEFAULT_ORPHAN_GRACE_MS = 10 * 60 * 1000
-
-function defaultRoot(): string {
-  return path.join(os.homedir(), '.claude', 'im-downloads')
-}
-
-/** Strip path separators / .. / control chars from a filename. */
-function sanitizeFilename(name: string): string {
-  // eslint-disable-next-line no-control-regex
-  const base = path.basename(name || '').replace(/[\x00-\x1f]/g, '')
-  const cleaned = base.replace(/[\/\\]/g, '_').replace(/\.\.+/g, '_')
-  return cleaned.trim() || 'unnamed'
-}
-
-export class AttachmentStore {
-  private readonly root: string
-  private readonly retentionMs: number
-  private readonly orphanGraceMs: number
-
-  constructor(config?: Partial<AttachmentStoreConfig>) {
-    this.root = config?.root ?? defaultRoot()
-    this.retentionMs = config?.retentionMs ?? DEFAULT_RETENTION_MS
-    this.orphanGraceMs = config?.orphanGraceMs ?? DEFAULT_ORPHAN_GRACE_MS
-  }
-
-  /** Compute the target path. Creates parent dirs on demand.
-   *  If a file with the same name already exists, prefix with a timestamp
-   *  to avoid clobbering. */
-  resolvePath(platform: ImPlatform, sessionId: string, name: string): string {
-    const safeSession = sanitizeFilename(sessionId)
-    const dir = path.join(this.root, platform, safeSession)
-    fsSync.mkdirSync(dir, { recursive: true })
-    const safeName = sanitizeFilename(name)
-    const candidate = path.join(dir, safeName)
-    if (!fsSync.existsSync(candidate)) return candidate
-    const { name: base, ext } = path.parse(safeName)
-    // Collisions are rare in practice, but multiple downloads landing in the
-    // same millisecond must still produce unique paths — append a random
-    // suffix so the bare timestamp alone never clashes.
-    const rand = Math.random().toString(36).slice(2, 8)
-    return path.join(dir, `${base}-${Date.now()}-${rand}${ext}`)
-  }
-
-  /** Write atomically: stream to {target}.part, then rename. */
-  async write(target: string, data: Buffer): Promise<string> {
-    await fs.mkdir(path.dirname(target), { recursive: true })
-    const tmp = `${target}.${process.pid}.${Date.now()}.part`
-    await fs.writeFile(tmp, data)
-    await fs.rename(tmp, target)
-    return target
-  }
-
-  /** Remove files older than retentionMs. Returns summary. */
-  async gc(): Promise<{ removed: number; bytes: number }> {
-    let removed = 0
-    let bytes = 0
-    const now = Date.now()
-
-    const walk = async (dir: string): Promise<void> => {
-      let entries: Dirent<string>[]
-      try {
-        // Pass encoding explicitly so Dirent stays string-typed under
-        // newer @types/node where the Buffer overload becomes the default.
-        entries = await fs.readdir(dir, { withFileTypes: true, encoding: 'utf8' })
-      } catch {
-        return
-      }
-      for (const entry of entries) {
-        const full = path.join(dir, entry.name)
-        if (entry.isDirectory()) {
-          await walk(full)
-        } else if (entry.isFile()) {
-          try {
-            const stat = await fs.stat(full)
-            const age = now - stat.mtimeMs
-            const isOrphanPart = entry.name.endsWith('.part')
-            const threshold = isOrphanPart ? this.orphanGraceMs : this.retentionMs
-            if (age > threshold) {
-              bytes += stat.size
-              await fs.unlink(full)
-              removed++
-            }
-          } catch {
-            // ignore races
-          }
-        }
-      }
-    }
-
-    await walk(this.root).catch(() => {})
-    return { removed, bytes }
-  }
-}

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

@@ -1,29 +0,0 @@
-/**
- * Shared attachment types for IM adapters.
- */
-
-import type { AttachmentRef } from '../ws-bridge.js'
-export type { AttachmentRef }
-
-/** Platform tag — used for local staging subdir and telemetry. */
-export type ImPlatform = 'feishu' | 'telegram'
-
-/** Result of downloading an IM resource into the local stage dir. */
-export interface LocalAttachment {
-  kind: 'image' | 'file'
-  name: string        // original filename, or synthesized if none
-  path: string        // absolute path on disk (under ~/.claude/im-downloads)
-  size: number        // bytes
-  mimeType: string    // detected or provided
-  buffer: Buffer      // raw bytes (kept so caller can choose base64 vs path)
-}
-
-/** Pending outbound media found in Agent stream output. */
-export interface PendingUpload {
-  id: string          // fingerprint, used for dedup
-  source:
-    | { kind: 'base64'; data: string; mime: string }
-    | { kind: 'path'; path: string; mime?: string }
-    | { kind: 'url'; url: string; mime?: string }
-  alt?: string
-}