bingocode 1.0.3 → 1.0.4

package/desktop/src/stores/settingsStore.ts

@@ -1,120 +0,0 @@
-import { create } from 'zustand'
-import { settingsApi } from '../api/settings'
-import { modelsApi } from '../api/models'
-import type { PermissionMode, EffortLevel, ModelInfo, ThemeMode } from '../types/settings'
-import type { Locale } from '../i18n'
-import { useUIStore } from './uiStore'
-
-const LOCALE_STORAGE_KEY = 'cc-haha-locale'
-
-function getStoredLocale(): Locale {
-  try {
-    const stored = localStorage.getItem(LOCALE_STORAGE_KEY)
-    if (stored === 'en' || stored === 'zh') return stored
-  } catch { /* localStorage unavailable */ }
-  return 'en'
-}
-
-type SettingsStore = {
-  permissionMode: PermissionMode
-  currentModel: ModelInfo | null
-  effortLevel: EffortLevel
-  availableModels: ModelInfo[]
-  activeProviderName: string | null
-  locale: Locale
-  theme: ThemeMode
-  isLoading: boolean
-  error: string | null
-
-  fetchAll: () => Promise<void>
-  setPermissionMode: (mode: PermissionMode) => Promise<void>
-  setModel: (modelId: string) => Promise<void>
-  setEffort: (level: EffortLevel) => Promise<void>
-  setLocale: (locale: Locale) => void
-  setTheme: (theme: ThemeMode) => Promise<void>
-}
-
-export const useSettingsStore = create<SettingsStore>((set, get) => ({
-  permissionMode: 'default',
-  currentModel: null,
-  effortLevel: 'high',
-  availableModels: [],
-  activeProviderName: null,
-  locale: getStoredLocale(),
-  theme: useUIStore.getState().theme,
-  isLoading: false,
-  error: null,
-
-  fetchAll: async () => {
-    set({ isLoading: true, error: null })
-    try {
-      const [{ mode }, modelsRes, { model }, { level }, userSettings] = await Promise.all([
-        settingsApi.getPermissionMode(),
-        modelsApi.list(),
-        modelsApi.getCurrent(),
-        modelsApi.getEffort(),
-        settingsApi.getUser(),
-      ])
-      const theme = userSettings.theme === 'dark' ? 'dark' : 'light'
-      useUIStore.getState().setTheme(theme)
-      set({
-        permissionMode: mode,
-        availableModels: modelsRes.models,
-        activeProviderName: modelsRes.provider?.name ?? null,
-        currentModel: model,
-        effortLevel: level,
-        theme,
-        isLoading: false,
-        error: null,
-      })
-    } catch (error) {
-      const message =
-        error instanceof Error ? error.message : 'Failed to load desktop settings'
-      set({ isLoading: false, error: message })
-      throw error
-    }
-  },
-
-  setPermissionMode: async (mode) => {
-    const prev = get().permissionMode
-    set({ permissionMode: mode })
-    try {
-      await settingsApi.setPermissionMode(mode)
-    } catch {
-      set({ permissionMode: prev })
-    }
-  },
-
-  setModel: async (modelId) => {
-    await modelsApi.setCurrent(modelId)
-    const { model } = await modelsApi.getCurrent()
-    set({ currentModel: model })
-  },
-
-  setEffort: async (level) => {
-    const prev = get().effortLevel
-    set({ effortLevel: level })
-    try {
-      await modelsApi.setEffort(level)
-    } catch {
-      set({ effortLevel: prev })
-    }
-  },
-
-  setLocale: (locale) => {
-    set({ locale })
-    try { localStorage.setItem(LOCALE_STORAGE_KEY, locale) } catch { /* noop */ }
-  },
-
-  setTheme: async (theme) => {
-    const prev = get().theme
-    set({ theme })
-    useUIStore.getState().setTheme(theme)
-    try {
-      await settingsApi.updateUser({ theme })
-    } catch {
-      set({ theme: prev })
-      useUIStore.getState().setTheme(prev)
-    }
-  },
-}))

package/desktop/src/stores/skillStore.ts

@@ -1,51 +0,0 @@
-import { create } from 'zustand'
-import { skillsApi } from '../api/skills'
-import type { SkillMeta, SkillDetail } from '../types/skill'
-
-type SkillStore = {
-  skills: SkillMeta[]
-  selectedSkill: SkillDetail | null
-  isLoading: boolean
-  isDetailLoading: boolean
-  error: string | null
-
-  fetchSkills: (cwd?: string) => Promise<void>
-  fetchSkillDetail: (source: string, name: string, cwd?: string) => Promise<void>
-  clearSelection: () => void
-}
-
-export const useSkillStore = create<SkillStore>((set) => ({
-  skills: [],
-  selectedSkill: null,
-  isLoading: false,
-  isDetailLoading: false,
-  error: null,
-
-  fetchSkills: async (cwd) => {
-    set({ isLoading: true, error: null })
-    try {
-      const { skills } = await skillsApi.list(cwd)
-      set({ skills, isLoading: false })
-    } catch (err) {
-      set({
-        error: err instanceof Error ? err.message : String(err),
-        isLoading: false,
-      })
-    }
-  },
-
-  fetchSkillDetail: async (source, name, cwd) => {
-    set({ isDetailLoading: true, error: null })
-    try {
-      const { detail } = await skillsApi.detail(source, name, cwd)
-      set({ selectedSkill: detail, isDetailLoading: false })
-    } catch (err) {
-      set({
-        error: err instanceof Error ? err.message : String(err),
-        isDetailLoading: false,
-      })
-    }
-  },
-
-  clearSelection: () => set({ selectedSkill: null }),
-}))

package/desktop/src/stores/tabStore.ts

@@ -1,169 +0,0 @@
-import { create } from 'zustand'
-import { sessionsApi } from '../api/sessions'
-
-const TAB_STORAGE_KEY = 'cc-haha-open-tabs'
-
-export const SETTINGS_TAB_ID = '__settings__'
-export const SCHEDULED_TAB_ID = '__scheduled__'
-
-export type TabType = 'session' | 'settings' | 'scheduled'
-
-export type Tab = {
-  sessionId: string
-  title: string
-  type: TabType
-  status: 'idle' | 'running' | 'error'
-}
-
-type TabPersistence = {
-  openTabs: Array<{ sessionId: string; title: string; type?: TabType }>
-  activeTabId: string | null
-}
-
-type TabStore = {
-  tabs: Tab[]
-  activeTabId: string | null
-
-  openTab: (sessionId: string, title: string, type?: TabType) => void
-  closeTab: (sessionId: string) => void
-  setActiveTab: (sessionId: string) => void
-  updateTabTitle: (sessionId: string, title: string) => void
-  updateTabStatus: (sessionId: string, status: Tab['status']) => void
-  replaceTabSession: (oldSessionId: string, newSessionId: string) => void
-  moveTab: (fromIndex: number, toIndex: number) => void
-
-  saveTabs: () => void
-  restoreTabs: () => Promise<void>
-}
-
-export const useTabStore = create<TabStore>((set, get) => ({
-  tabs: [],
-  activeTabId: null,
-
-  openTab: (sessionId, title, type = 'session') => {
-    const { tabs } = get()
-    const existing = tabs.find((t) => t.sessionId === sessionId)
-    if (existing) {
-      set({ activeTabId: sessionId })
-    } else {
-      set({
-        tabs: [...tabs, { sessionId, title, type, status: 'idle' }],
-        activeTabId: sessionId,
-      })
-    }
-    get().saveTabs()
-  },
-
-  closeTab: (sessionId) => {
-    const { tabs, activeTabId } = get()
-    const index = tabs.findIndex((t) => t.sessionId === sessionId)
-    if (index < 0) return
-
-    const newTabs = tabs.filter((t) => t.sessionId !== sessionId)
-    let newActiveId = activeTabId
-
-    if (activeTabId === sessionId) {
-      if (newTabs.length === 0) {
-        newActiveId = null
-      } else if (index >= newTabs.length) {
-        newActiveId = newTabs[newTabs.length - 1]!.sessionId
-      } else {
-        newActiveId = newTabs[index]!.sessionId
-      }
-    }
-
-    set({ tabs: newTabs, activeTabId: newActiveId })
-    get().saveTabs()
-  },
-
-  setActiveTab: (sessionId) => {
-    set({ activeTabId: sessionId })
-    get().saveTabs()
-  },
-
-  updateTabTitle: (sessionId, title) => {
-    set((s) => ({
-      tabs: s.tabs.map((t) => (t.sessionId === sessionId ? { ...t, title } : t)),
-    }))
-    get().saveTabs()
-  },
-
-  updateTabStatus: (sessionId, status) => {
-    set((s) => ({
-      tabs: s.tabs.map((t) => (t.sessionId === sessionId ? { ...t, status } : t)),
-    }))
-  },
-
-  replaceTabSession: (oldSessionId, newSessionId) => {
-    const { activeTabId } = get()
-    set((s) => ({
-      tabs: s.tabs.map((t) =>
-        t.sessionId === oldSessionId ? { ...t, sessionId: newSessionId } : t,
-      ),
-      activeTabId: activeTabId === oldSessionId ? newSessionId : activeTabId,
-    }))
-    get().saveTabs()
-  },
-
-  moveTab: (fromIndex, toIndex) => {
-    if (fromIndex === toIndex) return
-    const { tabs } = get()
-    if (fromIndex < 0 || fromIndex >= tabs.length || toIndex < 0 || toIndex >= tabs.length) return
-    const newTabs = [...tabs]
-    const [moved] = newTabs.splice(fromIndex, 1)
-    newTabs.splice(toIndex, 0, moved!)
-    set({ tabs: newTabs })
-    get().saveTabs()
-  },
-
-  saveTabs: () => {
-    const { tabs, activeTabId } = get()
-    const data: TabPersistence = {
-      openTabs: tabs.map((t) => ({ sessionId: t.sessionId, title: t.title, type: t.type })),
-      activeTabId,
-    }
-    try {
-      localStorage.setItem(TAB_STORAGE_KEY, JSON.stringify(data))
-    } catch { /* noop */ }
-  },
-
-  restoreTabs: async () => {
-    try {
-      const raw = localStorage.getItem(TAB_STORAGE_KEY)
-      if (!raw) return
-
-      const data = JSON.parse(raw) as TabPersistence
-      if (!data.openTabs || data.openTabs.length === 0) return
-
-      const { sessions } = await sessionsApi.list({ limit: 200 })
-      const existingIds = new Set(sessions.map((s) => s.id))
-
-      const validTabs: Tab[] = data.openTabs
-        .filter((t) => {
-          // Special tabs are always valid
-          if (t.type === 'settings' || t.type === 'scheduled') return true
-          // Session tabs must exist on server
-          return existingIds.has(t.sessionId)
-        })
-        .map((t) => {
-          if (t.type === 'settings' || t.type === 'scheduled') {
-            return { sessionId: t.sessionId, title: t.title, type: t.type, status: 'idle' as const }
-          }
-          return {
-            sessionId: t.sessionId,
-            title: sessions.find((s) => s.id === t.sessionId)?.title || t.title,
-            type: 'session' as const,
-            status: 'idle' as const,
-          }
-        })
-
-      if (validTabs.length === 0) return
-
-      const activeId = data.activeTabId && validTabs.some((t) => t.sessionId === data.activeTabId)
-        ? data.activeTabId
-        : validTabs[0]!.sessionId
-
-      set({ tabs: validTabs, activeTabId: activeId })
-    } catch { /* noop */ }
-  },
-}))

package/desktop/src/stores/taskStore.ts

@@ -1,68 +0,0 @@
-import { create } from 'zustand'
-import { tasksApi } from '../api/tasks'
-import type { CronTask, CreateTaskInput, TaskRun } from '../types/task'
-
-type TaskStore = {
-  tasks: CronTask[]
-  recentRuns: TaskRun[]
-  isLoading: boolean
-  error: string | null
-
-  fetchTasks: () => Promise<void>
-  createTask: (input: CreateTaskInput) => Promise<void>
-  updateTask: (id: string, updates: Partial<CronTask>) => Promise<void>
-  deleteTask: (id: string) => Promise<void>
-  runTask: (taskId: string) => Promise<void>
-  fetchRecentRuns: () => Promise<void>
-  fetchTaskRuns: (taskId: string) => Promise<TaskRun[]>
-}
-
-export const useTaskStore = create<TaskStore>((set) => ({
-  tasks: [],
-  recentRuns: [],
-  isLoading: false,
-  error: null,
-
-  fetchTasks: async () => {
-    set({ isLoading: true, error: null })
-    try {
-      const { tasks } = await tasksApi.list()
-      set({ tasks, isLoading: false })
-    } catch (err) {
-      set({ error: (err as Error).message, isLoading: false })
-    }
-  },
-
-  createTask: async (input) => {
-    const { task } = await tasksApi.create(input)
-    set((s) => ({ tasks: [...s.tasks, task] }))
-  },
-
-  updateTask: async (id, updates) => {
-    const { task } = await tasksApi.update(id, updates)
-    set((s) => ({ tasks: s.tasks.map((t) => (t.id === id ? task : t)) }))
-  },
-
-  deleteTask: async (id) => {
-    await tasksApi.delete(id)
-    set((s) => ({ tasks: s.tasks.filter((t) => t.id !== id) }))
-  },
-
-  runTask: async (taskId) => {
-    await tasksApi.runTask(taskId)
-  },
-
-  fetchRecentRuns: async () => {
-    try {
-      const { runs } = await tasksApi.getRecentRuns()
-      set({ recentRuns: runs })
-    } catch {
-      // ignore
-    }
-  },
-
-  fetchTaskRuns: async (taskId) => {
-    const { runs } = await tasksApi.getTaskRuns(taskId)
-    return runs
-  },
-}))