helixevo 0.2.14 → 0.2.16

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/dist/postinstall.js

@@ -1,18 +1,34 @@
 #!/usr/bin/env node
 
 // src/postinstall.ts
-import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-var require2 = createRequire(import.meta.url);
-var pkg = require2(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"));
+var __dirname = "/Users/tianchichen/Documents/GitHub/helixevo/src";
+var version = "unknown";
+try {
+  const candidates = [
+    join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"),
+    join(process.cwd(), "package.json"),
+    join(__dirname, "..", "package.json")
+  ];
+  for (const p of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(p, "utf-8"));
+      if (pkg.name === "helixevo" && pkg.version) {
+        version = pkg.version;
+        break;
+      }
+    } catch {}
+  }
+} catch {}
 var green = "\x1B[32m";
 var cyan = "\x1B[36m";
 var bold = "\x1B[1m";
 var dim = "\x1B[2m";
 var reset = "\x1B[0m";
 console.log();
-console.log(`  ${green}✓${reset} ${bold}HelixEvo v${pkg.version}${reset} installed successfully`);
+console.log(`  ${green}✓${reset} ${bold}HelixEvo v${version}${reset} installed successfully`);
 console.log();
 console.log(`  ${dim}Get started:${reset}`);
 console.log(`    ${cyan}helixevo init${reset}        Import skills + generate skill tests`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixevo",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Self-evolving skill ecosystem for AI agents. Skills and projects co-evolve through multi-judge evaluation and a Pareto frontier.",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "typecheck": "tsc --noEmit",
     "prepare": "npm run build",
     "prepublishOnly": "npm run typecheck && npm run build",
-    "postinstall": "node dist/postinstall.js 2>/dev/null || true"
+    "postinstall": "node dist/postinstall.js || true"
   },
   "dependencies": {
     "commander": "^13.1.0",