bingocode 1.0.2 → 1.0.3

package/desktop/src/stores/teamStore.ts

@@ -0,0 +1,344 @@
+import { create } from 'zustand'
+import { teamsApi } from '../api/teams'
+import type { TeamSummary, TeamDetail, TeamMember, AgentColor } from '../types/team'
+import { AGENT_COLORS } from '../types/team'
+import type { TeamMemberStatus, UIMessage } from '../types/chat'
+import { useChatStore, mapHistoryMessagesToUiMessages } from './chatStore'
+import { useTabStore } from './tabStore'
+
+const MEMBER_POLL_INTERVAL_MS = 1500
+const MEMBER_TRANSCRIPT_MATCH_WINDOW_MS = 120_000
+
+/** Generate a synthetic sessionId for team member tabs */
+const memberSessionId = (agentId: string) => `team-member:${agentId}`
+
+/** Module-level timer for polling member transcript */
+let memberPollTimer: ReturnType<typeof setInterval> | null = null
+let polledMemberSessionId: string | null = null
+
+function createMemberSessionState() {
+  return {
+    messages: [] as UIMessage[],
+    chatState: 'idle' as const,
+    connectionState: 'connected' as const,
+    streamingText: '',
+    streamingToolInput: '',
+    activeToolUseId: null,
+    activeToolName: null,
+    activeThinkingId: null,
+    pendingPermission: null,
+    pendingComputerUsePermission: null,
+    tokenUsage: { input_tokens: 0, output_tokens: 0 },
+    elapsedSeconds: 0,
+    statusVerb: '',
+    slashCommands: [],
+    agentTaskNotifications: {},
+    elapsedTimer: null,
+  }
+}
+
+function normalizeMemberStatus(status: string | undefined): TeamMember['status'] {
+  if (status === 'running' || status === 'idle' || status === 'completed') {
+    return status
+  }
+  return status === 'failed' ? 'error' : 'idle'
+}
+
+function toTeamMember(raw: Record<string, unknown>): TeamMember {
+  return {
+    agentId: (raw.agentId as string) || '',
+    name: raw.name as string | undefined,
+    role:
+      (raw.name as string) ||
+      (raw.agentType as string) ||
+      (raw.role as string) ||
+      (raw.agentId as string) ||
+      '',
+    status: normalizeMemberStatus(raw.status as string | undefined),
+    currentTask: raw.currentTask as string | undefined,
+    color: raw.color as AgentColor | undefined,
+    sessionId: raw.sessionId as string | undefined,
+  }
+}
+
+function isPendingMemberMessage(message: UIMessage): message is Extract<UIMessage, { type: 'user_text' }> & { pending: true } {
+  return message.type === 'user_text' && message.pending === true
+}
+
+function transcriptAlreadyContainsMessage(
+  transcriptMessages: UIMessage[],
+  pendingMessage: Extract<UIMessage, { type: 'user_text' }> & { pending: true },
+): boolean {
+  return transcriptMessages.some((message) => (
+    message.type === 'user_text' &&
+    message.pending !== true &&
+    message.content === pendingMessage.content &&
+    Math.abs(message.timestamp - pendingMessage.timestamp) <= MEMBER_TRANSCRIPT_MATCH_WINDOW_MS
+  ))
+}
+
+function mergeMemberTranscriptMessages(
+  existingMessages: UIMessage[],
+  transcriptMessages: UIMessage[],
+): UIMessage[] {
+  const pendingMessages = existingMessages.filter(isPendingMemberMessage).filter(
+    (message) => !transcriptAlreadyContainsMessage(transcriptMessages, message),
+  )
+
+  return pendingMessages.length > 0
+    ? [...transcriptMessages, ...pendingMessages]
+    : transcriptMessages
+}
+
+function syncMemberSessionMessages(
+  sessionId: string,
+  memberStatus: TeamMember['status'],
+  messages: UIMessage[],
+) {
+  const hasPendingMessages = messages.some(isPendingMemberMessage)
+  useChatStore.setState((state) => {
+    const existing = state.sessions[sessionId]
+    const nextState = existing ?? createMemberSessionState()
+    return {
+      sessions: {
+        ...state.sessions,
+        [sessionId]: {
+          ...nextState,
+          messages,
+          connectionState: 'connected',
+          chatState:
+            memberStatus === 'running' || hasPendingMessages
+              ? 'thinking'
+              : 'idle',
+        },
+      },
+    }
+  })
+}
+
+type TeamStore = {
+  teams: TeamSummary[]
+  activeTeam: TeamDetail | null
+  memberColors: Map<string, AgentColor>
+  error: string | null
+
+  fetchTeams: () => Promise<void>
+  fetchTeamDetail: (name: string) => Promise<void>
+  getMemberBySessionId: (sessionId: string) => TeamMember | null
+  refreshMemberSession: (sessionId: string) => Promise<void>
+  openMemberSession: (member: TeamMember) => void
+  sendMessageToMember: (sessionId: string, content: string) => Promise<void>
+  startMemberPolling: (sessionId: string, force?: boolean) => void
+  stopMemberPolling: () => void
+  clearTeam: () => void
+
+  // WebSocket handlers
+  handleTeamCreated: (teamName: string) => void
+  handleTeamUpdate: (teamName: string, members: TeamMemberStatus[]) => void
+  handleTeamDeleted: (teamName: string) => void
+}
+
+export const useTeamStore = create<TeamStore>((set, get) => ({
+  teams: [],
+  activeTeam: null,
+  memberColors: new Map(),
+  error: null,
+
+  fetchTeams: async () => {
+    set({ error: null })
+    try {
+      const { teams } = await teamsApi.list()
+      set({ teams })
+    } catch (err) {
+      set({ error: err instanceof Error ? err.message : String(err) })
+    }
+  },
+
+  fetchTeamDetail: async (name: string) => {
+    set({ error: null })
+    try {
+      const raw = await teamsApi.get(name) as Record<string, unknown>
+      const rawMembers = Array.isArray(raw.members) ? raw.members : []
+      const members: TeamMember[] = rawMembers.map((m: Record<string, unknown>) => toTeamMember(m))
+      const detail: TeamDetail = {
+        name: raw.name as string,
+        leadAgentId: raw.leadAgentId as string | undefined,
+        leadSessionId: raw.leadSessionId as string | undefined,
+        members,
+        createdAt: raw.createdAt != null ? String(raw.createdAt) : undefined,
+      }
+      // Assign colors to members
+      const colors = new Map<string, AgentColor>()
+      detail.members.forEach((m, i) => {
+        colors.set(m.agentId, AGENT_COLORS[i % AGENT_COLORS.length]!)
+      })
+      set({ activeTeam: detail, memberColors: colors })
+    } catch (err) {
+      set({ error: err instanceof Error ? err.message : String(err) })
+    }
+  },
+
+  getMemberBySessionId: (sessionId: string) => {
+    const team = get().activeTeam
+    if (!team) return null
+    return team.members.find(
+      (m) => m.sessionId === sessionId || memberSessionId(m.agentId) === sessionId,
+    ) ?? null
+  },
+
+  refreshMemberSession: async (sessionId) => {
+    const team = get().activeTeam
+    const member = get().getMemberBySessionId(sessionId)
+    if (!team || !member) return
+
+    try {
+      const { messages } = await teamsApi.getMemberTranscript(team.name, member.agentId)
+      const asEntries = messages.map((msg) => ({
+        id: msg.id,
+        type: msg.type,
+        content: msg.content,
+        timestamp: msg.timestamp,
+        model: msg.model,
+        parentToolUseId: msg.parentToolUseId,
+      }))
+      const transcriptMessages = mapHistoryMessagesToUiMessages(
+        asEntries as Parameters<typeof mapHistoryMessagesToUiMessages>[0],
+        { includeTeammateMessages: true },
+      )
+      const existingMessages = useChatStore.getState().sessions[sessionId]?.messages ?? []
+      const mergedMessages = mergeMemberTranscriptMessages(
+        existingMessages,
+        transcriptMessages,
+      )
+      syncMemberSessionMessages(sessionId, member.status, mergedMessages)
+    } catch {
+      const existingMessages = useChatStore.getState().sessions[sessionId]?.messages ?? []
+      syncMemberSessionMessages(sessionId, member.status, existingMessages)
+    }
+  },
+
+  openMemberSession: (member: TeamMember) => {
+    const team = get().activeTeam
+    if (!team) return
+
+    get().stopMemberPolling()
+
+    const tabId = memberSessionId(member.agentId)
+    useTabStore.getState().openTab(tabId, member.role, 'session')
+    void get().refreshMemberSession(tabId)
+    get().startMemberPolling(tabId)
+  },
+
+  sendMessageToMember: async (sessionId, content) => {
+    const team = get().activeTeam
+    const member = get().getMemberBySessionId(sessionId)
+    if (!team || !member) {
+      throw new Error('Team member session is no longer available')
+    }
+
+    await teamsApi.sendMemberMessage(team.name, member.agentId, content)
+    get().startMemberPolling(sessionId, true)
+    await get().refreshMemberSession(sessionId)
+  },
+
+  startMemberPolling: (sessionId, force = false) => {
+    const member = get().getMemberBySessionId(sessionId)
+    if (!member) return
+
+    const hasPendingMessages =
+      useChatStore.getState().sessions[sessionId]?.messages.some(isPendingMemberMessage) ?? false
+
+    if (!force && polledMemberSessionId === sessionId && memberPollTimer) {
+      return
+    }
+
+    if (member.status !== 'running' && !hasPendingMessages) {
+      get().stopMemberPolling()
+      return
+    }
+
+    get().stopMemberPolling()
+    polledMemberSessionId = sessionId
+    memberPollTimer = setInterval(() => {
+      const currentTabId = useTabStore.getState().activeTabId
+      if (currentTabId !== sessionId) {
+        get().stopMemberPolling()
+        return
+      }
+      void get().refreshMemberSession(sessionId)
+    }, MEMBER_POLL_INTERVAL_MS)
+  },
+
+  stopMemberPolling: () => {
+    if (memberPollTimer) {
+      clearInterval(memberPollTimer)
+      memberPollTimer = null
+    }
+    polledMemberSessionId = null
+  },
+
+  clearTeam: () => {
+    get().stopMemberPolling()
+    set({ activeTeam: null, memberColors: new Map() })
+  },
+
+  handleTeamCreated: (teamName: string) => {
+    set((s) => ({
+      teams: [...s.teams, { name: teamName, memberCount: 0 }],
+    }))
+    get().fetchTeamDetail(teamName)
+    setTimeout(() => get().fetchTeamDetail(teamName), 1500)
+    setTimeout(() => get().fetchTeamDetail(teamName), 4000)
+    setTimeout(() => get().fetchTeamDetail(teamName), 8000)
+  },
+
+  handleTeamUpdate: (teamName: string, members: TeamMemberStatus[]) => {
+    const team = get().activeTeam
+    if (team && team.name === teamName) {
+      if (members.length === 0) return
+
+      if (members.length > team.members.length) {
+        get().fetchTeamDetail(teamName)
+      }
+
+      const colors = get().memberColors
+      const existingMap = new Map(team.members.map((m) => [m.agentId, m]))
+      const incomingIds = new Set(members.map((m) => m.agentId))
+      const kept = team.members.filter((m) => !incomingIds.has(m.agentId))
+      const updatedMembers: TeamMember[] = [
+        ...kept,
+        ...members.map((m, i) => {
+          const existing = existingMap.get(m.agentId)
+          return {
+            ...(existing ?? {}),
+            name: existing?.name,
+            agentId: m.agentId,
+            role: m.role,
+            status: normalizeMemberStatus(m.status),
+            currentTask: m.currentTask,
+            color: colors.get(m.agentId) ?? AGENT_COLORS[i % AGENT_COLORS.length]!,
+            sessionId: existing?.sessionId,
+          }
+        }),
+      ]
+      set({ activeTeam: { ...team, members: updatedMembers } })
+
+      const currentTabId = useTabStore.getState().activeTabId
+      if (currentTabId) {
+        const viewedMember = get().getMemberBySessionId(currentTabId)
+        if (viewedMember) {
+          void get().refreshMemberSession(currentTabId)
+          get().startMemberPolling(currentTabId)
+        }
+      }
+    }
+  },
+
+  handleTeamDeleted: (teamName: string) => {
+    get().stopMemberPolling()
+    set((s) => ({
+      teams: s.teams.filter((t) => t.name !== teamName),
+      activeTeam: s.activeTeam?.name === teamName ? null : s.activeTeam,
+    }))
+  },
+}))

package/desktop/src/stores/uiStore.ts

@@ -0,0 +1,100 @@
+import { create } from 'zustand'
+import type { ThemeMode } from '../types/settings'
+
+const THEME_STORAGE_KEY = 'cc-haha-theme'
+
+function getStoredTheme(): ThemeMode {
+  try {
+    const stored = localStorage.getItem(THEME_STORAGE_KEY)
+    if (stored === 'light' || stored === 'dark') return stored
+  } catch { /* localStorage unavailable */ }
+  return 'light'
+}
+
+export function applyTheme(theme: ThemeMode) {
+  if (typeof document === 'undefined') return
+  document.documentElement.setAttribute('data-theme', theme)
+  document.documentElement.style.colorScheme = theme
+}
+
+export function initializeTheme() {
+  applyTheme(getStoredTheme())
+}
+
+export type Toast = {
+  id: string
+  type: 'success' | 'error' | 'warning' | 'info'
+  message: string
+  duration?: number
+}
+
+export type SettingsTab = 'providers' | 'permissions' | 'general' | 'adapters' | 'agents' | 'skills' | 'computerUse' | 'about'
+
+type ActiveView = 'code' | 'scheduled' | 'terminal' | 'history' | 'settings'
+
+type UIStore = {
+  theme: ThemeMode
+  sidebarOpen: boolean
+  activeView: ActiveView
+  pendingSettingsTab: SettingsTab | null
+  activeModal: string | null
+  toasts: Toast[]
+
+  setTheme: (theme: ThemeMode) => void
+  toggleTheme: () => void
+  toggleSidebar: () => void
+  setSidebarOpen: (open: boolean) => void
+  setActiveView: (view: ActiveView) => void
+  setPendingSettingsTab: (tab: SettingsTab | null) => void
+  openModal: (id: string) => void
+  closeModal: () => void
+  addToast: (toast: Omit<Toast, 'id'>) => void
+  removeToast: (id: string) => void
+}
+
+let toastCounter = 0
+
+export const useUIStore = create<UIStore>((set) => ({
+  theme: getStoredTheme(),
+  sidebarOpen: true,
+  activeView: 'code',
+  pendingSettingsTab: null,
+  activeModal: null,
+  toasts: [],
+
+  setTheme: (theme) => {
+    applyTheme(theme)
+    try { localStorage.setItem(THEME_STORAGE_KEY, theme) } catch { /* noop */ }
+    set({ theme })
+  },
+
+  toggleTheme: () => {
+    set((state) => {
+      const next = state.theme === 'light' ? 'dark' : 'light'
+      applyTheme(next)
+      try { localStorage.setItem(THEME_STORAGE_KEY, next) } catch { /* noop */ }
+      return { theme: next }
+    })
+  },
+
+  toggleSidebar: () => set((s) => ({ sidebarOpen: !s.sidebarOpen })),
+  setSidebarOpen: (open) => set({ sidebarOpen: open }),
+  setActiveView: (view) => set({ activeView: view }),
+  setPendingSettingsTab: (tab) => set({ pendingSettingsTab: tab }),
+  openModal: (id) => set({ activeModal: id }),
+  closeModal: () => set({ activeModal: null }),
+
+  addToast: (toast) => {
+    const id = `toast-${++toastCounter}`
+    set((s) => ({ toasts: [...s.toasts, { ...toast, id }] }))
+    // Auto-remove after duration
+    const duration = toast.duration ?? 4000
+    if (duration > 0) {
+      setTimeout(() => {
+        set((s) => ({ toasts: s.toasts.filter((t) => t.id !== id) }))
+      }, duration)
+    }
+  },
+
+  removeToast: (id) => set((s) => ({ toasts: s.toasts.filter((t) => t.id !== id) })),
+}))

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

@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const check = vi.fn()
+const relaunch = vi.fn()
+
+vi.mock('@tauri-apps/plugin-updater', () => ({
+  check,
+}))
+
+vi.mock('@tauri-apps/plugin-process', () => ({
+  relaunch,
+}))
+
+describe('updateStore', () => {
+  beforeEach(() => {
+    check.mockReset()
+    relaunch.mockReset()
+    Object.defineProperty(window, '__TAURI_INTERNALS__', {
+      configurable: true,
+      value: {},
+    })
+  })
+
+  it('stores available update metadata after a successful check', async () => {
+    const update = {
+      version: '0.2.0',
+      body: 'Bug fixes and performance improvements',
+      close: vi.fn().mockResolvedValue(undefined),
+    }
+    check.mockResolvedValue(update)
+
+    vi.resetModules()
+    const { useUpdateStore } = await import('./updateStore')
+
+    const result = await useUpdateStore.getState().checkForUpdates()
+
+    expect(result).toBe(update)
+    expect(useUpdateStore.getState().status).toBe('available')
+    expect(useUpdateStore.getState().availableVersion).toBe('0.2.0')
+    expect(useUpdateStore.getState().releaseNotes).toBe('Bug fixes and performance improvements')
+    expect(useUpdateStore.getState().shouldPrompt).toBe(true)
+  })
+
+  it('computes download progress from content length and relaunches after install', async () => {
+    const downloadAndInstall = vi.fn(async (onEvent?: (event: unknown) => void) => {
+      onEvent?.({ event: 'Started', data: { contentLength: 200 } })
+      onEvent?.({ event: 'Progress', data: { chunkLength: 50 } })
+      onEvent?.({ event: 'Progress', data: { chunkLength: 150 } })
+      onEvent?.({ event: 'Finished' })
+    })
+
+    check.mockResolvedValue({
+      version: '0.2.0',
+      body: 'Notes',
+      downloadAndInstall,
+      close: vi.fn().mockResolvedValue(undefined),
+    })
+    relaunch.mockResolvedValue(undefined)
+
+    vi.resetModules()
+    const { useUpdateStore } = await import('./updateStore')
+
+    await useUpdateStore.getState().checkForUpdates()
+    await useUpdateStore.getState().installUpdate()
+
+    expect(downloadAndInstall).toHaveBeenCalledTimes(1)
+    expect(useUpdateStore.getState().progressPercent).toBe(100)
+    expect(useUpdateStore.getState().status).toBe('restarting')
+    expect(relaunch).toHaveBeenCalledTimes(1)
+  })
+})