rufloui 0.3.2 → 0.3.35

package/src/frontend/__tests__/store.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { useStore } from '../store'
+
+const testAgent = { id: 'a1', name: 'coder-1', type: 'coder', status: 'idle' as const, createdAt: '2025-01-01T00:00:00Z' }
+const testAgent2 = { id: 'a2', name: 'tester-1', type: 'tester', status: 'running' as const, createdAt: '2025-01-01T01:00:00Z' }
+const testTask = { id: 't1', title: 'Test', description: 'Desc', status: 'pending' as const, priority: 'normal' as const, createdAt: '2025-01-01T00:00:00Z' }
+const testTask2 = { id: 't2', title: 'Test 2', description: 'Desc 2', status: 'in_progress' as const, priority: 'high' as const, createdAt: '2025-01-01T01:00:00Z' }
+
+beforeEach(() => {
+  useStore.setState({
+    systemHealth: null, connected: false, wsStatus: 'disconnected',
+    backendReachable: false, swarm: null, agents: [], tasks: [],
+    memoryEntries: [], memoryStats: null, sessions: [], activeSession: null,
+    hiveMind: null, neural: null, performance: null, hooks: [], workflows: [],
+    coordination: null, vizSessions: [], selectedVizNode: null, swarmMonitor: null,
+    logs: [], _initialLoaded: false,
+  })
+})
+
+// ── Simple setters ──────────────────────────────────────────────────────
+
+describe('simple setters', () => {
+  it('setConnected updates connected', () => {
+    useStore.getState().setConnected(true)
+    expect(useStore.getState().connected).toBe(true)
+  })
+
+  it('setWsStatus updates wsStatus', () => {
+    useStore.getState().setWsStatus('connected')
+    expect(useStore.getState().wsStatus).toBe('connected')
+  })
+
+  it('setBackendReachable updates backendReachable', () => {
+    useStore.getState().setBackendReachable(true)
+    expect(useStore.getState().backendReachable).toBe(true)
+  })
+
+  it('setSystemHealth updates systemHealth', () => {
+    const health = { status: 'healthy' as const, uptime: '5m', cpu: 10, memory: 50, activeConnections: 1, mcpStatus: 'ok' }
+    useStore.getState().setSystemHealth(health)
+    expect(useStore.getState().systemHealth).toEqual(health)
+  })
+
+  it('setSwarm sets or clears swarm', () => {
+    const swarm = { id: 's1', topology: 'mesh' as const, strategy: 'round-robin', status: 'active' as const, maxAgents: 8, activeAgents: 2, agents: [], createdAt: '2025-01-01' }
+    useStore.getState().setSwarm(swarm)
+    expect(useStore.getState().swarm?.id).toBe('s1')
+    useStore.getState().setSwarm(null)
+    expect(useStore.getState().swarm).toBeNull()
+  })
+
+  it('setInitialLoaded sets _initialLoaded', () => {
+    expect(useStore.getState()._initialLoaded).toBe(false)
+    useStore.getState().setInitialLoaded()
+    expect(useStore.getState()._initialLoaded).toBe(true)
+  })
+})
+
+// ── Agent actions ───────────────────────────────────────────────────────
+
+describe('agent actions', () => {
+  it('setAgents replaces agents array', () => {
+    useStore.getState().setAgents([testAgent])
+    expect(useStore.getState().agents).toHaveLength(1)
+    expect(useStore.getState().agents[0].id).toBe('a1')
+  })
+
+  it('addAgent appends to agents', () => {
+    useStore.getState().setAgents([testAgent])
+    useStore.getState().addAgent(testAgent2)
+    expect(useStore.getState().agents).toHaveLength(2)
+    expect(useStore.getState().agents[1].id).toBe('a2')
+  })
+
+  it('updateAgent merges partial update', () => {
+    useStore.getState().setAgents([testAgent, testAgent2])
+    useStore.getState().updateAgent('a1', { status: 'running', currentTask: 'fix-bug' })
+    const updated = useStore.getState().agents.find(a => a.id === 'a1')
+    expect(updated?.status).toBe('running')
+    expect(updated?.currentTask).toBe('fix-bug')
+    expect(updated?.name).toBe('coder-1') // unchanged
+  })
+
+  it('updateAgent does nothing for unknown id', () => {
+    useStore.getState().setAgents([testAgent])
+    useStore.getState().updateAgent('unknown', { status: 'error' })
+    expect(useStore.getState().agents).toHaveLength(1)
+    expect(useStore.getState().agents[0].status).toBe('idle')
+  })
+
+  it('removeAgent filters out by id', () => {
+    useStore.getState().setAgents([testAgent, testAgent2])
+    useStore.getState().removeAgent('a1')
+    expect(useStore.getState().agents).toHaveLength(1)
+    expect(useStore.getState().agents[0].id).toBe('a2')
+  })
+
+  it('removeAgent does nothing for unknown id', () => {
+    useStore.getState().setAgents([testAgent])
+    useStore.getState().removeAgent('unknown')
+    expect(useStore.getState().agents).toHaveLength(1)
+  })
+})
+
+// ── Task actions ────────────────────────────────────────────────────────
+
+describe('task actions', () => {
+  it('setTasks replaces tasks array', () => {
+    useStore.getState().setTasks([testTask])
+    expect(useStore.getState().tasks).toHaveLength(1)
+  })
+
+  it('addTask appends to tasks', () => {
+    useStore.getState().setTasks([testTask])
+    useStore.getState().addTask(testTask2)
+    expect(useStore.getState().tasks).toHaveLength(2)
+  })
+
+  it('updateTask merges partial update', () => {
+    useStore.getState().setTasks([testTask])
+    useStore.getState().updateTask('t1', { status: 'completed', result: 'done' })
+    const updated = useStore.getState().tasks.find(t => t.id === 't1')
+    expect(updated?.status).toBe('completed')
+    expect(updated?.result).toBe('done')
+    expect(updated?.title).toBe('Test') // unchanged
+  })
+
+  it('updateTask does nothing for unknown id', () => {
+    useStore.getState().setTasks([testTask])
+    useStore.getState().updateTask('unknown', { status: 'failed' })
+    expect(useStore.getState().tasks[0].status).toBe('pending')
+  })
+})
+
+// ── Log actions ─────────────────────────────────────────────────────────
+
+describe('addLog', () => {
+  it('adds a log entry with id and timestamp', () => {
+    useStore.getState().addLog({ level: 'info', message: 'test', source: 'api' })
+    const logs = useStore.getState().logs
+    expect(logs).toHaveLength(1)
+    expect(logs[0].level).toBe('info')
+    expect(logs[0].message).toBe('test')
+    expect(logs[0].source).toBe('api')
+    expect(logs[0].id).toBeTruthy()
+    expect(logs[0].timestamp).toBeTruthy()
+  })
+
+  it('prepends new logs (newest first)', () => {
+    useStore.getState().addLog({ level: 'info', message: 'first', source: 'api' })
+    useStore.getState().addLog({ level: 'info', message: 'second', source: 'api' })
+    expect(useStore.getState().logs[0].message).toBe('second')
+    expect(useStore.getState().logs[1].message).toBe('first')
+  })
+
+  it('caps logs at 500 entries', () => {
+    for (let i = 0; i < 510; i++) {
+      useStore.getState().addLog({ level: 'info', message: `log-${i}`, source: 'api' })
+    }
+    expect(useStore.getState().logs.length).toBeLessThanOrEqual(500)
+  })
+})
+
+// ── Other collection setters ────────────────────────────────────────────
+
+describe('collection setters', () => {
+  it('setMemoryEntries sets memoryEntries', () => {
+    const entries = [{ key: 'k', value: 'v', namespace: 'default', tags: [], createdAt: '', updatedAt: '' }]
+    useStore.getState().setMemoryEntries(entries)
+    expect(useStore.getState().memoryEntries).toHaveLength(1)
+  })
+
+  it('setSessions sets sessions', () => {
+    const sessions = [{ id: 's1', name: 'test', status: 'saved' as const, createdAt: '', agentCount: 0, taskCount: 0 }]
+    useStore.getState().setSessions(sessions)
+    expect(useStore.getState().sessions).toHaveLength(1)
+  })
+
+  it('setWorkflows sets workflows', () => {
+    const workflows = [{ id: 'w1', name: 'wf', status: 'draft' as const, steps: [], createdAt: '' }]
+    useStore.getState().setWorkflows(workflows)
+    expect(useStore.getState().workflows).toHaveLength(1)
+  })
+
+  it('setHooks sets hooks', () => {
+    const hooks = [{ name: 'pre-task', type: 'shell', enabled: true, trigger: 'pre-task', runCount: 0 }]
+    useStore.getState().setHooks(hooks)
+    expect(useStore.getState().hooks).toHaveLength(1)
+  })
+})
+
+// ── Viz session actions ────────────────────────────────────────────────
+
+describe('viz session actions', () => {
+  it('setVizSessions sets vizSessions', () => {
+    const sessions = [{
+      sessionId: 'v1', taskId: 't1', startedAt: '2025-01-01',
+      tree: { id: 'root', sessionId: 'v1', status: 'active' as const, children: [] },
+    }]
+    useStore.getState().setVizSessions(sessions)
+    expect(useStore.getState().vizSessions).toHaveLength(1)
+  })
+
+  it('updateVizSession updates existing session', () => {
+    const tree = { id: 'root', sessionId: 'v1', status: 'active' as const, children: [] }
+    useStore.getState().setVizSessions([{ sessionId: 'v1', taskId: 't1', startedAt: '2025-01-01', tree }])
+
+    const updatedTree = { ...tree, status: 'done' as const }
+    useStore.getState().updateVizSession('v1', updatedTree)
+
+    const session = useStore.getState().vizSessions.find(v => v.sessionId === 'v1')
+    expect(session?.tree.status).toBe('done')
+  })
+
+  it('updateVizSession adds new session if not found', () => {
+    useStore.getState().setVizSessions([])
+    const tree = { id: 'root', sessionId: 'v2', status: 'active' as const, children: [], taskId: 'task-1' }
+    useStore.getState().updateVizSession('v2', tree)
+    expect(useStore.getState().vizSessions).toHaveLength(1)
+    expect(useStore.getState().vizSessions[0].sessionId).toBe('v2')
+  })
+
+  it('setSelectedVizNode sets and clears', () => {
+    useStore.getState().setSelectedVizNode('node-1')
+    expect(useStore.getState().selectedVizNode).toBe('node-1')
+    useStore.getState().setSelectedVizNode(null)
+    expect(useStore.getState().selectedVizNode).toBeNull()
+  })
+})
+
+// ── Swarm Monitor actions ──────────────────────────────────────────────
+
+describe('swarmMonitor actions', () => {
+  it('setSwarmMonitor sets or clears swarm monitor state', () => {
+    const monitor = {
+      swarmId: 's1', status: 'active', topology: 'mesh', objective: 'test',
+      strategy: 'round-robin', progress: 50,
+      agents: [], agentSummary: { total: 4, active: 2, idle: 1, completed: 1 },
+      taskSummary: { total: 10, completed: 5, inProgress: 3, pending: 2 },
+      metrics: { tokensUsed: 1000, avgResponseTime: '50ms', successRate: '90%', elapsedTime: '5m' },
+      coordination: { consensusRounds: 3, messagesSent: 100, conflictsResolved: 2 },
+    }
+    useStore.getState().setSwarmMonitor(monitor)
+    expect(useStore.getState().swarmMonitor?.swarmId).toBe('s1')
+    useStore.getState().setSwarmMonitor(null)
+    expect(useStore.getState().swarmMonitor).toBeNull()
+  })
+})
+
+// ── Additional setter tests ────────────────────────────────────────────
+
+describe('additional setters', () => {
+  it('setMemoryStats sets memoryStats', () => {
+    const stats = { totalEntries: 10, namespaces: ['default'], storageSize: '1MB', hnswEnabled: true, indexedVectors: 5 }
+    useStore.getState().setMemoryStats(stats)
+    expect(useStore.getState().memoryStats?.totalEntries).toBe(10)
+  })
+
+  it('setActiveSession sets and clears', () => {
+    const session = { id: 's1', name: 'test', status: 'active' as const, createdAt: '', agentCount: 0, taskCount: 0 }
+    useStore.getState().setActiveSession(session)
+    expect(useStore.getState().activeSession?.id).toBe('s1')
+    useStore.getState().setActiveSession(null)
+    expect(useStore.getState().activeSession).toBeNull()
+  })
+
+  it('setHiveMind sets hive mind state', () => {
+    const hm = { status: 'active' as const, members: ['a1', 'a2'], consensusProtocol: 'majority' }
+    useStore.getState().setHiveMind(hm)
+    expect(useStore.getState().hiveMind?.status).toBe('active')
+    expect(useStore.getState().hiveMind?.members).toHaveLength(2)
+  })
+
+  it('setNeural sets neural state', () => {
+    const neural = { enabled: true, models: [{ name: 'gpt', status: 'ready', accuracy: 0.95 }], trainingQueue: 0 }
+    useStore.getState().setNeural(neural)
+    expect(useStore.getState().neural?.enabled).toBe(true)
+    expect(useStore.getState().neural?.models).toHaveLength(1)
+  })
+
+  it('setPerformance sets performance metrics', () => {
+    const perf = {
+      latency: { avg: 50, p95: 100, p99: 200 }, throughput: 100,
+      errorRate: 0.01, activeRequests: 5, history: [],
+    }
+    useStore.getState().setPerformance(perf)
+    expect(useStore.getState().performance?.throughput).toBe(100)
+  })
+
+  it('setCoordination sets coordination metrics', () => {
+    const coord = { topology: 'mesh', nodes: 4, syncLatency: 10, consensusRounds: 5, loadDistribution: { a: 1, b: 2 } }
+    useStore.getState().setCoordination(coord)
+    expect(useStore.getState().coordination?.topology).toBe('mesh')
+  })
+})

package/src/frontend/api.ts

@@ -1,5 +1,5 @@
 import { useStore } from './store'
-import type { WebhookEvent, GitHubWebhookStatus } from './types'
+import type { WebhookEvent, GitHubWebhookStatus, GitLabWebhookStatus } from './types'
 
 export interface PreflightCheck {
   id: string
@@ -115,6 +115,7 @@ export const api = {
     complete: (id: string, result?: string) =>
       request(`/tasks/${id}/complete`, { method: 'POST', body: JSON.stringify({ result }) }),
     cancel: (id: string) => request(`/tasks/${id}/cancel`, { method: 'POST' }),
+    cleanCompleted: () => request<{ ok: boolean; deleted: number }>('/tasks/clean-completed', { method: 'POST' }),
     continue: (id: string, instruction: string) =>
       request(`/tasks/${id}/continue`, { method: 'POST', body: JSON.stringify({ instruction }) }),
     output: (id: string, tail = 200) =>
@@ -260,6 +261,12 @@ export const api = {
     getGitHubEvents: () => request<WebhookEvent[]>('/webhooks/github/events'),
     testGitHub: () => request<{ ok: boolean; eventId?: string; taskId?: string; error?: string }>(
       '/webhooks/github/test', { method: 'POST' }),
+    getGitLabConfig: () => request<GitLabWebhookStatus>('/webhooks/gitlab/config'),
+    setGitLabConfig: (config: Record<string, unknown>) =>
+      request('/webhooks/gitlab/config', { method: 'PUT', body: JSON.stringify(config) }),
+    getGitLabEvents: () => request<WebhookEvent[]>('/webhooks/gitlab/events'),
+    testGitLab: () => request<{ ok: boolean; eventId?: string; taskId?: string; error?: string }>(
+      '/webhooks/gitlab/test', { method: 'POST' }),
   },
 }
 

package/src/frontend/pages/TasksPanel.tsx

@@ -316,8 +316,13 @@ export default function TasksPanel() {
   const [expandedId, setExpandedId] = useState<string | null>(null)
   const [summary, setSummary] = useState<TaskSummary | null>(null)
   const [taskOutputs, setTaskOutputs] = useState<Record<string, string[]>>({})
+  const [cleaning, setCleaning] = useState(false)
   const intervalRef = useRef<ReturnType<typeof setInterval>>(undefined)
   const wsRef = useRef<WebSocket | null>(null)
+  // Track tasks updated via WebSocket to avoid poll overwriting them
+  const wsUpdatedRef = useRef<Map<string, { task: Task; ts: number }>>(new Map())
+  // Track cleaned task IDs so poll doesn't re-add them
+  const cleanedIdsRef = useRef<{ ids: Set<string>; ts: number }>({ ids: new Set(), ts: 0 })
 
   // Load persisted output history for a task
   const loadOutputHistory = useCallback(async (taskId: string) => {
@@ -358,6 +363,13 @@ export default function TasksPanel() {
             }))
           }
         }
+        // Track task updates from WebSocket so polling doesn't overwrite them
+        if ((msg.type === 'task:updated' || msg.type === 'task:added') && msg.payload) {
+          const t = msg.payload as Task
+          if (t.id) {
+            wsUpdatedRef.current.set(t.id, { task: t, ts: Date.now() })
+          }
+        }
       } catch { /* ignore */ }
     }
     return () => { ws.close() }
@@ -374,7 +386,33 @@ export default function TasksPanel() {
       ])
       if (taskRes.status === 'fulfilled') {
         const data = taskRes.value as { tasks?: Task[] } | Task[]
-        setTasks(Array.isArray(data) ? data : (data.tasks ?? []))
+        let polledTasks = Array.isArray(data) ? data : (data.tasks ?? [])
+        // Merge: prefer WebSocket-updated tasks over stale poll data (within 10s window)
+        const now = Date.now()
+        const wsMap = wsUpdatedRef.current
+        polledTasks = polledTasks.map(t => {
+          const ws = wsMap.get(t.id)
+          if (ws && now - ws.ts < 10_000) return ws.task
+          return t
+        })
+        // Add any WS tasks not yet in poll results (newly created)
+        for (const [id, ws] of wsMap.entries()) {
+          if (now - ws.ts < 10_000 && !polledTasks.find(t => t.id === id)) {
+            polledTasks.push(ws.task)
+          }
+        }
+        // Clean up old WS entries
+        for (const [id, ws] of wsMap.entries()) {
+          if (now - ws.ts > 10_000) wsMap.delete(id)
+        }
+        // Filter out recently cleaned tasks (prevent poll re-adding them)
+        const cleaned = cleanedIdsRef.current
+        if (cleaned.ids.size > 0 && now - cleaned.ts < 10_000) {
+          polledTasks = polledTasks.filter(t => !cleaned.ids.has(t.id))
+        } else if (cleaned.ids.size > 0) {
+          cleanedIdsRef.current = { ids: new Set(), ts: 0 }
+        }
+        setTasks(polledTasks)
       }
       if (summaryRes.status === 'fulfilled') {
         setSummary(summaryRes.value as TaskSummary)
@@ -392,6 +430,19 @@ export default function TasksPanel() {
     return () => clearInterval(intervalRef.current)
   }, [fetchData])
 
+  const handleCleanCompleted = async () => {
+    setCleaning(true)
+    // Optimistic: remove from local store immediately and prevent poll re-adding
+    const removedIds = new Set(tasks.filter(t => t.status === 'completed' || t.status === 'failed' || t.status === 'cancelled').map(t => t.id))
+    cleanedIdsRef.current = { ids: removedIds, ts: Date.now() }
+    setTasks(tasks.filter(t => !removedIds.has(t.id)))
+    try {
+      await api.tasks.cleanCompleted()
+    } catch { /* silent */ }
+    setCleaning(false)
+    fetchData()
+  }
+
   const handleCreate = async () => {
     if (!title.trim()) return
     setCreating(true)
@@ -477,7 +528,13 @@ export default function TasksPanel() {
               <div key={col.key} style={s.column}>
                 <div style={s.colHeader}>
                   {col.label}
-                  <span style={s.colCount}>{colTasks.length}</span>
+                  <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                    {(col.key === 'completed' || col.key === 'failed') && colTasks.length > 0 && (
+                      <Button size="sm" variant="ghost" loading={cleaning} onClick={(e) => { e.stopPropagation(); handleCleanCompleted() }}
+                        style={{ fontSize: 10, padding: '2px 6px', color: 'var(--text-muted)' }}>Clean</Button>
+                    )}
+                    <span style={s.colCount}>{colTasks.length}</span>
+                  </div>
                 </div>
                 <div style={s.colBody}>
                   {colTasks.length === 0 && (