bingocode 1.0.2 → 1.0.3

package/desktop/src/stores/settingsStore.ts

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

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

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

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