helixevo 0.2.15 → 0.2.17

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

@@ -1,55 +1,126 @@
 import { NextResponse } from 'next/server'
-import { execSync } from 'child_process'
+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; timeout: number }> = {
-  'status':         { cmd: 'helixevo status',                    timeout: 15000 },
-  'health':         { cmd: 'helixevo health --verbose',          timeout: 120000 },
-  'metrics':        { cmd: 'helixevo metrics --verbose',         timeout: 15000 },
-  'evolve':         { cmd: 'helixevo evolve --verbose',          timeout: 300000 },
-  'evolve-dry':     { cmd: 'helixevo evolve --dry-run --verbose', timeout: 300000 },
-  'generalize':     { cmd: 'helixevo generalize --verbose',      timeout: 300000 },
-  'generalize-dry': { cmd: 'helixevo generalize --dry-run --verbose', timeout: 300000 },
-  'graph-rebuild':  { cmd: 'helixevo graph --rebuild --verbose', timeout: 300000 },
-  'graph-optimize': { cmd: 'helixevo graph --optimize --verbose', timeout: 300000 },
-  'research':       { cmd: 'helixevo research --verbose',        timeout: 300000 },
-  'research-dry':   { cmd: 'helixevo research --dry-run --verbose', timeout: 300000 },
-  'report':         { cmd: 'helixevo report --days 7',           timeout: 30000 },
+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 },
+  'metrics':        { cmd: 'helixevo', args: ['metrics', '--verbose'],             timeout: 15000 },
+  'evolve':         { cmd: 'helixevo', args: ['evolve', '--verbose'],              timeout: 300000 },
+  'evolve-dry':     { cmd: 'helixevo', args: ['evolve', '--dry-run', '--verbose'], timeout: 300000 },
+  'generalize':     { cmd: 'helixevo', args: ['generalize', '--verbose'],          timeout: 300000 },
+  'generalize-dry': { cmd: 'helixevo', args: ['generalize', '--dry-run', '--verbose'], timeout: 300000 },
+  'graph-rebuild':  { cmd: 'helixevo', args: ['graph', '--rebuild', '--verbose'],  timeout: 300000 },
+  'graph-optimize': { cmd: 'helixevo', args: ['graph', '--optimize', '--verbose'], timeout: 300000 },
+  'research':       { cmd: 'helixevo', args: ['research', '--verbose'],            timeout: 300000 },
+  'research-dry':   { cmd: 'helixevo', args: ['research', '--dry-run', '--verbose'], timeout: 300000 },
+  '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
+
 export async function POST(request: Request) {
-  try {
-    const body = await request.json()
-    const { command } = body as { command: string }
+  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 })
-    }
+  const entry = ALLOWED_COMMANDS[command]
+  if (!entry) {
+    return NextResponse.json({
+      success: false,
+      error: `Unknown command: ${command}`,
+    }, { status: 400 })
+  }
+
+  // Kill any existing process before starting a new one
+  if (activeProcess && !activeProcess.killed) {
+    activeProcess.kill('SIGTERM')
+    activeProcess = null
+    activeCommand = null
+  }
 
-    const output = execSync(`${entry.cmd} 2>&1`, {
-      encoding: 'utf-8',
-      timeout: entry.timeout,
+  return new Promise<Response>((resolve) => {
+    let output = ''
+    let timedOut = false
+
+    const child = spawn(entry.cmd, entry.args, {
       env: { ...process.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
     })
 
-    return NextResponse.json({
-      success: true,
-      command: entry.cmd,
-      output,
+    activeProcess = child
+    activeCommand = command
+
+    const timeout = setTimeout(() => {
+      timedOut = true
+      child.kill('SIGTERM')
+    }, entry.timeout)
+
+    child.stdout?.on('data', (data: Buffer) => {
+      output += data.toString()
     })
-  } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err)
-    // execSync errors include stdout in the message
-    const stdout = (err as { stdout?: string })?.stdout ?? ''
-    return NextResponse.json({
-      success: false,
-      output: stdout || message.slice(-2000),
-    }, { status: 500 })
+
+    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 }))
+      }
+    })
+
+    child.on('error', (err) => {
+      clearTimeout(timeout)
+      activeProcess = null
+      activeCommand = null
+      resolve(NextResponse.json({
+        success: false,
+        output: err.message,
+      }, { status: 500 }))
+    })
+  })
+}
+
+// DELETE = stop the running command
+export async function DELETE() {
+  if (activeProcess && !activeProcess.killed) {
+    const cmd = activeCommand
+    activeProcess.kill('SIGTERM')
+    activeProcess = null
+    activeCommand = null
+    return NextResponse.json({ stopped: true, command: cmd })
   }
+  return NextResponse.json({ stopped: false, message: 'No running command' })
+}
+
+// GET = check if something is running
+export async function GET() {
+  return NextResponse.json({
+    running: activeProcess !== null && !activeProcess.killed,
+    command: activeCommand,
+  })
 }

package/dashboard/components/quick-actions.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useState } from 'react'
+import { useState, useRef } from 'react'
 
 interface Action {
   id: string
@@ -17,12 +17,13 @@ interface QuickActionsProps {
   actions: Action[]
 }
 
-type RunState = 'idle' | 'running' | 'success' | 'error'
+type RunState = 'idle' | 'running' | 'success' | 'error' | 'stopped'
 
 export function QuickActions({ actions }: QuickActionsProps) {
   const [running, setRunning] = useState<string | null>(null)
   const [state, setState] = useState<RunState>('idle')
   const [output, setOutput] = useState<string | null>(null)
+  const abortRef = useRef<AbortController | null>(null)
 
   const handleRun = async (action: Action) => {
     if (action.disabled) return
@@ -30,19 +31,48 @@ export function QuickActions({ actions }: QuickActionsProps) {
     setState('running')
     setOutput(null)
 
+    const controller = new AbortController()
+    abortRef.current = controller
+
     try {
       const res = await fetch('/api/run', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ command: action.command }),
+        signal: controller.signal,
       })
       const data = await res.json()
-      setOutput(data.output ?? data.error ?? 'No output')
-      setState(data.success ? 'success' : 'error')
-    } catch {
-      setOutput('Network error')
-      setState('error')
+      if (data.stopped) {
+        setOutput(data.output ?? 'Stopped')
+        setState('stopped')
+      } else {
+        setOutput(data.output ?? data.error ?? 'No output')
+        setState(data.success ? 'success' : 'error')
+      }
+    } catch (err: unknown) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        // Client-side abort — also kill server-side process
+        try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
+        setOutput('Stopped by user')
+        setState('stopped')
+      } else {
+        setOutput('Network error')
+        setState('error')
+      }
+    } finally {
+      abortRef.current = null
+    }
+  }
+
+  const handleStop = async () => {
+    // Abort the fetch request
+    if (abortRef.current) {
+      abortRef.current.abort()
     }
+    // Also kill server-side process
+    try {
+      await fetch('/api/run', { method: 'DELETE' })
+    } catch {}
   }
 
   const handleClose = () => {
@@ -51,6 +81,21 @@ export function QuickActions({ actions }: QuickActionsProps) {
     setOutput(null)
   }
 
+  const stateColor = state === 'success' ? 'var(--green)'
+    : state === 'error' ? 'var(--red)'
+    : state === 'stopped' ? 'var(--yellow)'
+    : 'var(--text-secondary)'
+
+  const stateBorderColor = state === 'success' ? 'var(--green-border)'
+    : state === 'error' ? 'var(--red-border)'
+    : state === 'stopped' ? 'var(--yellow-border)'
+    : 'var(--border)'
+
+  const stateBgColor = state === 'success' ? 'var(--green-light)'
+    : state === 'error' ? 'var(--red-light)'
+    : state === 'stopped' ? 'var(--yellow-light)'
+    : 'var(--bg-section)'
+
   return (
     <>
       <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
@@ -93,12 +138,12 @@ export function QuickActions({ actions }: QuickActionsProps) {
         ))}
       </div>
 
-      {/* Output modal */}
+      {/* Output panel */}
       {running && state !== 'idle' && (
         <div style={{
           marginTop: 12,
           background: 'var(--bg-card)',
-          border: `1px solid ${state === 'success' ? 'var(--green-border)' : state === 'error' ? 'var(--red-border)' : 'var(--border)'}`,
+          border: `1px solid ${stateBorderColor}`,
           borderRadius: 'var(--radius-lg)',
           overflow: 'hidden',
         }}>
@@ -106,9 +151,7 @@ export function QuickActions({ actions }: QuickActionsProps) {
           <div style={{
             display: 'flex', justifyContent: 'space-between', alignItems: 'center',
             padding: '10px 14px',
-            background: state === 'running' ? 'var(--bg-section)'
-              : state === 'success' ? 'var(--green-light)'
-              : 'var(--red-light)',
+            background: stateBgColor,
             borderBottom: '1px solid var(--border)',
           }}>
             <div style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 12, fontWeight: 600 }}>
@@ -121,32 +164,46 @@ export function QuickActions({ actions }: QuickActionsProps) {
               )}
               {state === 'success' && <span style={{ color: 'var(--green)' }}>&#10003;</span>}
               {state === 'error' && <span style={{ color: 'var(--red)' }}>&#10007;</span>}
-              <span style={{
-                color: state === 'success' ? 'var(--green)' : state === 'error' ? 'var(--red)' : 'var(--text-secondary)',
-              }}>
+              {state === 'stopped' && <span style={{ color: 'var(--yellow)' }}>&#9632;</span>}
+              <span style={{ color: stateColor }}>
                 {state === 'running' ? `Running ${actions.find(a => a.id === running)?.label}...`
                   : state === 'success' ? 'Completed'
+                  : state === 'stopped' ? 'Stopped'
                   : 'Failed'}
               </span>
             </div>
-            {state !== 'running' && (
-              <div style={{ display: 'flex', gap: 6 }}>
-                <button onClick={() => { window.location.reload() }} style={{
-                  background: 'none', border: '1px solid var(--border)', borderRadius: 'var(--radius)',
-                  padding: '3px 10px', fontSize: 11, fontWeight: 600, cursor: 'pointer',
-                  color: 'var(--text-secondary)',
-                }}>
-                  Refresh
-                </button>
-                <button onClick={handleClose} style={{
-                  background: 'none', border: '1px solid var(--border)', borderRadius: 'var(--radius)',
-                  padding: '3px 10px', fontSize: 11, fontWeight: 600, cursor: 'pointer',
-                  color: 'var(--text-secondary)',
+            <div style={{ display: 'flex', gap: 6 }}>
+              {state === 'running' && (
+                <button onClick={handleStop} style={{
+                  background: 'var(--red)', color: '#fff', border: 'none', borderRadius: 'var(--radius)',
+                  padding: '3px 12px', fontSize: 11, fontWeight: 600, cursor: 'pointer',
+                  display: 'flex', alignItems: 'center', gap: 4,
                 }}>
-                  Close
+                  <svg width="10" height="10" viewBox="0 0 24 24" fill="currentColor" stroke="none">
+                    <rect x="4" y="4" width="16" height="16" rx="2" />
+                  </svg>
+                  Stop
                 </button>
-              </div>
-            )}
+              )}
+              {state !== 'running' && (
+                <>
+                  <button onClick={() => { window.location.reload() }} style={{
+                    background: 'none', border: '1px solid var(--border)', borderRadius: 'var(--radius)',
+                    padding: '3px 10px', fontSize: 11, fontWeight: 600, cursor: 'pointer',
+                    color: 'var(--text-secondary)',
+                  }}>
+                    Refresh
+                  </button>
+                  <button onClick={handleClose} style={{
+                    background: 'none', border: '1px solid var(--border)', borderRadius: 'var(--radius)',
+                    padding: '3px 10px', fontSize: 11, fontWeight: 600, cursor: 'pointer',
+                    color: 'var(--text-secondary)',
+                  }}>
+                    Close
+                  </button>
+                </>
+              )}
+            </div>
           </div>
 
           {/* Output */}

package/dashboard/components/update-banner.tsx

@@ -56,23 +56,47 @@ export function UpdateBanner({ currentVersion }: { currentVersion: string }) {
       if (data.success) {
         setState('success')
         setNewVersion(data.version)
-        // Trigger dashboard restart — the CLI will auto-relaunch
+
+        // Step 1: Tell server to restart (exits with code 75)
         setTimeout(async () => {
           try {
             await fetch('/api/restart', { method: 'POST' })
           } catch {}
-          // Poll until the new server is ready, then reload
-          const poll = setInterval(async () => {
+
+          // Step 2: Wait for old server to go DOWN (fetch should fail)
+          let serverDown = false
+          for (let i = 0; i < 20; i++) {
+            await new Promise(r => setTimeout(r, 1000))
+            try {
+              await fetch('/api/restart', { method: 'GET', signal: AbortSignal.timeout(1000) })
+              // Still up — keep waiting
+            } catch {
+              serverDown = true
+              break
+            }
+          }
+
+          // Step 3: Wait for new server to come UP
+          if (serverDown) {
+            await new Promise(r => setTimeout(r, 2000)) // give it time to start
+          }
+          for (let i = 0; i < 40; i++) {
+            await new Promise(r => setTimeout(r, 1500))
             try {
-              const res = await fetch('/', { cache: 'no-store' })
+              const res = await fetch('/?_t=' + Date.now(), {
+                cache: 'no-store',
+                signal: AbortSignal.timeout(2000),
+              })
               if (res.ok) {
-                clearInterval(poll)
-                window.location.reload()
+                // Step 4: Hard reload with cache busting
+                window.location.href = window.location.pathname + '?updated=' + Date.now()
+                return
               }
             } catch {}
-          }, 1500)
-          // Stop polling after 60s
-          setTimeout(() => clearInterval(poll), 60000)
+          }
+
+          // Fallback: force reload anyway
+          window.location.href = window.location.pathname + '?updated=' + Date.now()
         }, 1500)
       } else {
         setState('error')

package/dist/cli.js

@@ -12405,15 +12405,22 @@ function launchDashboard(dir, openBrowser) {
       console.log(`
   \uD83D\uDD04 Restarting dashboard after update...
 `);
-      const newDir = prepareDashboard() ?? dir;
-      ensureSkillGraph();
-      let updatedVersion = currentVersion;
-      try {
-        updatedVersion = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || currentVersion;
-      } catch {}
-      console.log(`  \uD83C\uDF10 HelixEvo Dashboard v${updatedVersion} at http://localhost:3847
+      setTimeout(() => {
+        const nextCache = join15(dir, ".next");
+        if (existsSync10(nextCache)) {
+          try {
+            rmSync2(nextCache, { recursive: true });
+          } catch {}
+        }
+        ensureSkillGraph();
+        let updatedVersion = currentVersion;
+        try {
+          updatedVersion = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || currentVersion;
+        } catch {}
+        console.log(`  \uD83C\uDF10 HelixEvo Dashboard v${updatedVersion} at http://localhost:3847
 `);
-      launchDashboard(newDir, false);
+        launchDashboard(dir, false);
+      }, 2000);
     } else {
       process.exit(code ?? 0);
     }

package/package.json

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