bingocode 1.0.1 → 1.0.3

package/desktop/src/stores/cliTaskStore.ts

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

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

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

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

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

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