bingocode 1.0.27 → 1.0.28

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

@@ -1,173 +0,0 @@
-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'))
-    }
-  })
-})

package/src/server/__tests__/conversations.test.ts

@@ -1,458 +0,0 @@
-/**
- * Tests for ConversationService and WebSocket chat integration
- *
- * ConversationService 管理 CLI 子进程的生命周期。
- * WebSocket 集成测试验证消息从客户端经过服务端到达 CLI 的完整流转。
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import * as os from 'os'
-import { fileURLToPath } from 'node:url'
-import { ConversationService } from '../services/conversationService.js'
-
-// ============================================================================
-// ConversationService unit tests
-// ============================================================================
-
-describe('ConversationService', () => {
-  it('should report no session for unknown ID', () => {
-    const svc = new ConversationService()
-    const sid = crypto.randomUUID()
-    expect(svc.hasSession(sid)).toBe(false)
-  })
-
-  it('should track active sessions as empty initially', () => {
-    const svc = new ConversationService()
-    expect(svc.getActiveSessions()).toEqual([])
-  })
-
-  it('should return false when sending message to non-existent session', async () => {
-    const svc = new ConversationService()
-    const result = await svc.sendMessage('no-such-session', 'hello')
-    expect(result).toBe(false)
-  })
-
-  it('should return false when responding to permission for non-existent session', () => {
-    const svc = new ConversationService()
-    const result = svc.respondToPermission('no-such-session', 'req-1', true)
-    expect(result).toBe(false)
-  })
-
-  it('should forward suggested permission updates for allow-for-session decisions', () => {
-    const svc = new ConversationService()
-    const sent: unknown[] = []
-
-    ;(svc as any).sessions.set('session-1', {
-      proc: null,
-      outputCallbacks: [],
-      workDir: process.cwd(),
-      sdkToken: 'token',
-      sdkSocket: {
-        send(data: string) {
-          sent.push(JSON.parse(data))
-        },
-      },
-      pendingOutbound: [],
-      stderrLines: [],
-      sdkMessages: [],
-      pendingPermissionRequests: new Map([
-        ['req-1', {
-          toolName: 'Bash',
-          input: { command: 'ls src' },
-          permissionSuggestions: [
-            {
-              type: 'addRules',
-              rules: [{ toolName: 'Bash', ruleContent: 'ls src' }],
-              behavior: 'allow',
-              destination: 'localSettings',
-            },
-          ],
-        }],
-      ]),
-    })
-
-    const result = svc.respondToPermission('session-1', 'req-1', true, 'always')
-
-    expect(result).toBe(true)
-    expect(sent).toHaveLength(1)
-    expect(sent[0]).toMatchObject({
-      type: 'control_response',
-      response: {
-        response: {
-          behavior: 'allow',
-          updatedPermissions: [
-            {
-              type: 'addRules',
-              rules: [{ toolName: 'Bash', ruleContent: 'ls src' }],
-              behavior: 'allow',
-              destination: 'session',
-            },
-          ],
-        },
-      },
-    })
-  })
-
-  it('should send set_permission_mode requests to active sessions', () => {
-    const svc = new ConversationService()
-    const sent: unknown[] = []
-
-    ;(svc as any).sessions.set('session-2', {
-      proc: null,
-      outputCallbacks: [],
-      workDir: process.cwd(),
-      sdkToken: 'token',
-      sdkSocket: {
-        send(data: string) {
-          sent.push(JSON.parse(data))
-        },
-      },
-      pendingOutbound: [],
-      stderrLines: [],
-      sdkMessages: [],
-      pendingPermissionRequests: new Map(),
-    })
-
-    const result = svc.setPermissionMode('session-2', 'acceptEdits')
-
-    expect(result).toBe(true)
-    expect(sent).toHaveLength(1)
-    expect(sent[0]).toMatchObject({
-      type: 'control_request',
-      request: {
-        subtype: 'set_permission_mode',
-        mode: 'acceptEdits',
-      },
-    })
-  })
-
-  it('should not inject a desktop-specific ask override in default permission mode', () => {
-    const svc = new ConversationService()
-    expect((svc as any).getPermissionArgs('default', false)).toEqual([
-      '--permission-mode',
-      'default',
-    ])
-  })
-
-  it('should return false when sending interrupt to non-existent session', () => {
-    const svc = new ConversationService()
-    const result = svc.sendInterrupt('no-such-session')
-    expect(result).toBe(false)
-  })
-
-  it('should not throw when stopping non-existent session', () => {
-    const svc = new ConversationService()
-    expect(() => svc.stopSession('no-such-session')).not.toThrow()
-  })
-
-  it('should not throw when registering callback for non-existent session', () => {
-    const svc = new ConversationService()
-    expect(() => svc.onOutput('no-such-session', () => {})).not.toThrow()
-  })
-})
-
-// ============================================================================
-// WebSocket integration tests (with mock CLI using the SDK websocket protocol)
-// ============================================================================
-
-describe('WebSocket Chat Integration', () => {
-  let server: ReturnType<typeof Bun.serve>
-  let baseUrl: string
-  let wsUrl: string
-  let tmpDir: string
-
-  async function withMockInitMode<T>(
-    mode: string | undefined,
-    callback: () => Promise<T>,
-  ): Promise<T> {
-    const previousMode = process.env.MOCK_SDK_INIT_MODE
-
-    if (mode) {
-      process.env.MOCK_SDK_INIT_MODE = mode
-    } else {
-      delete process.env.MOCK_SDK_INIT_MODE
-    }
-
-    try {
-      return await callback()
-    } finally {
-      if (previousMode === undefined) {
-        delete process.env.MOCK_SDK_INIT_MODE
-      } else {
-        process.env.MOCK_SDK_INIT_MODE = previousMode
-      }
-    }
-  }
-
-  async function runTurn(sessionId: string, content: string): Promise<any[]> {
-    const messages: any[] = []
-    const ws = new WebSocket(`${wsUrl}/ws/${sessionId}`)
-
-    await new Promise<void>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        ws.close()
-        reject(new Error(`Timed out waiting for completion for session ${sessionId}`))
-      }, 30000)
-
-      ws.onmessage = (e) => {
-        const msg = JSON.parse(e.data as string)
-        messages.push(msg)
-        if (msg.type === 'connected') {
-          ws.send(JSON.stringify({ type: 'user_message', content }))
-        }
-        if (msg.type === 'error') {
-          clearTimeout(timeout)
-          ws.close()
-          reject(new Error(msg.message))
-        }
-        if (msg.type === 'message_complete') {
-          clearTimeout(timeout)
-          ws.close()
-          resolve()
-        }
-      }
-
-      ws.onerror = () => {
-        clearTimeout(timeout)
-        ws.close()
-        reject(new Error(`WebSocket error for session ${sessionId}`))
-      }
-    })
-
-    return messages
-  }
-  const originalCliPath = process.env.CLAUDE_CLI_PATH
-
-  beforeAll(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-conv-'))
-    process.env.CLAUDE_CONFIG_DIR = tmpDir
-    process.env.CLAUDE_CLI_PATH = fileURLToPath(
-      new URL('./fixtures/mock-sdk-cli.ts', import.meta.url)
-    )
-    await fs.mkdir(path.join(tmpDir, 'projects'), { recursive: true })
-
-    const port = 15000 + Math.floor(Math.random() * 1000)
-    const { startServer } = await import('../index.js')
-    server = startServer(port, '127.0.0.1')
-    baseUrl = `http://127.0.0.1:${port}`
-    wsUrl = `ws://127.0.0.1:${port}`
-  })
-
-  afterAll(async () => {
-    server?.stop()
-    if (tmpDir) {
-      await fs.rm(tmpDir, { recursive: true, force: true })
-    }
-    if (originalCliPath) {
-      process.env.CLAUDE_CLI_PATH = originalCliPath
-    } else {
-      delete process.env.CLAUDE_CLI_PATH
-    }
-    delete process.env.CLAUDE_CONFIG_DIR
-  })
-
-  it('should connect and receive connected event', async () => {
-    const messages: any[] = []
-    const ws = new WebSocket(`${wsUrl}/ws/chat-test-1`)
-
-    await new Promise<void>((resolve) => {
-      ws.onmessage = (e) => {
-        messages.push(JSON.parse(e.data as string))
-        if (messages.length >= 1) {
-          ws.close()
-          resolve()
-        }
-      }
-      ws.onerror = () => {
-        ws.close()
-        resolve()
-      }
-      setTimeout(() => {
-        ws.close()
-        resolve()
-      }, 3000)
-    })
-
-    expect(messages[0].type).toBe('connected')
-    expect(messages[0].sessionId).toBe('chat-test-1')
-  })
-
-  it('should handle stop_generation and return idle status', async () => {
-    const messages: any[] = []
-    const ws = new WebSocket(`${wsUrl}/ws/chat-test-2`)
-
-    await new Promise<void>((resolve) => {
-      ws.onmessage = (e) => {
-        const msg = JSON.parse(e.data as string)
-        messages.push(msg)
-        if (msg.type === 'connected') {
-          ws.send(JSON.stringify({ type: 'stop_generation' }))
-        }
-        if (msg.type === 'status' && msg.state === 'idle') {
-          ws.close()
-          resolve()
-        }
-      }
-      ws.onerror = () => {
-        ws.close()
-        resolve()
-      }
-      setTimeout(() => {
-        ws.close()
-        resolve()
-      }, 3000)
-    })
-
-    expect(messages.some((m) => m.type === 'status' && m.state === 'idle')).toBe(true)
-  })
-
-  it('should send user_message and receive streamed SDK response', async () => {
-    const messages: any[] = []
-    const ws = new WebSocket(`${wsUrl}/ws/chat-test-3`)
-
-    await new Promise<void>((resolve) => {
-      ws.onmessage = (e) => {
-        const msg = JSON.parse(e.data as string)
-        messages.push(msg)
-        if (msg.type === 'connected') {
-          ws.send(
-            JSON.stringify({ type: 'user_message', content: 'Hello from test' })
-          )
-        }
-        // Wait until we receive completion after the streamed response
-        if (
-          msg.type === 'message_complete' &&
-          messages.some((entry) => entry.type === 'thinking')
-        ) {
-          ws.close()
-          resolve()
-        }
-      }
-      ws.onerror = () => {
-        ws.close()
-        resolve()
-      }
-      setTimeout(() => {
-        ws.close()
-        resolve()
-      }, 5000)
-    })
-
-    const types = messages.map((m) => m.type)
-    expect(types).toContain('connected')
-    expect(types).toContain('status')
-    // Mock SDK flow produces text streaming, thinking, and completion events.
-    expect(types).toContain('content_start')
-    expect(types).toContain('content_delta')
-    expect(types).toContain('thinking')
-    expect(types).toContain('message_complete')
-
-    // Verify thinking was first status
-    const statusMsgs = messages.filter((m) => m.type === 'status')
-    expect(statusMsgs[0].state).toBe('thinking')
-  })
-
-  it('should continue chat when SDK init arrives only after the first user turn', async () => {
-    const messages = await withMockInitMode('on_first_user', () =>
-      runTurn('chat-test-lazy-init', 'Hello after lazy init'),
-    )
-
-    expect(messages.some((m) => m.type === 'message_complete')).toBe(true)
-    expect(messages.some((m) => m.type === 'error')).toBe(false)
-    expect(
-      messages.some(
-        (m) => m.type === 'system_notification' && m.subtype === 'init',
-      ),
-    ).toBe(true)
-  })
-
-  it('should handle permission_response without error', async () => {
-    const messages: any[] = []
-    const ws = new WebSocket(`${wsUrl}/ws/chat-test-4`)
-
-    await new Promise<void>((resolve) => {
-      ws.onmessage = (e) => {
-        const msg = JSON.parse(e.data as string)
-        messages.push(msg)
-        if (msg.type === 'connected') {
-          // Send a permission response (no active session, should not crash)
-          ws.send(
-            JSON.stringify({
-              type: 'permission_response',
-              requestId: 'test-req-1',
-              allowed: true,
-            })
-          )
-          // Give a moment then close
-          setTimeout(() => {
-            ws.close()
-            resolve()
-          }, 500)
-        }
-      }
-      ws.onerror = () => {
-        ws.close()
-        resolve()
-      }
-      setTimeout(() => {
-        ws.close()
-        resolve()
-      }, 3000)
-    })
-
-    // Should have received connected and no error
-    expect(messages[0].type).toBe('connected')
-    expect(messages.some((m) => m.type === 'error')).toBe(false)
-  })
-
-  it('should handle ping/pong', async () => {
-    const messages: any[] = []
-    const ws = new WebSocket(`${wsUrl}/ws/chat-test-5`)
-
-    await new Promise<void>((resolve) => {
-      ws.onmessage = (e) => {
-        const msg = JSON.parse(e.data as string)
-        messages.push(msg)
-        if (msg.type === 'connected') {
-          ws.send(JSON.stringify({ type: 'ping' }))
-        }
-        if (msg.type === 'pong') {
-          ws.close()
-          resolve()
-        }
-      }
-      ws.onerror = () => {
-        ws.close()
-        resolve()
-      }
-      setTimeout(() => {
-        ws.close()
-        resolve()
-      }, 3000)
-    })
-
-    expect(messages.some((m) => m.type === 'pong')).toBe(true)
-  })
-
-  it('should start a placeholder REST session and continue it on a later reconnect', async () => {
-    const createRes = await fetch(`${baseUrl}/api/sessions`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ workDir: process.cwd() }),
-    })
-    expect(createRes.status).toBe(201)
-    const { sessionId } = await createRes.json() as { sessionId: string }
-
-    const firstTurn = await runTurn(sessionId, 'reply with first')
-    expect(firstTurn.some((m) => m.type === 'message_complete')).toBe(true)
-    expect(firstTurn.some((m) => m.type === 'error')).toBe(false)
-
-    await new Promise((resolve) => setTimeout(resolve, 1000))
-
-    const secondTurn = await runTurn(sessionId, 'reply with second')
-    expect(secondTurn.some((m) => m.type === 'message_complete')).toBe(true)
-    expect(secondTurn.some((m) => m.type === 'error')).toBe(false)
-  })
-})