bingocode 1.0.29 → 1.0.30

package/adapters/telegram/__tests__/media.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import { TelegramMediaService } from '../media.js'
+import { AttachmentStore } from '../../common/attachment/attachment-store.js'
+
+let tmpRoot: string
+let originalFetch: typeof fetch
+
+function makeMockBot() {
+  const fetchMock = mock(async (url: string | URL) => {
+    const u = typeof url === 'string' ? url : url.toString()
+    expect(u).toContain('/file/botFAKE_TOKEN/photos/abc.jpg')
+    return new Response(Buffer.from('PHOTODATA'), {
+      status: 200,
+      headers: { 'content-type': 'image/jpeg' },
+    })
+  })
+  ;(globalThis as any).fetch = fetchMock
+  return {
+    token: 'FAKE_TOKEN',
+    api: {
+      getFile: mock(async (fileId: string) => ({
+        file_id: fileId,
+        file_unique_id: 'unique',
+        file_path: 'photos/abc.jpg',
+      })),
+      sendPhoto: mock(async () => ({ message_id: 1 })),
+      sendDocument: mock(async () => ({ message_id: 2 })),
+    },
+    fetchMock,
+  }
+}
+
+beforeEach(async () => {
+  originalFetch = globalThis.fetch
+  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'tg-media-test-'))
+})
+
+afterEach(async () => {
+  globalThis.fetch = originalFetch
+  await fs.rm(tmpRoot, { recursive: true, force: true })
+})
+
+describe('TelegramMediaService', () => {
+  it('downloadFile fetches the real URL and stores a LocalAttachment', async () => {
+    const bot = makeMockBot()
+    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
+    const svc = new TelegramMediaService(bot as any, store)
+    const local = await svc.downloadFile('fid_123', 'sess-1', {
+      fileName: 'abc.jpg',
+      mimeType: 'image/jpeg',
+    })
+    expect(local.kind).toBe('image')
+    expect(local.name).toBe('abc.jpg')
+    expect(local.size).toBe('PHOTODATA'.length)
+    expect(local.buffer.toString()).toBe('PHOTODATA')
+    const onDisk = await fs.readFile(local.path)
+    expect(onDisk.toString()).toBe('PHOTODATA')
+  })
+
+  it('sendPhoto calls bot.api.sendPhoto with InputFile-like payload', async () => {
+    const bot = makeMockBot()
+    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
+    const svc = new TelegramMediaService(bot as any, store)
+    await svc.sendPhoto(42, Buffer.from('IMG'), 'caption text')
+    expect(bot.api.sendPhoto).toHaveBeenCalledTimes(1)
+    const args = (bot.api.sendPhoto as any).mock.calls[0]
+    expect(args[0]).toBe(42)
+    // grammY InputFile wraps the buffer; just verify it's an object.
+    expect(args[1]).toBeDefined()
+    expect(args[2]?.caption).toBe('caption text')
+  })
+
+  it('sendDocument calls bot.api.sendDocument', async () => {
+    const bot = makeMockBot()
+    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
+    const svc = new TelegramMediaService(bot as any, store)
+    await svc.sendDocument(42, Buffer.from('DOC'), 'spec.pdf')
+    expect(bot.api.sendDocument).toHaveBeenCalledTimes(1)
+    const args = (bot.api.sendDocument as any).mock.calls[0]
+    expect(args[0]).toBe(42)
+    expect(args[1]).toBeDefined()
+  })
+})

package/adapters/telegram/__tests__/telegram.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'bun:test'
+import { splitMessage, formatPermissionRequest, truncateInput, escapeMarkdownV2 } from '../../common/format.js'
+
+/**
+ * Telegram Adapter 翻译逻辑测试
+ *
+ * 由于 grammy Bot 需要实际 Token 才能初始化，
+ * 这里测试的是不依赖 Bot 实例的核心翻译逻辑。
+ */
+
+describe('Telegram message formatting', () => {
+  describe('long message splitting', () => {
+    it('splits messages at Telegram 4096 char limit', () => {
+      const longText = 'a'.repeat(8000)
+      const chunks = splitMessage(longText, 4000)
+      expect(chunks.length).toBe(2)
+      expect(chunks[0]!.length).toBeLessThanOrEqual(4000)
+      expect(chunks[1]!.length).toBeLessThanOrEqual(4000)
+    })
+
+    it('keeps short messages as single chunk', () => {
+      const chunks = splitMessage('Hello World', 4000)
+      expect(chunks).toEqual(['Hello World'])
+    })
+
+    it('splits at paragraph boundary when possible', () => {
+      const text = 'A'.repeat(2000) + '\n\n' + 'B'.repeat(2000)
+      const chunks = splitMessage(text, 3000)
+      expect(chunks.length).toBe(2)
+    })
+  })
+
+  describe('permission request formatting', () => {
+    it('formats Bash command request', () => {
+      const result = formatPermissionRequest('Bash', { command: 'npm test' }, 'abcde')
+      expect(result).toContain('🔐')
+      expect(result).toContain('Bash')
+      expect(result).toContain('npm test')
+      expect(result).toContain('abcde')
+    })
+
+    it('formats Write file request', () => {
+      const result = formatPermissionRequest(
+        'Write',
+        { file_path: '/src/index.ts', content: 'console.log("hello")' },
+        'fghij',
+      )
+      expect(result).toContain('Write')
+      expect(result).toContain('index.ts')
+      expect(result).toContain('fghij')
+    })
+
+    it('truncates long input in permission request', () => {
+      const longInput = { command: 'x'.repeat(500) }
+      const result = formatPermissionRequest('Bash', longInput, 'xxxxx')
+      expect(result.length).toBeLessThan(600)
+    })
+  })
+
+  describe('callback_data parsing', () => {
+    it('parses permit:requestId:yes format', () => {
+      const data = 'permit:abcde:yes'
+      const parts = data.split(':')
+      expect(parts[0]).toBe('permit')
+      expect(parts[1]).toBe('abcde')
+      expect(parts[2]).toBe('yes')
+    })
+
+    it('parses permit:requestId:no format', () => {
+      const data = 'permit:abcde:no'
+      const parts = data.split(':')
+      expect(parts[2]).toBe('no')
+    })
+
+    it('ignores non-permit callbacks', () => {
+      const data = 'other:action'
+      expect(data.startsWith('permit:')).toBe(false)
+    })
+  })
+
+  describe('MarkdownV2 escaping', () => {
+    it('escapes underscores', () => {
+      expect(escapeMarkdownV2('hello_world')).toBe('hello\\_world')
+    })
+
+    it('escapes multiple special chars', () => {
+      const result = escapeMarkdownV2('file.ts (line 42)')
+      expect(result).toBe('file\\.ts \\(line 42\\)')
+    })
+
+    it('handles code blocks safely', () => {
+      const result = escapeMarkdownV2('`code`')
+      expect(result).toBe('\\`code\\`')
+    })
+  })
+
+  describe('whitelist logic', () => {
+    it('empty allowedUsers means allow all', () => {
+      const allowedUsers: number[] = []
+      const isAllowed = (userId: number) =>
+        allowedUsers.length === 0 || allowedUsers.includes(userId)
+      expect(isAllowed(12345)).toBe(true)
+      expect(isAllowed(99999)).toBe(true)
+    })
+
+    it('non-empty allowedUsers filters correctly', () => {
+      const allowedUsers = [111, 222]
+      const isAllowed = (userId: number) =>
+        allowedUsers.length === 0 || allowedUsers.includes(userId)
+      expect(isAllowed(111)).toBe(true)
+      expect(isAllowed(222)).toBe(true)
+      expect(isAllowed(333)).toBe(false)
+    })
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.0.29",
+  "version": "1.0.30",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/server/__tests__/conversation-service.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { ConversationService } from '../services/conversationService.js'
+
+describe('ConversationService', () => {
+  let tmpDir: string
+  let originalConfigDir: string | undefined
+  let originalAuthToken: string | undefined
+  let originalBaseUrl: string | undefined
+  let originalModel: string | undefined
+  let originalEntrypoint: string | undefined
+  let originalOAuthToken: string | undefined
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'bingo-conversation-service-'))
+    originalConfigDir = process.env.CLAUDE_CONFIG_DIR
+    originalAuthToken = process.env.ANTHROPIC_AUTH_TOKEN
+    originalBaseUrl = process.env.ANTHROPIC_BASE_URL
+    originalModel = process.env.ANTHROPIC_MODEL
+    originalEntrypoint = process.env.CLAUDE_CODE_ENTRYPOINT
+    originalOAuthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN
+
+    process.env.CLAUDE_CONFIG_DIR = tmpDir
+    process.env.ANTHROPIC_AUTH_TOKEN = 'test-token'
+    process.env.ANTHROPIC_BASE_URL = 'https://example.invalid/anthropic'
+    process.env.ANTHROPIC_MODEL = 'test-model'
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = 'inherited-parent-oauth-token'
+    // Clear inherited CLAUDE_CODE_ENTRYPOINT so tests can assert whether
+    // buildChildEnv injects it or not without interference from the shell env.
+    delete process.env.CLAUDE_CODE_ENTRYPOINT
+  })
+
+  afterEach(async () => {
+    if (originalConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR
+    else process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+
+    if (originalAuthToken === undefined) delete process.env.ANTHROPIC_AUTH_TOKEN
+    else process.env.ANTHROPIC_AUTH_TOKEN = originalAuthToken
+
+    if (originalBaseUrl === undefined) delete process.env.ANTHROPIC_BASE_URL
+    else process.env.ANTHROPIC_BASE_URL = originalBaseUrl
+
+    if (originalModel === undefined) delete process.env.ANTHROPIC_MODEL
+    else process.env.ANTHROPIC_MODEL = originalModel
+
+    if (originalEntrypoint === undefined) delete process.env.CLAUDE_CODE_ENTRYPOINT
+    else process.env.CLAUDE_CODE_ENTRYPOINT = originalEntrypoint
+
+    if (originalOAuthToken === undefined) delete process.env.CLAUDE_CODE_OAUTH_TOKEN
+    else process.env.CLAUDE_CODE_OAUTH_TOKEN = originalOAuthToken
+
+    await fs.rm(tmpDir, { recursive: true, force: true })
+  })
+
+  test('keeps inherited provider env when no desktop provider config exists', async () => {
+    const service = new ConversationService() as any
+    const env = (await service.buildChildEnv('D:\\workspace\\code\\myself_code\\bingo')) as Record<string, string>
+
+    expect(env.ANTHROPIC_AUTH_TOKEN).toBe('test-token')
+    expect(env.ANTHROPIC_BASE_URL).toBe('https://example.invalid/anthropic')
+    expect(env.ANTHROPIC_MODEL).toBe('test-model')
+  })
+
+  test('strips inherited provider env when desktop provider config exists', async () => {
+    const ccHahaDir = path.join(tmpDir, 'bingo')
+    await fs.mkdir(ccHahaDir, { recursive: true })
+    await fs.writeFile(
+      path.join(ccHahaDir, 'providers.json'),
+      JSON.stringify({ activeId: null, providers: [] }),
+      'utf-8',
+    )
+
+    const service = new ConversationService() as any
+    const env = (await service.buildChildEnv('D:\\workspace\\code\\myself_code\\bingo')) as Record<string, string>
+
+    expect(env.ANTHROPIC_AUTH_TOKEN).toBeUndefined()
+    expect(env.ANTHROPIC_BASE_URL).toBeUndefined()
+    expect(env.ANTHROPIC_MODEL).toBeUndefined()
+  })
+
+  test('buildChildEnv injects CLAUDE_CODE_OAUTH_TOKEN when official mode + haha oauth token exists', async () => {
+    const ccHahaDir = path.join(tmpDir, 'bingo')
+    await fs.mkdir(ccHahaDir, { recursive: true })
+    await fs.writeFile(
+      path.join(ccHahaDir, 'settings.json'),
+      JSON.stringify({ env: {} }),
+      'utf-8',
+    )
+
+    const { hahaOAuthService } = await import('../services/hahaOAuthService.js')
+    await hahaOAuthService.saveTokens({
+      accessToken: 'haha-fresh-token',
+      refreshToken: 'haha-refresh-xxx',
+      expiresAt: Date.now() + 30 * 60_000,
+      scopes: ['user:inference'],
+      subscriptionType: 'max',
+    })
+
+    const service = new ConversationService() as any
+    const env = (await service.buildChildEnv('/tmp')) as Record<string, string>
+
+    expect(env.CLAUDE_CODE_ENTRYPOINT).toBe('claude-desktop')
+    expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBe('haha-fresh-token')
+  })
+
+  test('buildChildEnv does NOT inject CLAUDE_CODE_OAUTH_TOKEN when not official mode', async () => {
+    const ccHahaDir = path.join(tmpDir, 'bingo')
+    await fs.mkdir(ccHahaDir, { recursive: true })
+    await fs.writeFile(
+      path.join(ccHahaDir, 'settings.json'),
+      JSON.stringify({ env: { ANTHROPIC_AUTH_TOKEN: 'custom-provider-token' } }),
+      'utf-8',
+    )
+
+    const { hahaOAuthService } = await import('../services/hahaOAuthService.js')
+    await hahaOAuthService.saveTokens({
+      accessToken: 'haha-token-should-not-be-used',
+      refreshToken: null,
+      expiresAt: null,
+      scopes: [],
+      subscriptionType: null,
+    })
+
+    const service = new ConversationService() as any
+    const env = (await service.buildChildEnv('/tmp')) as Record<string, string>
+
+    expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBeUndefined()
+    expect(env.CLAUDE_CODE_ENTRYPOINT).toBeUndefined()
+  })
+
+  test('buildChildEnv does not leak inherited CLAUDE_CODE_OAUTH_TOKEN when official token is unavailable', async () => {
+    const ccHahaDir = path.join(tmpDir, 'bingo')
+    await fs.mkdir(ccHahaDir, { recursive: true })
+    await fs.writeFile(
+      path.join(ccHahaDir, 'settings.json'),
+      JSON.stringify({ env: {} }),
+      'utf-8',
+    )
+
+    const service = new ConversationService() as any
+    const env = (await service.buildChildEnv('/tmp')) as Record<string, string>
+
+    expect(env.CLAUDE_CODE_ENTRYPOINT).toBe('claude-desktop')
+    expect(env.CLAUDE_CODE_OAUTH_TOKEN).toBeUndefined()
+  })
+
+  test('buildChildEnv injects desktop Computer Use host bundle id for sdk sessions', async () => {
+    const service = new ConversationService() as any
+    const env = (await service.buildChildEnv(
+      '/tmp',
+      'ws://127.0.0.1:3456/sdk/test-session?token=test-token',
+    )) as Record<string, string>
+
+    expect(env.CC_HAHA_COMPUTER_USE_HOST_BUNDLE_ID).toBe(
+      'com.claude-code-haha.desktop',
+    )
+    expect(env.CC_HAHA_DESKTOP_SERVER_URL).toBe('http://127.0.0.1:3456')
+  })
+
+  test('uses bun entrypoint fallback on Windows dev mode', () => {
+    const service = new ConversationService() as any
+    const args = service.resolveCliArgs(['--print'])
+
+    if (process.platform === 'win32') {
+      expect(args[0]).toBe(process.execPath)
+      expect(args[1]).toContain(path.join('src', 'entrypoints', 'cli.tsx'))
+    } else {
+      expect(args[0]).toContain(path.join('bin', 'claude-haha'))
+    }
+  })
+})