bingocode 1.0.1 → 1.0.3

package/desktop/src/__tests__/skillsSettings.test.tsx

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { fireEvent, render, screen } from '@testing-library/react'
+import '@testing-library/jest-dom'
+
+import { Settings } from '../pages/Settings'
+import { useSkillStore } from '../stores/skillStore'
+import { useSettingsStore } from '../stores/settingsStore'
+import { useSessionStore } from '../stores/sessionStore'
+import { useTabStore, SETTINGS_TAB_ID } from '../stores/tabStore'
+
+vi.mock('../api/agents', () => ({
+  agentsApi: {
+    list: vi.fn().mockResolvedValue({ activeAgents: [], allAgents: [] }),
+  },
+}))
+
+vi.mock('../stores/providerStore', () => ({
+  useProviderStore: () => ({
+    providers: [],
+    activeId: null,
+    isLoading: false,
+    fetchProviders: vi.fn(),
+    deleteProvider: vi.fn(),
+    activateProvider: vi.fn(),
+    activateOfficial: vi.fn(),
+    testProvider: vi.fn(),
+    createProvider: vi.fn(),
+    updateProvider: vi.fn(),
+    testConfig: vi.fn(),
+  }),
+}))
+
+vi.mock('../pages/AdapterSettings', () => ({
+  AdapterSettings: () => <div>Adapter Settings Mock</div>,
+}))
+
+vi.mock('../stores/agentStore', () => ({
+  useAgentStore: () => ({
+    activeAgents: [],
+    allAgents: [],
+    isLoading: false,
+    error: null,
+    selectedAgent: null,
+    fetchAgents: vi.fn(),
+    selectAgent: vi.fn(),
+  }),
+}))
+
+vi.mock('../components/chat/CodeViewer', () => ({
+  CodeViewer: ({ code }: { code: string }) => <pre data-testid="code-viewer">{code}</pre>,
+}))
+
+const MOCK_FETCH_SKILLS = vi.fn()
+const MOCK_FETCH_SKILL_DETAIL = vi.fn()
+const MOCK_CLEAR_SELECTION = vi.fn()
+
+function switchToSkillsTab() {
+  fireEvent.click(screen.getByText('Skills'))
+}
+
+describe('Settings > Skills tab', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    useSettingsStore.setState({ locale: 'en' })
+    useSessionStore.setState({
+      sessions: [
+        {
+          id: 'session-1',
+          title: 'Active session',
+          createdAt: '2026-04-20T00:00:00.000Z',
+          modifiedAt: '2026-04-20T00:00:00.000Z',
+          messageCount: 1,
+          projectPath: '/workspace/project',
+          workDir: '/workspace/project',
+          workDirExists: true,
+        },
+      ],
+      activeSessionId: 'session-1',
+      isLoading: false,
+      error: null,
+      selectedProjects: [],
+      availableProjects: ['/workspace/project'],
+    })
+    useTabStore.setState({ tabs: [], activeTabId: null })
+    useSkillStore.setState({
+      skills: [],
+      selectedSkill: null,
+      isLoading: false,
+      isDetailLoading: false,
+      error: null,
+      fetchSkills: MOCK_FETCH_SKILLS,
+      fetchSkillDetail: MOCK_FETCH_SKILL_DETAIL,
+      clearSelection: MOCK_CLEAR_SELECTION,
+    })
+  })
+
+  it('renders browser summary and grouped skill cards', () => {
+    useSkillStore.setState({
+      skills: [
+        {
+          name: 'alpha',
+          displayName: 'Alpha Skill',
+          description: 'First skill description',
+          source: 'user',
+          userInvocable: true,
+          version: '1.0.0',
+          contentLength: 400,
+          hasDirectory: true,
+        },
+        {
+          name: 'beta',
+          description: 'Second skill description',
+          source: 'project',
+          userInvocable: false,
+          contentLength: 200,
+          hasDirectory: true,
+        },
+      ],
+    })
+
+    render(<Settings />)
+    switchToSkillsTab()
+
+    expect(screen.getByText('Browse installed skills')).toBeInTheDocument()
+    expect(screen.getByText('Skill Browser')).toBeInTheDocument()
+    expect(screen.getByText('Total skills')).toBeInTheDocument()
+    expect(screen.getByText('Alpha Skill')).toBeInTheDocument()
+    expect(screen.getByText('Second skill description')).toBeInTheDocument()
+  })
+
+  it('uses the active session workDir even when settings tab is focused', () => {
+    const fetchSkills = vi.fn()
+    useSkillStore.setState({
+      skills: [],
+      selectedSkill: null,
+      isLoading: false,
+      isDetailLoading: false,
+      error: null,
+      fetchSkills,
+      fetchSkillDetail: MOCK_FETCH_SKILL_DETAIL,
+      clearSelection: MOCK_CLEAR_SELECTION,
+    })
+    useTabStore.setState({
+      activeTabId: SETTINGS_TAB_ID,
+      tabs: [{ sessionId: SETTINGS_TAB_ID, title: 'Settings', type: 'settings', status: 'idle' }],
+    })
+
+    render(<Settings />)
+    switchToSkillsTab()
+
+    expect(fetchSkills).toHaveBeenCalledWith('/workspace/project')
+  })
+
+  it('opens skill detail with metadata cards and parsed markdown body', () => {
+    useSkillStore.setState({
+      selectedSkill: {
+        meta: {
+          name: 'alpha',
+          displayName: 'Alpha Skill',
+          description: 'First skill description',
+          source: 'user',
+          userInvocable: true,
+          version: '1.0.0',
+          contentLength: 400,
+          hasDirectory: true,
+        },
+        tree: [
+          { name: 'SKILL.md', path: 'SKILL.md', type: 'file' },
+          { name: 'run.ts', path: 'run.ts', type: 'file' },
+        ],
+        files: [
+          {
+            path: 'SKILL.md',
+            content: '# Hello\n\nBody content',
+            body: '# Hello\n\nBody content',
+            language: 'markdown',
+            isEntry: true,
+            frontmatter: {
+              description: 'Frontmatter description',
+              'allowed-tools': ['Read', 'Edit'],
+              model: 'sonnet',
+            },
+          },
+          {
+            path: 'run.ts',
+            content: 'console.log("hello")',
+            language: 'typescript',
+            isEntry: false,
+          },
+        ],
+        skillRoot: '/tmp/alpha',
+      },
+    })
+
+    render(<Settings />)
+    switchToSkillsTab()
+
+    expect(screen.getByText('Skill metadata')).toBeInTheDocument()
+    expect(screen.getByText('/slash')).toBeInTheDocument()
+    expect(screen.getByText('Frontmatter description')).toBeInTheDocument()
+    expect(screen.getByText('Read, Edit')).toBeInTheDocument()
+    expect(screen.getByText('Hello')).toBeInTheDocument()
+    expect(screen.queryByText(/^---$/)).not.toBeInTheDocument()
+  })
+})

package/desktop/src/api/adapters.ts

@@ -0,0 +1,12 @@
+import { api } from './client'
+import type { AdapterFileConfig } from '../types/adapter'
+
+export const adaptersApi = {
+  getConfig() {
+    return api.get<AdapterFileConfig>('/api/adapters')
+  },
+
+  updateConfig(patch: Partial<AdapterFileConfig>) {
+    return api.put<AdapterFileConfig>('/api/adapters', patch)
+  },
+}

package/desktop/src/api/agents.ts

@@ -0,0 +1,36 @@
+import { api } from './client'
+
+export type AgentSource =
+  | 'built-in'
+  | 'plugin'
+  | 'userSettings'
+  | 'projectSettings'
+  | 'localSettings'
+  | 'flagSettings'
+  | 'policySettings'
+
+export type AgentDefinition = {
+  agentType: string
+  description?: string
+  model?: string
+  modelDisplay?: string
+  tools?: string[]
+  systemPrompt?: string
+  color?: string
+  source: AgentSource
+  baseDir?: string
+  overriddenBy?: AgentSource
+  isActive: boolean
+}
+
+export type AgentListResponse = {
+  activeAgents: AgentDefinition[]
+  allAgents: AgentDefinition[]
+}
+
+export const agentsApi = {
+  list: (cwd?: string) => {
+    const query = cwd ? `?cwd=${encodeURIComponent(cwd)}` : ''
+    return api.get<AgentListResponse>(`/api/agents${query}`)
+  },
+}

package/desktop/src/api/cliTasks.ts

@@ -0,0 +1,28 @@
+import { api } from './client'
+import type { CLITask, TaskListSummary } from '../types/cliTask'
+
+type TaskListsResponse = { lists: TaskListSummary[] }
+type TasksResponse = { tasks: CLITask[] }
+type TaskResponse = { task: CLITask }
+
+export const cliTasksApi = {
+  /** List all task lists with summaries */
+  listTaskLists() {
+    return api.get<TaskListsResponse>('/api/tasks/lists')
+  },
+
+  /** Get all tasks for a specific task list */
+  getTasksForList(taskListId: string) {
+    return api.get<TasksResponse>(`/api/tasks/lists/${encodeURIComponent(taskListId)}`)
+  },
+
+  /** Get a single task */
+  getTask(taskListId: string, taskId: string) {
+    return api.get<TaskResponse>(`/api/tasks/lists/${encodeURIComponent(taskListId)}/${taskId}`)
+  },
+
+  /** List all tasks across all task lists */
+  listAll() {
+    return api.get<TasksResponse>('/api/tasks')
+  },
+}

package/desktop/src/api/client.ts

@@ -0,0 +1,63 @@
+const DEFAULT_BASE_URL = 'http://127.0.0.1:3456'
+
+let baseUrl = DEFAULT_BASE_URL
+
+export function setBaseUrl(url: string) {
+  baseUrl = url.replace(/\/$/, '')
+}
+
+export function getBaseUrl() {
+  return baseUrl
+}
+
+export function getDefaultBaseUrl() {
+  return DEFAULT_BASE_URL
+}
+
+export class ApiError extends Error {
+  constructor(
+    public status: number,
+    public body: unknown,
+  ) {
+    super(`API error ${status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`)
+    this.name = 'ApiError'
+  }
+}
+
+async function request<T>(method: string, path: string, body?: unknown, options?: { timeout?: number }): Promise<T> {
+  const url = `${baseUrl}${path}`
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  }
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), options?.timeout ?? 30_000)
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+      signal: controller.signal,
+    })
+    clearTimeout(timeout)
+
+    if (!res.ok) {
+      const errorBody = await res.json().catch(() => res.text())
+      throw new ApiError(res.status, errorBody)
+    }
+
+    if (res.status === 204) return undefined as T
+    return res.json() as Promise<T>
+  } catch (err) {
+    clearTimeout(timeout)
+    throw err
+  }
+}
+
+export const api = {
+  get: <T>(path: string, options?: { timeout?: number }) => request<T>('GET', path, undefined, options),
+  post: <T>(path: string, body?: unknown, options?: { timeout?: number }) => request<T>('POST', path, body, options),
+  put: <T>(path: string, body?: unknown) => request<T>('PUT', path, body),
+  patch: <T>(path: string, body?: unknown) => request<T>('PATCH', path, body),
+  delete: <T>(path: string) => request<T>('DELETE', path),
+}

package/desktop/src/api/computerUse.ts

@@ -0,0 +1,76 @@
+import { api } from './client'
+
+export type ComputerUseStatus = {
+  platform: string
+  supported: boolean
+  python: {
+    installed: boolean
+    version: string | null
+    path: string | null
+  }
+  venv: {
+    created: boolean
+    path: string
+  }
+  dependencies: {
+    installed: boolean
+    requirementsFound: boolean
+  }
+  permissions: {
+    accessibility: boolean | null
+    screenRecording: boolean | null
+  }
+}
+
+export type SetupStep = {
+  name: string
+  ok: boolean
+  message: string
+}
+
+export type SetupResult = {
+  success: boolean
+  steps: SetupStep[]
+}
+
+export type InstalledApp = {
+  bundleId: string
+  displayName: string
+  path: string
+}
+
+export type AuthorizedApp = {
+  bundleId: string
+  displayName: string
+  authorizedAt: string
+}
+
+export type ComputerUseConfig = {
+  authorizedApps: AuthorizedApp[]
+  grantFlags: {
+    clipboardRead: boolean
+    clipboardWrite: boolean
+    systemKeyCombos: boolean
+  }
+}
+
+export const computerUseApi = {
+  getStatus() {
+    return api.get<ComputerUseStatus>('/api/computer-use/status')
+  },
+  runSetup() {
+    return api.post<SetupResult>('/api/computer-use/setup', undefined, { timeout: 300_000 })
+  },
+  getInstalledApps() {
+    return api.get<{ apps: InstalledApp[] }>('/api/computer-use/apps')
+  },
+  getAuthorizedApps() {
+    return api.get<ComputerUseConfig>('/api/computer-use/authorized-apps')
+  },
+  setAuthorizedApps(config: Partial<ComputerUseConfig>) {
+    return api.put<{ ok: true }>('/api/computer-use/authorized-apps', config)
+  },
+  openSettings(pane: 'Privacy_ScreenCapture' | 'Privacy_Accessibility') {
+    return api.post<{ ok: true }>('/api/computer-use/open-settings', { pane })
+  },
+}

package/desktop/src/api/filesystem.ts

@@ -0,0 +1,30 @@
+import { api } from './client'
+
+type DirEntry = {
+  name: string
+  path: string
+  isDirectory: boolean
+}
+
+type BrowseResult = {
+  currentPath: string
+  parentPath: string
+  entries: DirEntry[]
+  query?: string
+}
+
+export const filesystemApi = {
+  browse(path?: string, options?: { includeFiles?: boolean }) {
+    const q = new URLSearchParams()
+    if (path) q.set('path', path)
+    if (options?.includeFiles) q.set('includeFiles', 'true')
+    const qs = q.toString()
+    return api.get<BrowseResult>(`/api/filesystem/browse${qs ? `?${qs}` : ''}`)
+  },
+
+  search(query: string, cwd?: string) {
+    const q = new URLSearchParams({ search: query, maxResults: '200' })
+    if (cwd) q.set('path', cwd)
+    return api.get<BrowseResult>(`/api/filesystem/browse?${q}`)
+  },
+}

package/desktop/src/api/hahaOAuth.ts

@@ -0,0 +1,38 @@
+// desktop/src/api/hahaOAuth.ts
+
+import { api, getBaseUrl } from './client'
+
+export type HahaOAuthStatus =
+  | { loggedIn: false }
+  | {
+      loggedIn: true
+      expiresAt: number | null
+      scopes: string[]
+      subscriptionType: 'pro' | 'max' | 'team' | 'enterprise' | null
+    }
+
+function currentServerPort(): number {
+  const port = new URL(getBaseUrl()).port
+  const parsed = Number.parseInt(port, 10)
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Cannot determine server port from baseUrl: ${getBaseUrl()}`)
+  }
+  return parsed
+}
+
+export const hahaOAuthApi = {
+  start() {
+    return api.post<{ authorizeUrl: string; state: string }>(
+      '/api/haha-oauth/start',
+      { serverPort: currentServerPort() },
+    )
+  },
+
+  status() {
+    return api.get<HahaOAuthStatus>('/api/haha-oauth')
+  },
+
+  logout() {
+    return api.delete<{ ok: true }>('/api/haha-oauth')
+  },
+}

package/desktop/src/api/models.ts

@@ -0,0 +1,28 @@
+import { api } from './client'
+import type { ModelInfo, EffortLevel } from '../types/settings'
+
+type ModelsResponse = { models: ModelInfo[]; provider: { id: string; name: string } | null }
+type CurrentModelResponse = { model: ModelInfo }
+type EffortResponse = { level: EffortLevel; available: EffortLevel[] }
+
+export const modelsApi = {
+  list() {
+    return api.get<ModelsResponse>('/api/models')
+  },
+
+  getCurrent() {
+    return api.get<CurrentModelResponse>('/api/models/current')
+  },
+
+  setCurrent(modelId: string) {
+    return api.put<{ ok: true; model: string }>('/api/models/current', { modelId })
+  },
+
+  getEffort() {
+    return api.get<EffortResponse>('/api/effort')
+  },
+
+  setEffort(level: EffortLevel) {
+    return api.put<{ ok: true; level: EffortLevel }>('/api/effort', { level })
+  },
+}

package/desktop/src/api/providers.ts

@@ -0,0 +1,63 @@
+// desktop/src/api/providers.ts
+
+import { api } from './client'
+import type {
+  SavedProvider,
+  CreateProviderInput,
+  UpdateProviderInput,
+  TestProviderConfigInput,
+  ProviderTestResult,
+} from '../types/provider'
+import type { ProviderPreset } from '../config/providerPresets'
+
+type ProvidersResponse = { providers: SavedProvider[]; activeId: string | null }
+type ProviderResponse = { provider: SavedProvider }
+type PresetsResponse = { presets: ProviderPreset[] }
+type TestResultResponse = { result: ProviderTestResult }
+type AuthStatusResponse = {
+  hasAuth: boolean
+  source: 'cc-haha-provider' | 'original-settings' | 'env' | 'none'
+  activeProvider?: string
+}
+
+export const providersApi = {
+  list() {
+    return api.get<ProvidersResponse>('/api/providers')
+  },
+
+  presets() {
+    return api.get<PresetsResponse>('/api/providers/presets')
+  },
+
+  authStatus() {
+    return api.get<AuthStatusResponse>('/api/providers/auth-status')
+  },
+
+  create(input: CreateProviderInput) {
+    return api.post<ProviderResponse>('/api/providers', input)
+  },
+
+  update(id: string, input: UpdateProviderInput) {
+    return api.put<ProviderResponse>(`/api/providers/${id}`, input)
+  },
+
+  delete(id: string) {
+    return api.delete<{ ok: true }>(`/api/providers/${id}`)
+  },
+
+  activate(id: string) {
+    return api.post<{ ok: true }>(`/api/providers/${id}/activate`)
+  },
+
+  activateOfficial() {
+    return api.post<{ ok: true }>('/api/providers/official')
+  },
+
+  test(id: string, overrides?: { baseUrl?: string; modelId?: string; apiFormat?: string }) {
+    return api.post<TestResultResponse>(`/api/providers/${id}/test`, overrides)
+  },
+
+  testConfig(input: TestProviderConfigInput) {
+    return api.post<TestResultResponse>('/api/providers/test', input)
+  },
+}

package/desktop/src/api/search.ts

@@ -0,0 +1,29 @@
+import { api } from './client'
+
+type SearchResult = {
+  file: string
+  line: number
+  text: string
+  context?: string[]
+}
+
+type SearchResponse = { results: SearchResult[]; total: number }
+
+type SessionSearchResult = {
+  sessionId: string
+  title: string
+  matchCount: number
+  matches: Array<{ line: number; text: string }>
+}
+
+type SessionSearchResponse = { results: SessionSearchResult[] }
+
+export const searchApi = {
+  search(params: { query: string; cwd?: string; maxResults?: number; glob?: string }) {
+    return api.post<SearchResponse>('/api/search', params)
+  },
+
+  searchSessions(query: string) {
+    return api.post<SessionSearchResponse>('/api/search/sessions', { query })
+  },
+}

package/desktop/src/api/sessions.ts

@@ -0,0 +1,56 @@
+import { api } from './client'
+import type { SessionListItem, MessageEntry } from '../types/session'
+
+type SessionsResponse = { sessions: SessionListItem[]; total: number }
+type MessagesResponse = { messages: MessageEntry[] }
+type CreateSessionResponse = { sessionId: string }
+
+export type RecentProject = {
+  projectPath: string
+  realPath: string
+  projectName: string
+  isGit: boolean
+  repoName: string | null
+  branch: string | null
+  modifiedAt: string
+  sessionCount: number
+}
+
+export const sessionsApi = {
+  list(params?: { project?: string; limit?: number; offset?: number }) {
+    const query = new URLSearchParams()
+    if (params?.project) query.set('project', params.project)
+    if (params?.limit) query.set('limit', String(params.limit))
+    if (params?.offset) query.set('offset', String(params.offset))
+    const qs = query.toString()
+    return api.get<SessionsResponse>(`/api/sessions${qs ? `?${qs}` : ''}`)
+  },
+
+  getMessages(sessionId: string) {
+    return api.get<MessagesResponse>(`/api/sessions/${sessionId}/messages`)
+  },
+
+  create(workDir?: string) {
+    return api.post<CreateSessionResponse>('/api/sessions', workDir ? { workDir } : {})
+  },
+
+  delete(sessionId: string) {
+    return api.delete<{ ok: true }>(`/api/sessions/${sessionId}`)
+  },
+
+  rename(sessionId: string, title: string) {
+    return api.patch<{ ok: true }>(`/api/sessions/${sessionId}`, { title })
+  },
+
+  getRecentProjects() {
+    return api.get<{ projects: RecentProject[] }>('/api/sessions/recent-projects')
+  },
+
+  getGitInfo(sessionId: string) {
+    return api.get<{ branch: string | null; repoName: string | null; workDir: string; changedFiles: number }>(`/api/sessions/${sessionId}/git-info`)
+  },
+
+  getSlashCommands(sessionId: string) {
+    return api.get<{ commands: Array<{ name: string; description: string }> }>(`/api/sessions/${sessionId}/slash-commands`)
+  },
+}

package/desktop/src/api/settings.ts

@@ -0,0 +1,20 @@
+import { api } from './client'
+import type { PermissionMode, UserSettings } from '../types/settings'
+
+export const settingsApi = {
+  getUser() {
+    return api.get<UserSettings>('/api/settings/user')
+  },
+
+  updateUser(settings: Partial<UserSettings>) {
+    return api.put<{ ok: true }>('/api/settings/user', settings)
+  },
+
+  getPermissionMode() {
+    return api.get<{ mode: PermissionMode }>('/api/permissions/mode')
+  },
+
+  setPermissionMode(mode: PermissionMode) {
+    return api.put<{ ok: true; mode: PermissionMode }>('/api/permissions/mode', { mode })
+  },
+}