helixevo 0.2.24 → 0.2.25

package/dashboard/app/api/run/route.ts

@@ -3,7 +3,6 @@ import { spawn, type ChildProcess } from 'child_process'
 
 export const dynamic = 'force-dynamic'
 
-// Allowed commands — whitelist to prevent arbitrary execution
 const ALLOWED_COMMANDS: Record<string, { cmd: string; args: string[]; timeout: number }> = {
   'status':         { cmd: 'helixevo', args: ['status'],                           timeout: 15000 },
   'health':         { cmd: 'helixevo', args: ['health', '--verbose'],              timeout: 120000 },
@@ -19,93 +18,103 @@ const ALLOWED_COMMANDS: Record<string, { cmd: string; args: string[]; timeout: n
   'report':         { cmd: 'helixevo', args: ['report', '--days', '7'],            timeout: 30000 },
 }
 
-// Track the currently running process so it can be stopped
 let activeProcess: ChildProcess | null = null
 let activeCommand: string | null = null
 
+// POST — stream output via SSE
 export async function POST(request: Request) {
   const body = await request.json()
   const { command } = body as { command: string }
 
   const entry = ALLOWED_COMMANDS[command]
   if (!entry) {
-    return NextResponse.json({
-      success: false,
-      error: `Unknown command: ${command}`,
-    }, { status: 400 })
+    return NextResponse.json({ success: false, error: `Unknown command: ${command}` }, { status: 400 })
   }
 
-  // Kill any existing process before starting a new one
+  // Kill any existing process
   if (activeProcess && !activeProcess.killed) {
     activeProcess.kill('SIGTERM')
     activeProcess = null
     activeCommand = null
   }
 
-  return new Promise<Response>((resolve) => {
-    let output = ''
-    let timedOut = false
-
-    const child = spawn(entry.cmd, entry.args, {
-      env: { ...process.env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-
-    activeProcess = child
-    activeCommand = command
-
-    const timeout = setTimeout(() => {
-      timedOut = true
-      child.kill('SIGTERM')
-    }, entry.timeout)
-
-    child.stdout?.on('data', (data: Buffer) => {
-      output += data.toString()
-    })
-
-    child.stderr?.on('data', (data: Buffer) => {
-      output += data.toString()
-    })
-
-    child.on('close', (code, signal) => {
-      clearTimeout(timeout)
-      activeProcess = null
-      activeCommand = null
-
-      if (signal === 'SIGTERM' && !timedOut) {
-        // Stopped by user
-        resolve(NextResponse.json({
-          success: false,
-          stopped: true,
-          output: output + '\n\n[Stopped by user]',
-        }))
-      } else if (timedOut) {
-        resolve(NextResponse.json({
-          success: false,
-          output: output + '\n\n[Timed out]',
-        }, { status: 500 }))
-      } else {
-        resolve(NextResponse.json({
-          success: code === 0,
-          command: `${entry.cmd} ${entry.args.join(' ')}`,
-          output: output || 'No output',
-        }, code === 0 ? {} : { status: 500 }))
+  const encoder = new TextEncoder()
+  let timedOut = false
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const child = spawn(entry.cmd, entry.args, {
+        env: { ...process.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      activeProcess = child
+      activeCommand = command
+
+      const timeout = setTimeout(() => {
+        timedOut = true
+        child.kill('SIGTERM')
+      }, entry.timeout)
+
+      const send = (event: string, data: string) => {
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`))
+        } catch {}
       }
-    })
-
-    child.on('error', (err) => {
-      clearTimeout(timeout)
-      activeProcess = null
-      activeCommand = null
-      resolve(NextResponse.json({
-        success: false,
-        output: err.message,
-      }, { status: 500 }))
-    })
+
+      child.stdout?.on('data', (chunk: Buffer) => {
+        send('output', chunk.toString())
+      })
+
+      child.stderr?.on('data', (chunk: Buffer) => {
+        send('output', chunk.toString())
+      })
+
+      child.on('close', (code, signal) => {
+        clearTimeout(timeout)
+        activeProcess = null
+        activeCommand = null
+
+        if (signal === 'SIGTERM' && !timedOut) {
+          send('done', JSON.stringify({ success: false, stopped: true }))
+        } else if (timedOut) {
+          send('done', JSON.stringify({ success: false, timedOut: true }))
+        } else {
+          send('done', JSON.stringify({ success: code === 0 }))
+        }
+
+        try { controller.close() } catch {}
+      })
+
+      child.on('error', (err) => {
+        clearTimeout(timeout)
+        activeProcess = null
+        activeCommand = null
+        send('output', `Error: ${err.message}`)
+        send('done', JSON.stringify({ success: false }))
+        try { controller.close() } catch {}
+      })
+    },
+
+    cancel() {
+      if (activeProcess && !activeProcess.killed) {
+        activeProcess.kill('SIGTERM')
+        activeProcess = null
+        activeCommand = null
+      }
+    },
+  })
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
   })
 }
 
-// DELETE = stop the running command
+// DELETE = stop
 export async function DELETE() {
   if (activeProcess && !activeProcess.killed) {
     const cmd = activeCommand
@@ -117,7 +126,7 @@ export async function DELETE() {
   return NextResponse.json({ stopped: false, message: 'No running command' })
 }
 
-// GET = check if something is running
+// GET = check status
 export async function GET() {
   return NextResponse.json({
     running: activeProcess !== null && !activeProcess.killed,

package/dashboard/app/research/client.tsx

@@ -59,12 +59,13 @@ const PIPELINE_STEPS = [
 
 export default function ResearchClient({ buffer, projects }: Props) {
   const [runState, setRunState] = useState<RunState>('idle')
-  const [output, setOutput] = useState<string | null>(null)
+  const [output, setOutput] = useState<string>('')
   const abortRef = useRef<AbortController | null>(null)
+  const outputRef = useRef<HTMLPreElement | null>(null)
 
   const handleRun = async () => {
     setRunState('running')
-    setOutput(null)
+    setOutput('')
     const controller = new AbortController()
     abortRef.current = controller
 
@@ -75,21 +76,58 @@ export default function ResearchClient({ buffer, projects }: Props) {
         body: JSON.stringify({ command: 'research' }),
         signal: controller.signal,
       })
-      const data = await res.json()
-      if (data.stopped) {
-        setOutput(data.output ?? 'Stopped')
-        setRunState('stopped')
-      } else {
-        setOutput(data.output ?? data.error ?? 'No output')
-        setRunState(data.success ? 'success' : 'error')
+
+      if (!res.body) {
+        setOutput('No response body')
+        setRunState('error')
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let sseBuffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        sseBuffer += decoder.decode(value, { stream: true })
+        const events = sseBuffer.split('\n\n')
+        sseBuffer = events.pop() ?? ''
+
+        for (const event of events) {
+          const lines = event.split('\n')
+          let eventType = ''
+          let eventData = ''
+          for (const line of lines) {
+            if (line.startsWith('event: ')) eventType = line.slice(7)
+            if (line.startsWith('data: ')) eventData = line.slice(6)
+          }
+          if (eventType === 'output' && eventData) {
+            try {
+              const text = JSON.parse(eventData) as string
+              setOutput(prev => prev + text)
+              setTimeout(() => {
+                if (outputRef.current) outputRef.current.scrollTop = outputRef.current.scrollHeight
+              }, 10)
+            } catch {}
+          }
+          if (eventType === 'done' && eventData) {
+            try {
+              const result = JSON.parse(JSON.parse(eventData) as string) as { success: boolean; stopped?: boolean }
+              setRunState(result.stopped ? 'stopped' : result.success ? 'success' : 'error')
+            } catch {}
+          }
+        }
       }
+      if (runState === 'running') setRunState('success')
     } catch (err: unknown) {
       if (err instanceof Error && err.name === 'AbortError') {
         try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
-        setOutput('Stopped by user')
+        setOutput(prev => prev + '\n\n[Stopped by user]')
         setRunState('stopped')
       } else {
-        setOutput('Network error')
+        setOutput(prev => prev || 'Network error')
         setRunState('error')
       }
     } finally {
@@ -220,29 +258,29 @@ export default function ResearchClient({ buffer, projects }: Props) {
       </div>
 
       {/* Output panel */}
-      {runState !== 'idle' && output && (
+      {runState !== 'idle' && (
         <div className="card" style={{ marginBottom: 24, overflow: 'hidden' }}>
           <div style={{
             padding: '10px 16px',
-            background: runState === 'success' ? 'var(--green-light)' : runState === 'error' ? 'var(--red-light)' : 'var(--bg-section)',
+            background: runState === 'success' ? 'var(--green-light)' : runState === 'error' ? 'var(--red-light)' : runState === 'stopped' ? 'var(--yellow-light)' : 'var(--bg-section)',
             borderBottom: '1px solid var(--border)',
             fontSize: 12, fontWeight: 600,
-            color: runState === 'success' ? 'var(--green)' : runState === 'error' ? 'var(--red)' : 'var(--text-secondary)',
+            color: runState === 'success' ? 'var(--green)' : runState === 'error' ? 'var(--red)' : runState === 'stopped' ? 'var(--yellow)' : 'var(--text-secondary)',
           }}>
             {runState === 'running' && '● Running research pipeline...'}
             {runState === 'success' && '✓ Research completed'}
             {runState === 'error' && '✗ Research failed'}
             {runState === 'stopped' && '■ Research stopped'}
           </div>
-          <pre style={{
+          <pre ref={outputRef} style={{
             padding: '14px 16px', margin: 0,
             fontSize: 11, lineHeight: 1.55,
             fontFamily: 'var(--font-mono)',
             color: 'var(--text-secondary)',
-            maxHeight: 300, overflow: 'auto',
+            maxHeight: 400, overflow: 'auto',
             whiteSpace: 'pre-wrap', wordBreak: 'break-word',
           }}>
-            {output}
+            {output || 'Starting research pipeline...'}
           </pre>
         </div>
       )}

package/dashboard/components/quick-actions.tsx

@@ -25,14 +25,15 @@ type RunState = 'idle' | 'running' | 'success' | 'error' | 'stopped'
 export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActionsProps) {
   const [running, setRunning] = useState<string | null>(null)
   const [state, setState] = useState<RunState>('idle')
-  const [output, setOutput] = useState<string | null>(null)
+  const [output, setOutput] = useState<string>('')
   const abortRef = useRef<AbortController | null>(null)
+  const outputRef = useRef<HTMLPreElement | null>(null)
 
   const handleRun = async (action: Action) => {
     if (action.disabled) return
     setRunning(action.id)
     setState('running')
-    setOutput(null)
+    setOutput('')
 
     const controller = new AbortController()
     abortRef.current = controller
@@ -44,21 +45,76 @@ export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActions
         body: JSON.stringify({ command: action.command }),
         signal: controller.signal,
       })
-      const data = await res.json()
-      if (data.stopped) {
-        setOutput(data.output ?? 'Stopped')
-        setState('stopped')
-      } else {
-        setOutput(data.output ?? data.error ?? 'No output')
-        setState(data.success ? 'success' : 'error')
+
+      if (!res.body) {
+        setOutput('No response body')
+        setState('error')
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+
+        // Parse SSE events from buffer
+        const events = buffer.split('\n\n')
+        buffer = events.pop() ?? '' // keep incomplete event
+
+        for (const event of events) {
+          const lines = event.split('\n')
+          let eventType = ''
+          let eventData = ''
+
+          for (const line of lines) {
+            if (line.startsWith('event: ')) eventType = line.slice(7)
+            if (line.startsWith('data: ')) eventData = line.slice(6)
+          }
+
+          if (eventType === 'output' && eventData) {
+            try {
+              const text = JSON.parse(eventData) as string
+              setOutput(prev => prev + text)
+              // Auto-scroll to bottom
+              setTimeout(() => {
+                if (outputRef.current) {
+                  outputRef.current.scrollTop = outputRef.current.scrollHeight
+                }
+              }, 10)
+            } catch {}
+          }
+
+          if (eventType === 'done' && eventData) {
+            try {
+              const result = JSON.parse(JSON.parse(eventData) as string) as { success: boolean; stopped?: boolean; timedOut?: boolean }
+              if (result.stopped) {
+                setOutput(prev => prev + '\n\n[Stopped by user]')
+                setState('stopped')
+              } else if (result.timedOut) {
+                setOutput(prev => prev + '\n\n[Timed out]')
+                setState('error')
+              } else {
+                setState(result.success ? 'success' : 'error')
+              }
+            } catch {}
+          }
+        }
       }
+
+      // If we reach here without a 'done' event, mark as complete
+      if (state === 'running') setState('success')
     } catch (err: unknown) {
       if (err instanceof Error && err.name === 'AbortError') {
         try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
-        setOutput('Stopped by user')
+        setOutput(prev => prev + '\n\n[Stopped by user]')
         setState('stopped')
       } else {
-        setOutput('Network error')
+        setOutput(prev => prev || 'Network error')
         setState('error')
       }
     } finally {
@@ -227,7 +283,7 @@ export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActions
             </div>
           </div>
 
-          <pre style={{
+          <pre ref={outputRef} style={{
             padding: '12px 14px', margin: 0,
             fontSize: 11, lineHeight: 1.5,
             fontFamily: 'var(--font-mono)',
@@ -235,7 +291,7 @@ export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActions
             maxHeight: 400, overflow: 'auto',
             whiteSpace: 'pre-wrap', wordBreak: 'break-word',
           }}>
-            {output ?? 'Waiting for output...'}
+            {output || (state === 'running' ? 'Starting...' : 'No output')}
           </pre>
         </div>
       )}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixevo",
-  "version": "0.2.24",
+  "version": "0.2.25",
   "description": "Self-evolving skill ecosystem for AI agents. Skills and projects co-evolve through multi-judge evaluation and a Pareto frontier.",
   "type": "module",
   "bin": {