bingocode 1.0.28 → 1.0.30

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

@@ -0,0 +1,627 @@
+/**
+ * Unit tests for TeamService and Teams API
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import { TeamService } from '../services/teamService.js'
+
+// ============================================================================
+// Test helpers
+// ============================================================================
+
+let tmpDir: string
+let service: TeamService
+
+async function setupTmpConfigDir(): Promise<string> {
+  tmpDir = path.join(
+    os.tmpdir(),
+    `claude-teams-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  await fs.mkdir(path.join(tmpDir, 'teams'), { recursive: true })
+  await fs.mkdir(path.join(tmpDir, 'projects'), { recursive: true })
+  process.env.CLAUDE_CONFIG_DIR = tmpDir
+  return tmpDir
+}
+
+async function cleanupTmpDir(): Promise<void> {
+  if (tmpDir) {
+    await fs.rm(tmpDir, { recursive: true, force: true })
+  }
+  delete process.env.CLAUDE_CONFIG_DIR
+}
+
+/** Write a team config.json to the temp directory. */
+async function writeTeamConfig(
+  teamName: string,
+  config: Record<string, unknown>,
+): Promise<string> {
+  const teamDir = path.join(tmpDir, 'teams', teamName)
+  await fs.mkdir(teamDir, { recursive: true })
+  const configPath = path.join(teamDir, 'config.json')
+  await fs.writeFile(configPath, JSON.stringify(config), 'utf-8')
+  return configPath
+}
+
+/** Write a mock JSONL transcript file under projects. */
+async function writeTranscriptFile(
+  projectDir: string,
+  sessionId: string,
+  entries: Record<string, unknown>[],
+): Promise<string> {
+  const dir = path.join(tmpDir, 'projects', projectDir)
+  await fs.mkdir(dir, { recursive: true })
+  const filePath = path.join(dir, `${sessionId}.jsonl`)
+  const content = entries.map((e) => JSON.stringify(e)).join('\n') + '\n'
+  await fs.writeFile(filePath, content, 'utf-8')
+  return filePath
+}
+
+async function writeSubagentTranscriptFile(
+  projectDir: string,
+  leadSessionId: string,
+  fileName: string,
+  entries: Record<string, unknown>[],
+): Promise<string> {
+  const dir = path.join(tmpDir, 'projects', projectDir, leadSessionId, 'subagents')
+  await fs.mkdir(dir, { recursive: true })
+  const filePath = path.join(dir, fileName)
+  const content = entries.map((e) => JSON.stringify(e)).join('\n') + '\n'
+  await fs.writeFile(filePath, content, 'utf-8')
+  return filePath
+}
+
+/** Create a standard team config for testing. */
+function makeTeamConfig(overrides?: Record<string, unknown>) {
+  return {
+    name: 'test-team',
+    description: 'A test team',
+    createdAt: 1700000000000,
+    leadAgentId: 'agent-lead',
+    members: [
+      {
+        agentId: 'agent-lead',
+        name: 'Lead Agent',
+        agentType: 'lead',
+        model: 'claude-opus-4-7',
+        color: '#ff0000',
+        joinedAt: 1700000000000,
+        tmuxPaneId: '%0',
+        cwd: '/tmp/project',
+        sessionId: 'session-lead-001',
+        isActive: true,
+      },
+      {
+        agentId: 'agent-worker',
+        name: 'Worker Agent',
+        agentType: 'worker',
+        model: 'claude-sonnet-4-20250514',
+        color: '#00ff00',
+        joinedAt: 1700000001000,
+        tmuxPaneId: '%1',
+        cwd: '/tmp/project/src',
+        sessionId: 'session-worker-001',
+        isActive: false,
+      },
+    ],
+    ...overrides,
+  }
+}
+
+// ============================================================================
+// TeamService tests
+// ============================================================================
+
+describe('TeamService', () => {
+  beforeEach(async () => {
+    await setupTmpConfigDir()
+    service = new TeamService()
+  })
+
+  afterEach(async () => {
+    await cleanupTmpDir()
+  })
+
+  // --------------------------------------------------------------------------
+  // listTeams
+  // --------------------------------------------------------------------------
+
+  it('should return empty list when no teams exist', async () => {
+    const teams = await service.listTeams()
+    expect(teams).toEqual([])
+  })
+
+  it('should return empty list when teams directory does not exist', async () => {
+    await fs.rm(path.join(tmpDir, 'teams'), { recursive: true, force: true })
+    const teams = await service.listTeams()
+    expect(teams).toEqual([])
+  })
+
+  it('should list teams from config files', async () => {
+    await writeTeamConfig('alpha', makeTeamConfig({ name: 'alpha' }))
+    await writeTeamConfig('beta', makeTeamConfig({ name: 'beta', description: 'Beta team' }))
+
+    const teams = await service.listTeams()
+    expect(teams).toHaveLength(2)
+
+    const names = teams.map((t) => t.name).sort()
+    expect(names).toEqual(['alpha', 'beta'])
+  })
+
+  it('should compute memberCount and activeMemberCount', async () => {
+    await writeTeamConfig('gamma', makeTeamConfig({ name: 'gamma' }))
+
+    const teams = await service.listTeams()
+    expect(teams).toHaveLength(1)
+    expect(teams[0]!.memberCount).toBe(2)
+    expect(teams[0]!.activeMemberCount).toBe(1) // only lead is active
+  })
+
+  it('should skip malformed team directories', async () => {
+    // Create a team dir with invalid JSON
+    const badDir = path.join(tmpDir, 'teams', 'bad-team')
+    await fs.mkdir(badDir, { recursive: true })
+    await fs.writeFile(path.join(badDir, 'config.json'), 'not json', 'utf-8')
+
+    // Also create a valid team
+    await writeTeamConfig('good-team', makeTeamConfig({ name: 'good-team' }))
+
+    const teams = await service.listTeams()
+    expect(teams).toHaveLength(1)
+    expect(teams[0]!.name).toBe('good-team')
+  })
+
+  // --------------------------------------------------------------------------
+  // getTeam
+  // --------------------------------------------------------------------------
+
+  it('should return team detail with members', async () => {
+    await writeTeamConfig(
+      'detail-team',
+      makeTeamConfig({
+        name: 'detail-team',
+        leadSessionId: 'lead-session-xyz',
+      }),
+    )
+
+    const detail = await service.getTeam('detail-team')
+    expect(detail.name).toBe('detail-team')
+    expect(detail.leadAgentId).toBe('agent-lead')
+    expect(detail.leadSessionId).toBe('lead-session-xyz')
+    expect(detail.members).toHaveLength(2)
+    expect(detail.members[0]!.agentId).toBe('agent-lead')
+    expect(detail.members[1]!.agentId).toBe('agent-worker')
+  })
+
+  it('should discover missing in-process members from subagent transcripts', async () => {
+    await writeTeamConfig(
+      'subagent-team',
+      makeTeamConfig({
+        name: 'subagent-team',
+        leadSessionId: 'lead-session-subagents',
+        members: [
+          {
+            agentId: 'agent-lead',
+            name: 'Lead Agent',
+            agentType: 'lead',
+            joinedAt: 1700000000000,
+            tmuxPaneId: '%0',
+            cwd: '/tmp/project',
+            sessionId: 'session-lead-001',
+            isActive: true,
+          },
+        ],
+      }),
+    )
+
+    await writeSubagentTranscriptFile(
+      '-tmp-project',
+      'lead-session-subagents',
+      'agent-1.jsonl',
+      [
+        {
+          agentName: 'security-reviewer',
+          agentId: 'security-reviewer@subagent-team',
+          timestamp: '2026-01-01T00:00:00.000Z',
+        },
+      ],
+    )
+
+    const detail = await service.getTeam('subagent-team')
+    expect(detail.members.some((member) => member.name === 'security-reviewer')).toBe(true)
+  })
+
+  it('should derive running status for active member', async () => {
+    await writeTeamConfig('status-team', makeTeamConfig({ name: 'status-team' }))
+
+    const detail = await service.getTeam('status-team')
+    const lead = detail.members.find((m) => m.agentId === 'agent-lead')!
+    expect(lead.status).toBe('running')
+  })
+
+  it('should derive idle status for inactive member', async () => {
+    await writeTeamConfig('status-team', makeTeamConfig({ name: 'status-team' }))
+
+    const detail = await service.getTeam('status-team')
+    const worker = detail.members.find((m) => m.agentId === 'agent-worker')!
+    expect(worker.status).toBe('idle')
+  })
+
+  it('should derive running status when isActive is undefined', async () => {
+    const config = makeTeamConfig({ name: 'undef-team' })
+    // Remove isActive from the first member to simulate undefined
+    delete (config.members[0] as Record<string, unknown>).isActive
+    await writeTeamConfig('undef-team', config)
+
+    const detail = await service.getTeam('undef-team')
+    const lead = detail.members.find((m) => m.agentId === 'agent-lead')!
+    expect(lead.status).toBe('running')
+  })
+
+  it('should throw 404 for non-existent team', async () => {
+    expect(service.getTeam('nonexistent')).rejects.toThrow('Team not found')
+  })
+
+  // --------------------------------------------------------------------------
+  // getMemberTranscript
+  // --------------------------------------------------------------------------
+
+  it('should return transcript messages for a member', async () => {
+    await writeTeamConfig('transcript-team', makeTeamConfig({ name: 'transcript-team' }))
+
+    // Write a mock transcript JSONL for the lead session
+    await writeTranscriptFile('-tmp-project', 'session-lead-001', [
+      {
+        type: 'file-history-snapshot',
+        messageId: 'snap-1',
+        snapshot: {},
+      },
+      {
+        type: 'user',
+        uuid: 'msg-user-1',
+        message: { role: 'user', content: 'Hello team' },
+        timestamp: '2026-01-01T00:01:00.000Z',
+      },
+      {
+        type: 'assistant',
+        uuid: 'msg-asst-1',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Hi! Ready to help.' }],
+        },
+        timestamp: '2026-01-01T00:02:00.000Z',
+      },
+    ])
+
+    const messages = await service.getMemberTranscript(
+      'transcript-team',
+      'agent-lead',
+    )
+    expect(messages).toHaveLength(2)
+    expect(messages[0]!.type).toBe('user')
+    expect(messages[0]!.id).toBe('msg-user-1')
+    expect(messages[1]!.type).toBe('assistant')
+  })
+
+  it('should return empty array when member has no sessionId', async () => {
+    const config = makeTeamConfig({ name: 'no-session-team' })
+    delete (config.members[0] as Record<string, unknown>).sessionId
+    await writeTeamConfig('no-session-team', config)
+
+    const messages = await service.getMemberTranscript(
+      'no-session-team',
+      'agent-lead',
+    )
+    expect(messages).toEqual([])
+  })
+
+  it('should return empty array when transcript file not found', async () => {
+    await writeTeamConfig('no-file-team', makeTeamConfig({ name: 'no-file-team' }))
+
+    // Don't write any transcript file
+    const messages = await service.getMemberTranscript(
+      'no-file-team',
+      'agent-lead',
+    )
+    expect(messages).toEqual([])
+  })
+
+  it('should throw 404 for unknown member', async () => {
+    await writeTeamConfig('member-team', makeTeamConfig({ name: 'member-team' }))
+
+    expect(
+      service.getMemberTranscript('member-team', 'nonexistent-agent'),
+    ).rejects.toThrow('Team member not found')
+  })
+
+  it('should skip meta entries in transcript', async () => {
+    await writeTeamConfig('meta-team', makeTeamConfig({ name: 'meta-team' }))
+
+    await writeTranscriptFile('-tmp-project', 'session-lead-001', [
+      {
+        type: 'user',
+        uuid: 'msg-meta',
+        message: { role: 'user', content: 'internal meta' },
+        isMeta: true,
+        timestamp: '2026-01-01T00:00:30.000Z',
+      },
+      {
+        type: 'user',
+        uuid: 'msg-real',
+        message: { role: 'user', content: 'Real message' },
+        timestamp: '2026-01-01T00:01:00.000Z',
+      },
+    ])
+
+    const messages = await service.getMemberTranscript('meta-team', 'agent-lead')
+    expect(messages).toHaveLength(1)
+    expect(messages[0]!.id).toBe('msg-real')
+  })
+
+  // --------------------------------------------------------------------------
+  // sendMemberMessage
+  // --------------------------------------------------------------------------
+
+  it('should write member messages into the teammate inbox', async () => {
+    await writeTeamConfig('mailbox-team', makeTeamConfig({ name: 'mailbox-team' }))
+
+    await service.sendMemberMessage(
+      'mailbox-team',
+      'agent-worker',
+      'Please review the latest diff',
+    )
+
+    const inboxPath = path.join(
+      tmpDir,
+      'teams',
+      'mailbox-team',
+      'inboxes',
+      'Worker-Agent.json',
+    )
+    const rawInbox = await fs.readFile(inboxPath, 'utf-8')
+    const inbox = JSON.parse(rawInbox) as Array<{
+      from: string
+      text: string
+      read: boolean
+    }>
+
+    expect(inbox).toHaveLength(1)
+    expect(inbox[0]).toMatchObject({
+      from: 'user',
+      text: 'Please review the latest diff',
+      read: false,
+    })
+  })
+
+  it('should send messages to inbox-discovered members', async () => {
+    await writeTeamConfig('inbox-team', makeTeamConfig({ name: 'inbox-team' }))
+    const inboxDir = path.join(tmpDir, 'teams', 'inbox-team', 'inboxes')
+    await fs.mkdir(inboxDir, { recursive: true })
+    await fs.writeFile(path.join(inboxDir, 'security-reviewer.json'), '[]', 'utf-8')
+
+    await service.sendMemberMessage(
+      'inbox-team',
+      'security-reviewer@inbox-team',
+      'Check the auth changes',
+    )
+
+    const rawInbox = await fs.readFile(
+      path.join(inboxDir, 'security-reviewer.json'),
+      'utf-8',
+    )
+    const inbox = JSON.parse(rawInbox) as Array<{ text: string }>
+    expect(inbox.at(-1)?.text).toBe('Check the auth changes')
+  })
+
+  // --------------------------------------------------------------------------
+  // deleteTeam
+  // --------------------------------------------------------------------------
+
+  it('should delete a team with no active members', async () => {
+    const config = makeTeamConfig({ name: 'deletable' })
+    // Set all members to inactive
+    for (const member of config.members) {
+      ;(member as Record<string, unknown>).isActive = false
+    }
+    await writeTeamConfig('deletable', config)
+
+    await service.deleteTeam('deletable')
+
+    // Team dir should be gone
+    const teamDir = path.join(tmpDir, 'teams', 'deletable')
+    expect(fs.access(teamDir)).rejects.toThrow()
+  })
+
+  it('should refuse to delete a team with active members', async () => {
+    await writeTeamConfig('active-team', makeTeamConfig({ name: 'active-team' }))
+
+    expect(service.deleteTeam('active-team')).rejects.toThrow(
+      'has active members',
+    )
+  })
+
+  it('should throw 404 when deleting non-existent team', async () => {
+    expect(service.deleteTeam('ghost')).rejects.toThrow('Team not found')
+  })
+})
+
+// ============================================================================
+// Teams API integration tests
+// ============================================================================
+
+describe('Teams API', () => {
+  let baseUrl: string
+  let server: ReturnType<typeof Bun.serve> | null = null
+
+  beforeEach(async () => {
+    await setupTmpConfigDir()
+    service = new TeamService()
+
+    const { handleTeamsApi } = await import('../api/teams.js')
+
+    const port = 40000 + Math.floor(Math.random() * 10000)
+    baseUrl = `http://127.0.0.1:${port}`
+
+    server = Bun.serve({
+      port,
+      hostname: '127.0.0.1',
+
+      async fetch(req) {
+        const url = new URL(req.url)
+        const segments = url.pathname.split('/').filter(Boolean)
+
+        if (segments[0] === 'api' && segments[1] === 'teams') {
+          return handleTeamsApi(req, url, segments)
+        }
+
+        return new Response('Not Found', { status: 404 })
+      },
+    })
+  })
+
+  afterEach(async () => {
+    if (server) {
+      server.stop(true)
+      server = null
+    }
+    await cleanupTmpDir()
+  })
+
+  it('GET /api/teams should return empty list', async () => {
+    const res = await fetch(`${baseUrl}/api/teams`)
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as { teams: unknown[] }
+    expect(body.teams).toEqual([])
+  })
+
+  it('GET /api/teams should list teams', async () => {
+    await writeTeamConfig('api-team', makeTeamConfig({ name: 'api-team' }))
+
+    const res = await fetch(`${baseUrl}/api/teams`)
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as { teams: Array<{ name: string }> }
+    expect(body.teams).toHaveLength(1)
+    expect(body.teams[0]!.name).toBe('api-team')
+  })
+
+  it('GET /api/teams/:name should return team detail', async () => {
+    await writeTeamConfig(
+      'detail',
+      makeTeamConfig({ name: 'detail', leadSessionId: 'leader-session-id' }),
+    )
+
+    const res = await fetch(`${baseUrl}/api/teams/detail`)
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as {
+      name: string
+      leadAgentId: string
+      leadSessionId?: string
+      members: Array<{ agentId: string }>
+    }
+    expect(body.name).toBe('detail')
+    expect(body.leadAgentId).toBe('agent-lead')
+    expect(body.leadSessionId).toBe('leader-session-id')
+    expect(body.members).toHaveLength(2)
+  })
+
+  it('GET /api/teams/:name should 404 for unknown team', async () => {
+    const res = await fetch(`${baseUrl}/api/teams/nonexistent`)
+    expect(res.status).toBe(404)
+  })
+
+  it('GET /api/teams/:name/members/:id/transcript should return messages', async () => {
+    await writeTeamConfig('t-team', makeTeamConfig({ name: 't-team' }))
+
+    await writeTranscriptFile('-tmp-project', 'session-lead-001', [
+      {
+        type: 'user',
+        uuid: 'u1',
+        message: { role: 'user', content: 'Hello' },
+        timestamp: '2026-01-01T00:01:00.000Z',
+      },
+    ])
+
+    const res = await fetch(
+      `${baseUrl}/api/teams/t-team/members/agent-lead/transcript`,
+    )
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as {
+      messages: Array<{ id: string; type: string }>
+    }
+    expect(body.messages).toHaveLength(1)
+    expect(body.messages[0]!.type).toBe('user')
+  })
+
+  it('GET /api/teams/:name/members/:id/transcript should 404 for unknown member', async () => {
+    await writeTeamConfig('t2-team', makeTeamConfig({ name: 't2-team' }))
+
+    const res = await fetch(
+      `${baseUrl}/api/teams/t2-team/members/unknown-agent/transcript`,
+    )
+    expect(res.status).toBe(404)
+  })
+
+  it('POST /api/teams/:name/members/:id/messages should enqueue a mailbox message', async () => {
+    await writeTeamConfig('send-team', makeTeamConfig({ name: 'send-team' }))
+
+    const res = await fetch(
+      `${baseUrl}/api/teams/send-team/members/agent-worker/messages`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ content: 'Please continue with the failing test' }),
+      },
+    )
+
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as { ok: boolean }
+    expect(body.ok).toBe(true)
+
+    const rawInbox = await fs.readFile(
+      path.join(tmpDir, 'teams', 'send-team', 'inboxes', 'Worker-Agent.json'),
+      'utf-8',
+    )
+    const inbox = JSON.parse(rawInbox) as Array<{ text: string }>
+    expect(inbox.at(-1)?.text).toBe('Please continue with the failing test')
+  })
+
+  it('DELETE /api/teams/:name should delete team', async () => {
+    const config = makeTeamConfig({ name: 'del-team' })
+    for (const member of (config as { members: Array<Record<string, unknown>> }).members) {
+      member.isActive = false
+    }
+    await writeTeamConfig('del-team', config)
+
+    const res = await fetch(`${baseUrl}/api/teams/del-team`, {
+      method: 'DELETE',
+    })
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as { ok: boolean }
+    expect(body.ok).toBe(true)
+
+    // Verify it's gone
+    const res2 = await fetch(`${baseUrl}/api/teams/del-team`)
+    expect(res2.status).toBe(404)
+  })
+
+  it('DELETE /api/teams/:name should 409 when team has active members', async () => {
+    await writeTeamConfig('active', makeTeamConfig({ name: 'active' }))
+
+    const res = await fetch(`${baseUrl}/api/teams/active`, {
+      method: 'DELETE',
+    })
+    expect(res.status).toBe(409)
+  })
+
+  it('POST /api/teams should return 405', async () => {
+    const res = await fetch(`${baseUrl}/api/teams`, { method: 'POST' })
+    expect(res.status).toBe(405)
+  })
+})

package/src/server/middleware/cors.test.ts

@@ -0,0 +1,27 @@
+//@C:ID=M.CT.corsTest;K=M;V=1.0;P=Import test dependencies;D=API;M=CORS;S=Testing
+import { describe, expect, it } from 'bun:test'
+import { corsHeaders } from './cors'
+
+//@C:ID=F.CT.testCorsHeaders;K=F;V=1.0;P=Test CORS header generation functionality;D=API;M=CORS;S=Testing;In=void;Out=void
+describe('corsHeaders', () => {
+  console.log("F.CT.testCorsHeaders");
+  
+  ///@C:CT.TestLocalhostOrigins
+  it('allows localhost browser origins', () => {
+    expect(corsHeaders('http://127.0.0.1:1420')['Access-Control-Allow-Origin']).toBe('http://127.0.0.1:1420')
+    expect(corsHeaders('http://localhost:3000')['Access-Control-Allow-Origin']).toBe('http://localhost:3000')
+  })
+
+  ///@C:CT.TestTauriOrigins
+  it('allows tauri webview origins used in production builds', () => {
+    expect(corsHeaders('http://tauri.localhost')['Access-Control-Allow-Origin']).toBe('http://tauri.localhost')
+    expect(corsHeaders('https://tauri.localhost')['Access-Control-Allow-Origin']).toBe('https://tauri.localhost')
+    expect(corsHeaders('tauri://localhost')['Access-Control-Allow-Origin']).toBe('tauri://localhost')
+  })
+
+  ///@C:CT.TestFallbackOrigins
+  it('falls back for unknown origins', () => {
+    expect(corsHeaders('https://example.com')['Access-Control-Allow-Origin']).toBe('http://localhost:3000')
+    expect(corsHeaders(null)['Access-Control-Allow-Origin']).toBe('http://localhost:3000')
+  })
+})