bingocode 1.0.28 → 1.0.30

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

@@ -0,0 +1,376 @@
+/**
+ * Unit tests for Settings, Models, and Status APIs
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import * as os from 'os'
+import { SettingsService } from '../services/settingsService.js'
+import { handleSettingsApi } from '../api/settings.js'
+import { handleModelsApi } from '../api/models.js'
+import { handleStatusApi, resetUsage, addUsage } from '../api/status.js'
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+let tmpDir: string
+let originalConfigDir: string | undefined
+
+async function setup() {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-test-'))
+  originalConfigDir = process.env.CLAUDE_CONFIG_DIR
+  process.env.CLAUDE_CONFIG_DIR = tmpDir
+}
+
+async function teardown() {
+  if (originalConfigDir !== undefined) {
+    process.env.CLAUDE_CONFIG_DIR = originalConfigDir
+  } else {
+    delete process.env.CLAUDE_CONFIG_DIR
+  }
+  await fs.rm(tmpDir, { recursive: true, force: true })
+}
+
+/** 创建一个模拟 Request */
+function makeRequest(
+  method: string,
+  urlStr: string,
+  body?: Record<string, unknown>,
+): { req: Request; url: URL; segments: string[] } {
+  const url = new URL(urlStr, 'http://localhost:3456')
+  const init: RequestInit = { method }
+  if (body) {
+    init.headers = { 'Content-Type': 'application/json' }
+    init.body = JSON.stringify(body)
+  }
+  const req = new Request(url.toString(), init)
+  const segments = url.pathname.split('/').filter(Boolean)
+  return { req, url, segments }
+}
+
+// =============================================================================
+// SettingsService
+// =============================================================================
+
+describe('SettingsService', () => {
+  beforeEach(setup)
+  afterEach(teardown)
+
+  it('should return empty object when settings file does not exist', async () => {
+    const svc = new SettingsService()
+    const settings = await svc.getUserSettings()
+    expect(settings).toEqual({})
+  })
+
+  it('should write and read user settings', async () => {
+    const svc = new SettingsService()
+    await svc.updateUserSettings({ theme: 'dark', model: 'claude-opus-4-7' })
+
+    const settings = await svc.getUserSettings()
+    expect(settings.theme).toBe('dark')
+    expect(settings.model).toBe('claude-opus-4-7')
+  })
+
+  it('should merge settings on update (shallow merge)', async () => {
+    const svc = new SettingsService()
+    await svc.updateUserSettings({ theme: 'dark' })
+    await svc.updateUserSettings({ model: 'claude-haiku-4-5' })
+
+    const settings = await svc.getUserSettings()
+    expect(settings.theme).toBe('dark')
+    expect(settings.model).toBe('claude-haiku-4-5')
+  })
+
+  it('should read and write project settings', async () => {
+    const projectRoot = path.join(tmpDir, 'myproject')
+    await fs.mkdir(path.join(projectRoot, '.claude'), { recursive: true })
+
+    const svc = new SettingsService(projectRoot)
+    await svc.updateProjectSettings({ outputStyle: 'verbose' })
+
+    const settings = await svc.getProjectSettings()
+    expect(settings.outputStyle).toBe('verbose')
+  })
+
+  it('should merge user and project settings', async () => {
+    const projectRoot = path.join(tmpDir, 'myproject')
+    await fs.mkdir(path.join(projectRoot, '.claude'), { recursive: true })
+
+    const svc = new SettingsService(projectRoot)
+    await svc.updateUserSettings({ theme: 'dark', model: 'claude-opus-4-7' })
+    await svc.updateProjectSettings({ theme: 'light' })
+
+    const merged = await svc.getSettings()
+    // project overrides user
+    expect(merged.theme).toBe('light')
+    // user value preserved when not overridden
+    expect(merged.model).toBe('claude-opus-4-7')
+  })
+
+  it('should get default permission mode', async () => {
+    const svc = new SettingsService()
+    const mode = await svc.getPermissionMode()
+    expect(mode).toBe('default')
+  })
+
+  it('should set and get permission mode', async () => {
+    const svc = new SettingsService()
+    await svc.setPermissionMode('plan')
+    const mode = await svc.getPermissionMode()
+    expect(mode).toBe('plan')
+  })
+
+  it('should reject invalid permission mode', async () => {
+    const svc = new SettingsService()
+    await expect(svc.setPermissionMode('invalid')).rejects.toThrow('Invalid permission mode')
+  })
+
+  it('should preserve other settings when updating permission mode', async () => {
+    const svc = new SettingsService()
+    await svc.updateUserSettings({ theme: 'dark' })
+    await svc.setPermissionMode('acceptEdits')
+
+    const settings = await svc.getUserSettings()
+    expect(settings.theme).toBe('dark')
+    expect(settings.defaultMode).toBe('acceptEdits')
+  })
+})
+
+// =============================================================================
+// Settings API
+// =============================================================================
+
+describe('Settings API', () => {
+  beforeEach(setup)
+  afterEach(teardown)
+
+  it('GET /api/settings should return merged settings', async () => {
+    // Seed some user settings
+    const settingsPath = path.join(tmpDir, 'settings.json')
+    await fs.writeFile(settingsPath, JSON.stringify({ theme: 'dark' }))
+
+    const { req, url, segments } = makeRequest('GET', '/api/settings')
+    const res = await handleSettingsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.theme).toBe('dark')
+  })
+
+  it('GET /api/settings/user should return user settings', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/settings/user')
+    const res = await handleSettingsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body).toEqual({})
+  })
+
+  it('PUT /api/settings/user should update user settings', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/settings/user', {
+      model: 'claude-opus-4-7',
+    })
+    const res = await handleSettingsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(true)
+
+    // Verify persisted
+    const { req: r2, url: u2, segments: s2 } = makeRequest('GET', '/api/settings/user')
+    const res2 = await handleSettingsApi(r2, u2, s2)
+    const body2 = await res2.json()
+    expect(body2.model).toBe('claude-opus-4-7')
+  })
+
+  it('GET /api/permissions/mode should return default mode', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/permissions/mode')
+    const res = await handleSettingsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.mode).toBe('default')
+  })
+
+  it('PUT /api/permissions/mode should set mode', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/permissions/mode', {
+      mode: 'bypassPermissions',
+    })
+    const res = await handleSettingsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(true)
+    expect(body.mode).toBe('bypassPermissions')
+  })
+
+  it('PUT /api/permissions/mode should reject invalid mode', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/permissions/mode', {
+      mode: 'yolo',
+    })
+    const res = await handleSettingsApi(req, url, segments)
+
+    expect(res.status).toBe(400)
+  })
+
+  it('should return 404 for unknown settings endpoint', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/settings/unknown')
+    const res = await handleSettingsApi(req, url, segments)
+    expect(res.status).toBe(404)
+  })
+})
+
+// =============================================================================
+// Models API
+// =============================================================================
+
+describe('Models API', () => {
+  beforeEach(setup)
+  afterEach(teardown)
+
+  it('GET /api/models should return available models', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/models')
+    const res = await handleModelsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.models).toBeArray()
+    expect(body.models.length).toBe(4)
+    expect(body.models[0].id).toContain('claude')
+  })
+
+  it('GET /api/models/current should return default model when not set', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/models/current')
+    const res = await handleModelsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.model.id).toBe('claude-sonnet-4-6')
+  })
+
+  it('PUT /api/models/current should switch model', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/models/current', {
+      modelId: 'claude-opus-4-7',
+    })
+    const res = await handleModelsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(true)
+    expect(body.model).toBe('claude-opus-4-7')
+
+    // Verify persisted
+    const { req: r2, url: u2, segments: s2 } = makeRequest('GET', '/api/models/current')
+    const res2 = await handleModelsApi(r2, u2, s2)
+    const body2 = await res2.json()
+    expect(body2.model.id).toBe('claude-opus-4-7')
+  })
+
+  it('PUT /api/models/current should reject missing modelId', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/models/current', {})
+    const res = await handleModelsApi(req, url, segments)
+    expect(res.status).toBe(400)
+  })
+
+  it('GET /api/effort should return default effort level', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/effort')
+    const res = await handleModelsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.level).toBe('medium')
+    expect(body.available).toEqual(['low', 'medium', 'high', 'max'])
+  })
+
+  it('PUT /api/effort should set effort level', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/effort', { level: 'high' })
+    const res = await handleModelsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(true)
+    expect(body.level).toBe('high')
+  })
+
+  it('PUT /api/effort should reject invalid level', async () => {
+    const { req, url, segments } = makeRequest('PUT', '/api/effort', { level: 'turbo' })
+    const res = await handleModelsApi(req, url, segments)
+    expect(res.status).toBe(400)
+  })
+
+  it('should return 404 for unknown models endpoint', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/models/unknown')
+    const res = await handleModelsApi(req, url, segments)
+    expect(res.status).toBe(404)
+  })
+})
+
+// =============================================================================
+// Status API
+// =============================================================================
+
+describe('Status API', () => {
+  beforeEach(async () => {
+    await setup()
+    resetUsage()
+  })
+  afterEach(teardown)
+
+  it('GET /api/status should return health check', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/status')
+    const res = await handleStatusApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.status).toBe('ok')
+    expect(body.version).toBeDefined()
+    expect(body.uptime).toBeGreaterThanOrEqual(0)
+  })
+
+  it('GET /api/status/diagnostics should return system info', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/status/diagnostics')
+    const res = await handleStatusApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.platform).toBeDefined()
+    expect(body.arch).toBeDefined()
+    expect(body.configDir).toBeDefined()
+  })
+
+  it('GET /api/status/usage should return token usage', async () => {
+    addUsage(100, 50, 0.005)
+    addUsage(200, 100, 0.01)
+
+    const { req, url, segments } = makeRequest('GET', '/api/status/usage')
+    const res = await handleStatusApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.totalInputTokens).toBe(300)
+    expect(body.totalOutputTokens).toBe(150)
+    expect(body.totalCost).toBeCloseTo(0.015)
+  })
+
+  it('GET /api/status/user should return user info', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/status/user')
+    const res = await handleStatusApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.configDir).toBe(tmpDir)
+    expect(body.projects).toBeArray()
+  })
+
+  it('should reject non-GET methods', async () => {
+    const { req, url, segments } = makeRequest('POST', '/api/status')
+    const res = await handleStatusApi(req, url, segments)
+    expect(res.status).toBe(405)
+  })
+
+  it('should return 404 for unknown status endpoint', async () => {
+    const { req, url, segments } = makeRequest('GET', '/api/status/nonexistent')
+    const res = await handleStatusApi(req, url, segments)
+    expect(res.status).toBe(404)
+  })
+})

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

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { getCwdState, setCwdState } from '../../bootstrap/state.js'
+import { handleSkillsApi } from '../api/skills.js'
+
+let tmpHome: string
+let originalHome: string | undefined
+let originalUserProfile: string | undefined
+let originalClaudeConfigDir: string | undefined
+let originalCwdState: string
+
+function makeRequest(urlStr: string): { req: Request; url: URL; segments: string[] } {
+  const url = new URL(urlStr, 'http://localhost:3456')
+  const req = new Request(url.toString(), { method: 'GET' })
+  return {
+    req,
+    url,
+    segments: url.pathname.split('/').filter(Boolean),
+  }
+}
+
+async function writeSkill(root: string, skillName: string, content: string): Promise<void> {
+  const skillDir = path.join(root, skillName)
+  await fs.mkdir(skillDir, { recursive: true })
+  await fs.writeFile(path.join(skillDir, 'SKILL.md'), content, 'utf-8')
+}
+
+describe('Skills API', () => {
+  beforeEach(async () => {
+    tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-skills-test-'))
+    originalHome = process.env.HOME
+    originalUserProfile = process.env.USERPROFILE
+    originalClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR
+    originalCwdState = getCwdState()
+
+    process.env.HOME = tmpHome
+    process.env.USERPROFILE = tmpHome
+    process.env.CLAUDE_CONFIG_DIR = path.join(tmpHome, '.claude')
+    setCwdState(tmpHome)
+  })
+
+  afterEach(async () => {
+    if (originalHome === undefined) {
+      delete process.env.HOME
+    } else {
+      process.env.HOME = originalHome
+    }
+
+    if (originalUserProfile === undefined) {
+      delete process.env.USERPROFILE
+    } else {
+      process.env.USERPROFILE = originalUserProfile
+    }
+
+    if (originalClaudeConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = originalClaudeConfigDir
+    }
+
+    setCwdState(originalCwdState)
+    await fs.rm(tmpHome, { recursive: true, force: true })
+  })
+
+  it('lists user and project skills for the requested cwd', async () => {
+    const userSkillsRoot = path.join(tmpHome, '.claude', 'skills')
+    const projectRoot = path.join(tmpHome, 'workspace')
+    const cwd = path.join(projectRoot, 'packages', 'app')
+
+    await writeSkill(
+      userSkillsRoot,
+      'user-skill',
+      ['---', 'description: User scope', '---', '', '# User skill'].join('\n'),
+    )
+    await writeSkill(
+      path.join(projectRoot, '.claude', 'skills'),
+      'project-skill',
+      ['---', 'description: Project scope', '---', '', '# Project skill'].join('\n'),
+    )
+
+    const { req, url, segments } = makeRequest(`/api/skills?cwd=${encodeURIComponent(cwd)}`)
+    const res = await handleSkillsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json() as { skills: Array<{ name: string; source: string }> }
+    expect(body.skills).toContainEqual(expect.objectContaining({ name: 'user-skill', source: 'user' }))
+    expect(body.skills).toContainEqual(expect.objectContaining({ name: 'project-skill', source: 'project' }))
+  })
+
+  it('resolves project skill details from the nearest project skills directory', async () => {
+    const projectRoot = path.join(tmpHome, 'workspace')
+    const nestedRoot = path.join(projectRoot, 'packages', 'app')
+    const nestedSkillsRoot = path.join(nestedRoot, '.claude', 'skills')
+    const parentSkillsRoot = path.join(projectRoot, '.claude', 'skills')
+
+    await writeSkill(
+      parentSkillsRoot,
+      'shared-skill',
+      ['---', 'description: Parent version', '---', '', 'parent body'].join('\n'),
+    )
+    await writeSkill(
+      nestedSkillsRoot,
+      'shared-skill',
+      ['---', 'description: Child version', '---', '', 'child body'].join('\n'),
+    )
+
+    const { req, url, segments } = makeRequest(
+      `/api/skills/detail?source=project&name=shared-skill&cwd=${encodeURIComponent(nestedRoot)}`,
+    )
+    const res = await handleSkillsApi(req, url, segments)
+
+    expect(res.status).toBe(200)
+    const body = await res.json() as {
+      detail: { meta: { description: string }; skillRoot: string; files: Array<{ path: string; body?: string }> }
+    }
+
+    expect(body.detail.meta.description).toBe('Child version')
+    expect(body.detail.skillRoot).toBe(path.join(nestedSkillsRoot, 'shared-skill'))
+    expect(body.detail.files).toContainEqual(
+      expect.objectContaining({ path: 'SKILL.md', body: 'child body' }),
+    )
+  })
+})

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

@@ -0,0 +1,171 @@
+/**
+ * Unit tests for TaskService and Tasks API
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import * as os from 'os'
+import { TaskService } from '../services/taskService.js'
+
+// ============================================================================
+// TaskService unit tests
+// ============================================================================
+
+describe('TaskService', () => {
+  let tmpDir: string
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-tasks-'))
+    process.env.CLAUDE_CONFIG_DIR = tmpDir
+  })
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true })
+    delete process.env.CLAUDE_CONFIG_DIR
+  })
+
+  it('should return empty list when no tasks dir', async () => {
+    const svc = new TaskService()
+    const tasks = await svc.listTasks()
+    expect(tasks).toEqual([])
+  })
+
+  it('should list tasks from JSON files', async () => {
+    const tasksDir = path.join(tmpDir, 'tasks')
+    await fs.mkdir(tasksDir, { recursive: true })
+
+    await fs.writeFile(path.join(tasksDir, 'task-001.json'), JSON.stringify({
+      id: 'task-001',
+      type: 'local_agent',
+      status: 'completed',
+      name: 'code-review',
+      description: 'Review PR #42',
+      createdAt: Date.now() - 60000,
+      completedAt: Date.now(),
+    }))
+
+    await fs.writeFile(path.join(tasksDir, 'task-002.json'), JSON.stringify({
+      id: 'task-002',
+      type: 'in_process_teammate',
+      status: 'running',
+      name: 'frontend-dev',
+      teamName: 'ui-team',
+      createdAt: Date.now(),
+    }))
+
+    const svc = new TaskService()
+    const tasks = await svc.listTasks()
+    expect(tasks.length).toBe(2)
+    // 按 createdAt 倒序
+    expect(tasks[0].id).toBe('task-002')
+    expect(tasks[1].id).toBe('task-001')
+  })
+
+  it('should scan nested team task directories', async () => {
+    const teamDir = path.join(tmpDir, 'tasks', 'my-team')
+    await fs.mkdir(teamDir, { recursive: true })
+
+    await fs.writeFile(path.join(teamDir, 'member-1.json'), JSON.stringify({
+      id: 'member-1',
+      type: 'in_process_teammate',
+      status: 'completed',
+      teamName: 'my-team',
+    }))
+
+    const svc = new TaskService()
+    const tasks = await svc.listTasks()
+    expect(tasks.length).toBe(1)
+    expect(tasks[0].teamName).toBe('my-team')
+  })
+
+  it('should get single task by ID', async () => {
+    const tasksDir = path.join(tmpDir, 'tasks')
+    await fs.mkdir(tasksDir, { recursive: true })
+
+    await fs.writeFile(path.join(tasksDir, 'abc.json'), JSON.stringify({
+      id: 'abc',
+      type: 'local_shell',
+      status: 'failed',
+      name: 'build',
+    }))
+
+    const svc = new TaskService()
+    const task = await svc.getTask('abc')
+    expect(task).toBeDefined()
+    expect(task!.status).toBe('failed')
+  })
+
+  it('should return null for unknown task', async () => {
+    const svc = new TaskService()
+    const task = await svc.getTask('nonexistent')
+    expect(task).toBeNull()
+  })
+
+  it('should skip invalid JSON files gracefully', async () => {
+    const tasksDir = path.join(tmpDir, 'tasks')
+    await fs.mkdir(tasksDir, { recursive: true })
+    await fs.writeFile(path.join(tasksDir, 'bad.json'), 'not json {{{')
+
+    const svc = new TaskService()
+    const tasks = await svc.listTasks()
+    expect(tasks).toEqual([])
+  })
+})
+
+// ============================================================================
+// Tasks API integration tests
+// ============================================================================
+
+describe('Tasks API', () => {
+  let server: any
+  let baseUrl: string
+  let tmpDir: string
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'claude-tasks-api-'))
+    process.env.CLAUDE_CONFIG_DIR = tmpDir
+    await fs.mkdir(path.join(tmpDir, 'projects'), { recursive: true })
+
+    const port = 15500 + Math.floor(Math.random() * 500)
+    const { startServer } = await import('../../server/index.js')
+    server = startServer(port, '127.0.0.1')
+    baseUrl = `http://127.0.0.1:${port}`
+  })
+
+  afterEach(async () => {
+    server?.stop()
+    await fs.rm(tmpDir, { recursive: true, force: true })
+    delete process.env.CLAUDE_CONFIG_DIR
+  })
+
+  it('should return empty tasks list', async () => {
+    const res = await fetch(`${baseUrl}/api/tasks`)
+    const data = await res.json()
+    expect(res.status).toBe(200)
+    expect(data.tasks).toEqual([])
+  })
+
+  it('should return tasks when files exist', async () => {
+    const tasksDir = path.join(tmpDir, 'tasks')
+    await fs.mkdir(tasksDir, { recursive: true })
+    await fs.writeFile(path.join(tasksDir, 'test.json'), JSON.stringify({
+      id: 'test', type: 'local_agent', status: 'completed', name: 'test-task',
+    }))
+
+    const res = await fetch(`${baseUrl}/api/tasks`)
+    const data = await res.json()
+    expect(data.tasks.length).toBe(1)
+    expect(data.tasks[0].name).toBe('test-task')
+  })
+
+  it('should return 404 for unknown task', async () => {
+    const res = await fetch(`${baseUrl}/api/tasks/nonexistent`)
+    expect(res.status).toBe(404)
+  })
+
+  it('should reject non-GET methods', async () => {
+    const res = await fetch(`${baseUrl}/api/tasks`, { method: 'POST' })
+    expect(res.status).toBe(405)
+  })
+})