bingocode 1.0.3 → 1.0.4

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

@@ -1,205 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,38 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-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

@@ -1,63 +0,0 @@
-// 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

@@ -1,29 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

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