bingocode 1.0.3 → 1.0.4

package/desktop/src/stores/cliTaskStore.ts

@@ -1,152 +0,0 @@
-import { create } from 'zustand'
-import { cliTasksApi } from '../api/cliTasks'
-import type { CLITask, TaskStatus } from '../types/cliTask'
-
-type TodoItem = {
-  content: string
-  status: string
-  activeForm?: string
-}
-
-type CLITaskStore = {
-  /** Current session ID being tracked */
-  sessionId: string | null
-  /** Tasks for the current session */
-  tasks: CLITask[]
-  /** Whether the task bar is expanded */
-  expanded: boolean
-  /** True when all tasks completed and the user already continued chatting.
-   *  Set during history load so the sticky bar is suppressed on page refresh. */
-  completedAndDismissed: boolean
-  /** Snapshot of the completed task set that was dismissed */
-  dismissedCompletionKey: string | null
-
-  /** Fetch tasks for a given session (uses sessionId as taskListId) */
-  fetchSessionTasks: (sessionId: string) => Promise<void>
-  /** Refresh tasks for the currently tracked session */
-  refreshTasks: () => Promise<void>
-  /** Update tasks from TodoWrite V1 tool input (in-memory, no disk read needed) */
-  setTasksFromTodos: (todos: TodoItem[]) => void
-  /** Mark that completed tasks were already dismissed (conversation continued) */
-  markCompletedAndDismissed: () => void
-  /** Clear task tracking state */
-  clearTasks: () => void
-  /** Toggle expanded state */
-  toggleExpanded: () => void
-}
-
-function buildCompletedTaskKey(tasks: CLITask[]): string | null {
-  if (tasks.length === 0 || tasks.some((task) => task.status !== 'completed')) return null
-
-  return tasks
-    .map((task) => [
-      task.taskListId,
-      task.id,
-      task.subject,
-      task.status,
-      task.activeForm ?? '',
-      task.owner ?? '',
-    ].join('::'))
-    .join('|')
-}
-
-function resolveDismissState(tasks: CLITask[], dismissedCompletionKey: string | null) {
-  const completionKey = buildCompletedTaskKey(tasks)
-  const keepDismissed = completionKey !== null && completionKey === dismissedCompletionKey
-
-  return {
-    completedAndDismissed: keepDismissed,
-    dismissedCompletionKey: keepDismissed ? completionKey : null,
-  }
-}
-
-function mapTodosToTasks(todos: TodoItem[], sessionId: string | null): CLITask[] {
-  return todos.map((todo, index) => ({
-    id: String(index + 1),
-    subject: todo.content,
-    description: '',
-    activeForm: todo.activeForm,
-    status: (['pending', 'in_progress', 'completed'].includes(todo.status)
-      ? todo.status
-      : 'pending') as TaskStatus,
-    blocks: [],
-    blockedBy: [],
-    taskListId: sessionId || '',
-  }))
-}
-
-export const useCLITaskStore = create<CLITaskStore>((set, get) => ({
-  sessionId: null,
-  tasks: [],
-  expanded: false,
-  completedAndDismissed: false,
-  dismissedCompletionKey: null,
-
-  fetchSessionTasks: async (sessionId) => {
-    set({ sessionId })
-    try {
-      const { tasks } = await cliTasksApi.getTasksForList(sessionId)
-      // Only update if still tracking the same session
-      if (get().sessionId === sessionId) {
-        set((state) => ({
-          tasks,
-          ...resolveDismissState(tasks, state.dismissedCompletionKey),
-        }))
-      }
-    } catch {
-      // No tasks for this session — that's fine
-      if (get().sessionId === sessionId) {
-        set({ tasks: [], completedAndDismissed: false, dismissedCompletionKey: null })
-      }
-    }
-  },
-
-  refreshTasks: async () => {
-    const { sessionId } = get()
-    if (!sessionId) return
-    try {
-      const { tasks } = await cliTasksApi.getTasksForList(sessionId)
-      if (get().sessionId === sessionId) {
-        set((state) => ({
-          tasks,
-          ...resolveDismissState(tasks, state.dismissedCompletionKey),
-        }))
-      }
-    } catch {
-      // ignore
-    }
-  },
-
-  setTasksFromTodos: (todos) => {
-    const tasks = mapTodosToTasks(todos, get().sessionId)
-    set((state) => ({
-      tasks,
-      ...resolveDismissState(tasks, state.dismissedCompletionKey),
-    }))
-  },
-
-  markCompletedAndDismissed: () => {
-    const completionKey = buildCompletedTaskKey(get().tasks)
-    if (!completionKey) return
-
-    set({
-      completedAndDismissed: true,
-      dismissedCompletionKey: completionKey,
-      expanded: false,
-    })
-  },
-
-  clearTasks: () => {
-    set({
-      sessionId: null,
-      tasks: [],
-      completedAndDismissed: false,
-      dismissedCompletionKey: null,
-      expanded: false,
-    })
-  },
-
-  toggleExpanded: () => {
-    set((s) => ({ expanded: !s.expanded }))
-  },
-}))

package/desktop/src/stores/hahaOAuthStore.test.ts

@@ -1,77 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-const { startMock, statusMock, logoutMock } = vi.hoisted(() => ({
-  startMock: vi.fn(),
-  statusMock: vi.fn(),
-  logoutMock: vi.fn(),
-}))
-
-vi.mock('../api/hahaOAuth', () => ({
-  hahaOAuthApi: {
-    start: startMock,
-    status: statusMock,
-    logout: logoutMock,
-  },
-}))
-
-import { useHahaOAuthStore } from './hahaOAuthStore'
-
-const initialState = useHahaOAuthStore.getState()
-
-describe('hahaOAuthStore', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-    startMock.mockReset()
-    statusMock.mockReset()
-    logoutMock.mockReset()
-    useHahaOAuthStore.setState({
-      ...initialState,
-      status: null,
-      isPolling: false,
-      isLoading: false,
-      error: null,
-    })
-  })
-
-  afterEach(() => {
-    useHahaOAuthStore.getState().stopPolling()
-    useHahaOAuthStore.setState(initialState)
-    vi.useRealTimers()
-  })
-
-  it('login does not start polling until the browser launch succeeds', async () => {
-    startMock.mockResolvedValue({
-      authorizeUrl: 'http://localhost:3456/api/haha-oauth/callback',
-      state: 'state-123',
-    })
-
-    const result = await useHahaOAuthStore.getState().login()
-
-    expect(result.authorizeUrl).toContain('/api/haha-oauth/callback')
-    expect(useHahaOAuthStore.getState().isPolling).toBe(false)
-  })
-
-  it('startPolling stops after the status becomes logged in', async () => {
-    statusMock
-      .mockResolvedValueOnce({ loggedIn: false })
-      .mockResolvedValueOnce({
-        loggedIn: true,
-        expiresAt: Date.now() + 60_000,
-        scopes: ['user:inference'],
-        subscriptionType: 'max',
-      })
-
-    useHahaOAuthStore.getState().startPolling()
-    expect(useHahaOAuthStore.getState().isPolling).toBe(true)
-
-    await vi.advanceTimersByTimeAsync(2_000)
-    expect(useHahaOAuthStore.getState().isPolling).toBe(true)
-
-    await vi.advanceTimersByTimeAsync(2_000)
-    expect(useHahaOAuthStore.getState().status).toMatchObject({
-      loggedIn: true,
-      subscriptionType: 'max',
-    })
-    expect(useHahaOAuthStore.getState().isPolling).toBe(false)
-  })
-})

package/desktop/src/stores/hahaOAuthStore.ts

@@ -1,97 +0,0 @@
-// desktop/src/stores/hahaOAuthStore.ts
-
-import { create } from 'zustand'
-import { hahaOAuthApi, type HahaOAuthStatus } from '../api/hahaOAuth'
-
-const POLL_INTERVAL_MS = 2_000
-
-type HahaOAuthState = {
-  status: HahaOAuthStatus | null
-  isPolling: boolean
-  isLoading: boolean
-  error: string | null
-
-  fetchStatus: () => Promise<void>
-  login: () => Promise<{ authorizeUrl: string }>
-  logout: () => Promise<void>
-  startPolling: () => void
-  stopPolling: () => void
-}
-
-export const useHahaOAuthStore = create<HahaOAuthState>((set, get) => {
-  let pollTimer: ReturnType<typeof setTimeout> | null = null
-
-  return {
-    status: null,
-    isPolling: false,
-    isLoading: false,
-    error: null,
-
-    fetchStatus: async () => {
-      try {
-        const status = await hahaOAuthApi.status()
-        set({ status, error: null })
-      } catch (err) {
-        set({ error: err instanceof Error ? err.message : String(err) })
-      }
-    },
-
-    login: async () => {
-      set({ isLoading: true, error: null })
-      try {
-        const res = await hahaOAuthApi.start()
-        set({ isLoading: false })
-        return { authorizeUrl: res.authorizeUrl }
-      } catch (err) {
-        set({
-          isLoading: false,
-          error: err instanceof Error ? err.message : String(err),
-        })
-        throw err
-      }
-    },
-
-    logout: async () => {
-      get().stopPolling()
-      set({ isLoading: true })
-      try {
-        await hahaOAuthApi.logout()
-        set({ status: { loggedIn: false }, isLoading: false })
-      } catch (err) {
-        set({
-          isLoading: false,
-          error: err instanceof Error ? err.message : String(err),
-        })
-        throw err
-      }
-    },
-
-    startPolling: () => {
-      if (pollTimer) return
-      set({ isPolling: true })
-
-      const scheduleNext = () => {
-        pollTimer = setTimeout(async () => {
-          await get().fetchStatus()
-          const cur = get().status
-          if (cur && cur.loggedIn) {
-            get().stopPolling()
-            return
-          }
-          if (get().isPolling) {
-            scheduleNext()
-          }
-        }, POLL_INTERVAL_MS)
-      }
-      scheduleNext()
-    },
-
-    stopPolling: () => {
-      if (pollTimer) {
-        clearTimeout(pollTimer)
-        pollTimer = null
-      }
-      set({ isPolling: false })
-    },
-  }
-})

package/desktop/src/stores/providerStore.ts

@@ -1,101 +0,0 @@
-// desktop/src/stores/providerStore.ts
-
-import { create } from 'zustand'
-import { providersApi } from '../api/providers'
-import { useSettingsStore } from './settingsStore'
-import type {
-  SavedProvider,
-  CreateProviderInput,
-  UpdateProviderInput,
-  TestProviderConfigInput,
-  ProviderTestResult,
-} from '../types/provider'
-
-// 与后端 src/server/api/models.ts 的 DEFAULT_MODEL 保持一致:
-// 切回"官方"时把聊天页的 currentModel 重置到这个,避免残留第三方 provider
-// 的 model id 在官方模型列表里找不到、ModelSelector 显示但不选中的状态。
-const OFFICIAL_DEFAULT_MODEL_ID = 'claude-opus-4-7'
-
-type ProviderStore = {
-  providers: SavedProvider[]
-  activeId: string | null
-  isLoading: boolean
-  error: string | null
-
-  fetchProviders: () => Promise<void>
-  createProvider: (input: CreateProviderInput) => Promise<SavedProvider>
-  updateProvider: (id: string, input: UpdateProviderInput) => Promise<SavedProvider>
-  deleteProvider: (id: string) => Promise<void>
-  activateProvider: (id: string) => Promise<void>
-  activateOfficial: () => Promise<void>
-  testProvider: (id: string, overrides?: { baseUrl?: string; modelId?: string; apiFormat?: string }) => Promise<ProviderTestResult>
-  testConfig: (input: TestProviderConfigInput) => Promise<ProviderTestResult>
-}
-
-export const useProviderStore = create<ProviderStore>((set, get) => ({
-  providers: [],
-  activeId: null,
-  isLoading: false,
-  error: null,
-
-  fetchProviders: async () => {
-    set({ isLoading: true, error: null })
-    try {
-      const { providers, activeId } = await providersApi.list()
-      set({ providers, activeId, isLoading: false })
-    } catch (err) {
-      set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
-    }
-  },
-
-  createProvider: async (input) => {
-    const { provider } = await providersApi.create(input)
-    await get().fetchProviders()
-    return provider
-  },
-
-  updateProvider: async (id, input) => {
-    const { provider } = await providersApi.update(id, input)
-    await get().fetchProviders()
-    return provider
-  },
-
-  deleteProvider: async (id) => {
-    await providersApi.delete(id)
-    await get().fetchProviders()
-  },
-
-  activateProvider: async (id) => {
-    await providersApi.activate(id)
-    await get().fetchProviders()
-    // 联动聊天页:把 currentModel 重置到新 provider 的 main model。
-    // 不这么做的话,用户在切换前手动选过的 model id (写进了 settings.json 的
-    // `model` 字段) 会继续被后端当作 explicit 返回,但新 provider 的模型列表
-    // 里没这个 id, ModelSelector 会卡在"显示旧名字 + radio 不选中"。
-    const provider = get().providers.find((p) => p.id === id)
-    if (provider) {
-      const settings = useSettingsStore.getState()
-      await settings.setModel(provider.models.main)
-      await settings.fetchAll()
-    }
-  },
-
-  activateOfficial: async () => {
-    await providersApi.activateOfficial()
-    await get().fetchProviders()
-    // 切回官方时同样重置 currentModel,避免残留第三方 model id。
-    const settings = useSettingsStore.getState()
-    await settings.setModel(OFFICIAL_DEFAULT_MODEL_ID)
-    await settings.fetchAll()
-  },
-
-  testProvider: async (id, overrides?) => {
-    const { result } = await providersApi.test(id, overrides)
-    return result
-  },
-
-  testConfig: async (input) => {
-    const { result } = await providersApi.testConfig(input)
-    return result
-  },
-}))

package/desktop/src/stores/sessionStore.test.ts

@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-const { createMock, listMock } = vi.hoisted(() => ({
-  createMock: vi.fn(),
-  listMock: vi.fn(),
-}))
-
-vi.mock('../api/sessions', () => ({
-  sessionsApi: {
-    create: createMock,
-    list: listMock,
-    delete: vi.fn(),
-    rename: vi.fn(),
-  },
-}))
-
-import { useSessionStore } from './sessionStore'
-
-const initialState = useSessionStore.getState()
-
-function delay(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-describe('sessionStore', () => {
-  beforeEach(() => {
-    createMock.mockReset()
-    listMock.mockReset()
-    useSessionStore.setState({
-      ...initialState,
-      sessions: [],
-      activeSessionId: null,
-      isLoading: false,
-      error: null,
-      selectedProjects: [],
-      availableProjects: [],
-    })
-  })
-
-  afterEach(() => {
-    useSessionStore.setState(initialState)
-  })
-
-  it('returns a new session id before the background refresh completes', async () => {
-    createMock.mockResolvedValue({ sessionId: 'session-optimistic-1' })
-    listMock.mockImplementation(() => new Promise(() => {}))
-
-    const result = await Promise.race([
-      useSessionStore.getState().createSession('D:/workspace/code/myself_code/cc-haha'),
-      delay(100).then(() => 'timed-out'),
-    ])
-
-    expect(result).toBe('session-optimistic-1')
-    expect(useSessionStore.getState().activeSessionId).toBe('session-optimistic-1')
-    expect(useSessionStore.getState().sessions[0]).toMatchObject({
-      id: 'session-optimistic-1',
-      title: 'New Session',
-      workDir: 'D:/workspace/code/myself_code/cc-haha',
-      workDirExists: true,
-    })
-    expect(listMock).toHaveBeenCalledOnce()
-  })
-})

package/desktop/src/stores/sessionStore.ts

@@ -1,102 +0,0 @@
-import { create } from 'zustand'
-import { sessionsApi } from '../api/sessions'
-import type { SessionListItem } from '../types/session'
-
-type SessionStore = {
-  sessions: SessionListItem[]
-  activeSessionId: string | null
-  isLoading: boolean
-  error: string | null
-  selectedProjects: string[]
-  availableProjects: string[]
-
-  fetchSessions: (project?: string) => Promise<void>
-  createSession: (workDir?: string) => Promise<string>
-  deleteSession: (id: string) => Promise<void>
-  renameSession: (id: string, title: string) => Promise<void>
-  updateSessionTitle: (id: string, title: string) => void
-  setActiveSession: (id: string | null) => void
-  setSelectedProjects: (projects: string[]) => void
-}
-
-export const useSessionStore = create<SessionStore>((set, get) => ({
-  sessions: [],
-  activeSessionId: null,
-  isLoading: false,
-  error: null,
-  selectedProjects: [],
-  availableProjects: [],
-
-  fetchSessions: async (project?: string) => {
-    set({ isLoading: true, error: null })
-    try {
-      const { sessions: raw } = await sessionsApi.list({ project, limit: 100 })
-      // Deduplicate by session ID — keep the most recently modified entry
-      const byId = new Map<string, SessionListItem>()
-      for (const s of raw) {
-        const existing = byId.get(s.id)
-        if (!existing || new Date(s.modifiedAt) > new Date(existing.modifiedAt)) {
-          byId.set(s.id, s)
-        }
-      }
-      const sessions = [...byId.values()]
-      const availableProjects = [...new Set(sessions.map((s) => s.projectPath).filter(Boolean))].sort()
-      set({ sessions, availableProjects, isLoading: false })
-    } catch (err) {
-      set({ error: (err as Error).message, isLoading: false })
-    }
-  },
-
-  createSession: async (workDir?: string) => {
-    const { sessionId: id } = await sessionsApi.create(workDir || undefined)
-    const now = new Date().toISOString()
-    const optimisticSession: SessionListItem = {
-      id,
-      title: 'New Session',
-      createdAt: now,
-      modifiedAt: now,
-      messageCount: 0,
-      projectPath: '',
-      workDir: workDir ?? null,
-      workDirExists: true,
-    }
-
-    set((state) => ({
-      sessions: state.sessions.some((session) => session.id === id)
-        ? state.sessions
-        : [optimisticSession, ...state.sessions],
-      activeSessionId: id,
-    }))
-
-    void get().fetchSessions()
-    return id
-  },
-
-  deleteSession: async (id: string) => {
-    await sessionsApi.delete(id)
-    set((s) => ({
-      sessions: s.sessions.filter((session) => session.id !== id),
-      activeSessionId: s.activeSessionId === id ? null : s.activeSessionId,
-    }))
-  },
-
-  renameSession: async (id: string, title: string) => {
-    await sessionsApi.rename(id, title)
-    set((s) => ({
-      sessions: s.sessions.map((session) =>
-        session.id === id ? { ...session, title } : session,
-      ),
-    }))
-  },
-
-  updateSessionTitle: (id, title) => {
-    set((s) => ({
-      sessions: s.sessions.map((session) =>
-        session.id === id ? { ...session, title } : session,
-      ),
-    }))
-  },
-
-  setActiveSession: (id) => set({ activeSessionId: id }),
-  setSelectedProjects: (projects) => set({ selectedProjects: projects }),
-}))