Add real battle visualization and cypherpunk-neue UI to admin console

Features added:
- Real process management for nodes (spawn actual bitcell-node processes)
- Actual CA battle testing with real simulation (not mocked)
- Battle visualization API with downsampled grid frames
- Interactive battle playback with play/pause and frame scrubbing
- Beautiful cypherpunk-neue aesthetic with:
  - Neon green (#00ffaa) color scheme
  - Scanline effects and grid backgrounds
  - Glowing text and borders with pulsing animations
  - Monospace fonts (Share Tech Mono, Orbitron)
  - Matrix-inspired dark theme

Technical improvements:
- Made Battle::measure_regional_energy public
- Added Battle::grid_states() for capturing frames at intervals
- Added Grid::downsample() for efficient visualization
- Real-time CA simulation using tokio::spawn_blocking
- Canvas-based rendering with color-coded regions
- Unix signal handling for graceful node shutdown

All 158 tests passing.

Author: claude

crates/bitcell-admin/Cargo.toml

@@ -34,11 +34,19 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 # Time
 chrono = { version = "0.4", features = ["serde"] }
 
+# Sync primitives
+parking_lot = "0.12"
+
 # BitCell dependencies
 bitcell-node = { path = "../bitcell-node" }
 bitcell-consensus = { path = "../bitcell-consensus" }
 bitcell-state = { path = "../bitcell-state" }
 bitcell-network = { path = "../bitcell-network" }
 bitcell-crypto = { path = "../bitcell-crypto" }
+bitcell-ca = { path = "../bitcell-ca" }
+
+# Unix process management
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
 
 [dev-dependencies]

crates/bitcell-admin/src/api/nodes.rs

@@ -36,7 +36,7 @@ pub struct StartNodeRequest {
 pub async fn list_nodes(
     State(state): State<Arc<AppState>>,
 ) -> Result<Json<NodesResponse>, (StatusCode, Json<ErrorResponse>)> {
-    let nodes = state.api.list_nodes();
+    let nodes = state.process.list_nodes();
     let total = nodes.len();
 
     Ok(Json(NodesResponse { nodes, total }))
@@ -47,7 +47,7 @@ pub async fn get_node(
     State(state): State<Arc<AppState>>,
     Path(id): Path<String>,
 ) -> Result<Json<NodeResponse>, (StatusCode, Json<ErrorResponse>)> {
-    match state.api.get_node(&id) {
+    match state.process.get_node(&id) {
         Some(node) => Ok(Json(NodeResponse { node })),
         None => Err((
             StatusCode::NOT_FOUND,
@@ -64,29 +64,15 @@ pub async fn start_node(
     Path(id): Path<String>,
     Json(_req): Json<StartNodeRequest>,
 ) -> Result<Json<NodeResponse>, (StatusCode, Json<ErrorResponse>)> {
-    // Update status to starting
-    if !state.api.update_node_status(&id, NodeStatus::Starting) {
-        return Err((
-            StatusCode::NOT_FOUND,
-            Json(ErrorResponse {
-                error: format!("Node '{}' not found", id),
-            }),
-        ));
-    }
-
-    // TODO: Actually start the node process
-    // For now, simulate starting
-    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
-
-    // Update to running
-    state.api.update_node_status(&id, NodeStatus::Running);
-
-    match state.api.get_node(&id) {
-        Some(node) => Ok(Json(NodeResponse { node })),
-        None => Err((
+    match state.process.start_node(&id) {
+        Ok(node) => {
+            tracing::info!("Started node '{}' successfully", id);
+            Ok(Json(NodeResponse { node }))
+        }
+        Err(e) => Err((
             StatusCode::INTERNAL_SERVER_ERROR,
             Json(ErrorResponse {
-                error: "Failed to retrieve node after starting".to_string(),
+                error: format!("Failed to start node '{}': {}", id, e),
             }),
         )),
     }
@@ -97,29 +83,15 @@ pub async fn stop_node(
     State(state): State<Arc<AppState>>,
     Path(id): Path<String>,
 ) -> Result<Json<NodeResponse>, (StatusCode, Json<ErrorResponse>)> {
-    // Update status to stopping
-    if !state.api.update_node_status(&id, NodeStatus::Stopping) {
-        return Err((
-            StatusCode::NOT_FOUND,
-            Json(ErrorResponse {
-                error: format!("Node '{}' not found", id),
-            }),
-        ));
-    }
-
-    // TODO: Actually stop the node process
-    // For now, simulate stopping
-    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
-
-    // Update to stopped
-    state.api.update_node_status(&id, NodeStatus::Stopped);
-
-    match state.api.get_node(&id) {
-        Some(node) => Ok(Json(NodeResponse { node })),
-        None => Err((
+    match state.process.stop_node(&id) {
+        Ok(node) => {
+            tracing::info!("Stopped node '{}' successfully", id);
+            Ok(Json(NodeResponse { node }))
+        }
+        Err(e) => Err((
             StatusCode::INTERNAL_SERVER_ERROR,
             Json(ErrorResponse {
-                error: "Failed to retrieve node after stopping".to_string(),
+                error: format!("Failed to stop node '{}': {}", id, e),
             }),
         )),
     }

crates/bitcell-admin/src/api/test.rs

@@ -10,6 +10,9 @@ use std::sync::Arc;
 
 use crate::AppState;
 
+// Import BitCell types
+use bitcell_ca::{Battle, Glider, GliderPattern, Position, BattleOutcome};
+
 #[derive(Debug, Deserialize)]
 pub struct RunBattleTestRequest {
     pub glider_a: String,
@@ -27,6 +30,33 @@ pub struct BattleTestResponse {
     pub duration_ms: u64,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct BattleVisualizationRequest {
+    pub glider_a: String,
+    pub glider_b: String,
+    pub steps: Option<usize>,
+    pub frame_count: Option<usize>,
+    pub downsample_size: Option<usize>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct BattleVisualizationResponse {
+    pub test_id: String,
+    pub winner: String,
+    pub steps: usize,
+    pub final_energy_a: u64,
+    pub final_energy_b: u64,
+    pub frames: Vec<BattleFrame>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct BattleFrame {
+    pub step: usize,
+    pub grid: Vec<Vec<u8>>,
+    pub energy_a: u64,
+    pub energy_b: u64,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct SendTestTransactionRequest {
     pub from: Option<String>,
@@ -41,23 +71,85 @@ pub struct TransactionTestResponse {
     pub message: String,
 }
 
+fn parse_glider_pattern(name: &str) -> Result<GliderPattern, String> {
+    match name.to_lowercase().as_str() {
+        "standard" => Ok(GliderPattern::Standard),
+        "lightweight" | "lwss" => Ok(GliderPattern::Lightweight),
+        "middleweight" | "mwss" => Ok(GliderPattern::Middleweight),
+        "heavyweight" | "hwss" => Ok(GliderPattern::Heavyweight),
+        _ => Err(format!("Unknown glider pattern: {}", name)),
+    }
+}
+
 /// Run a battle test
 pub async fn run_battle_test(
     State(_state): State<Arc<AppState>>,
     Json(req): Json<RunBattleTestRequest>,
 ) -> Result<Json<BattleTestResponse>, (StatusCode, Json<String>)> {
-    // TODO: Actually run battle simulation
-    // For now, return mock response
-
     let test_id = format!("test-{}", chrono::Utc::now().timestamp());
 
+    tracing::info!("Running battle test: {} vs {}", req.glider_a, req.glider_b);
+
+    // Parse glider patterns
+    let pattern_a = parse_glider_pattern(&req.glider_a)
+        .map_err(|e| (StatusCode::BAD_REQUEST, Json(e)))?;
+
+    let pattern_b = parse_glider_pattern(&req.glider_b)
+        .map_err(|e| (StatusCode::BAD_REQUEST, Json(e)))?;
+
+    // Create gliders
+    let glider_a = Glider::new(pattern_a, Position::new(256, 512));
+    let glider_b = Glider::new(pattern_b, Position::new(768, 512));
+
+    // Create battle
+    let steps = req.steps.unwrap_or(1000);
+    let battle = if steps != 1000 {
+        Battle::with_steps(glider_a, glider_b, steps)
+    } else {
+        Battle::new(glider_a, glider_b)
+    };
+
+    // Run battle simulation
+    let start = std::time::Instant::now();
+
+    let (outcome, energy_a, energy_b) = tokio::task::spawn_blocking(move || {
+        // Simulate the battle
+        let outcome = battle.simulate()
+            .map_err(|e| format!("Battle simulation error: {:?}", e))?;
+
+        // Get final grid to measure energies
+        let final_grid = battle.final_grid();
+        let (energy_a, energy_b) = battle.measure_regional_energy(&final_grid);
+
+        Ok::<_, String>((outcome, energy_a, energy_b))
+    })
+    .await
+    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, Json(format!("Task join error: {}", e))))?
+    .map_err(|e: String| (StatusCode::INTERNAL_SERVER_ERROR, Json(e)))?;
+
+    let duration = start.elapsed();
+
+    let winner = match outcome {
+        BattleOutcome::AWins => "glider_a".to_string(),
+        BattleOutcome::BWins => "glider_b".to_string(),
+        BattleOutcome::Tie => "tie".to_string(),
+    };
+
+    tracing::info!(
+        "Battle test completed: winner={}, energy_a={}, energy_b={}, duration={}ms",
+        winner,
+        energy_a,
+        energy_b,
+        duration.as_millis()
+    );
+
     let response = BattleTestResponse {
         test_id,
-        winner: "glider_a".to_string(),
-        steps: req.steps.unwrap_or(1000),
-        final_energy_a: 8500,
-        final_energy_b: 7200,
-        duration_ms: 235,
+        winner,
+        steps,
+        final_energy_a: energy_a,
+        final_energy_b: energy_b,
+        duration_ms: duration.as_millis() as u64,
     };
 
     Ok(Json(response))
@@ -68,19 +160,118 @@ pub async fn send_test_transaction(
     State(_state): State<Arc<AppState>>,
     Json(req): Json<SendTestTransactionRequest>,
 ) -> Result<Json<TransactionTestResponse>, (StatusCode, Json<String>)> {
-    // TODO: Actually send transaction
-    // For now, return mock response
+    // TODO: Actually send transaction to a running node
+    // For now, return a formatted response
 
     let tx_hash = format!("0x{:x}", chrono::Utc::now().timestamp());
 
     let response = TransactionTestResponse {
         tx_hash,
         status: "pending".to_string(),
-        message: format!("Test transaction sent: {} -> {}",
+        message: format!(
+            "Test transaction sent: {} -> {} ({} units)",
             req.from.unwrap_or_else(|| "genesis".to_string()),
-            req.to
+            req.to,
+            req.amount
         ),
     };
 
+    tracing::info!("Test transaction: {}", response.message);
+
+    Ok(Json(response))
+}
+
+/// Run a battle with visualization frames
+pub async fn run_battle_visualization(
+    State(_state): State<Arc<AppState>>,
+    Json(req): Json<BattleVisualizationRequest>,
+) -> Result<Json<BattleVisualizationResponse>, (StatusCode, Json<String>)> {
+    let test_id = format!("viz-{}", chrono::Utc::now().timestamp());
+
+    tracing::info!("Running battle visualization: {} vs {}", req.glider_a, req.glider_b);
+
+    // Parse glider patterns
+    let pattern_a = parse_glider_pattern(&req.glider_a)
+        .map_err(|e| (StatusCode::BAD_REQUEST, Json(e)))?;
+
+    let pattern_b = parse_glider_pattern(&req.glider_b)
+        .map_err(|e| (StatusCode::BAD_REQUEST, Json(e)))?;
+
+    // Create gliders
+    let glider_a = Glider::new(pattern_a, Position::new(256, 512));
+    let glider_b = Glider::new(pattern_b, Position::new(768, 512));
+
+    // Create battle
+    let steps = req.steps.unwrap_or(1000);
+    let frame_count = req.frame_count.unwrap_or(20).min(100); // Max 100 frames
+    let downsample_size = req.downsample_size.unwrap_or(128).min(512); // Max 512x512
+
+    let battle = if steps != 1000 {
+        Battle::with_steps(glider_a, glider_b, steps)
+    } else {
+        Battle::new(glider_a, glider_b)
+    };
+
+    // Calculate which steps to capture
+    let sample_interval = steps / frame_count;
+    let mut sample_steps: Vec<usize> = (0..frame_count)
+        .map(|i| i * sample_interval)
+        .collect();
+    sample_steps.push(steps); // Always include final step
+
+    // Run simulation and capture frames
+    let (outcome, frames) = tokio::task::spawn_blocking(move || {
+        // Get outcome
+        let outcome = battle.simulate()
+            .map_err(|e| format!("Battle simulation error: {:?}", e))?;
+
+        // Get grid states at sample steps
+        let grids = battle.grid_states(&sample_steps);
+
+        // Create frames with downsampled grids and energy measurements
+        let mut frames = Vec::new();
+        for (i, grid) in grids.iter().enumerate() {
+            let step = sample_steps[i];
+            let (energy_a, energy_b) = battle.measure_regional_energy(grid);
+            let downsampled = grid.downsample(downsample_size);
+
+            frames.push(BattleFrame {
+                step,
+                grid: downsampled,
+                energy_a,
+                energy_b,
+            });
+        }
+
+        Ok::<_, String>((outcome, frames))
+    })
+    .await
+    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, Json(format!("Task join error: {}", e))))?
+    .map_err(|e: String| (StatusCode::INTERNAL_SERVER_ERROR, Json(e)))?;
+
+    let winner = match outcome {
+        BattleOutcome::AWins => "glider_a".to_string(),
+        BattleOutcome::BWins => "glider_b".to_string(),
+        BattleOutcome::Tie => "tie".to_string(),
+    };
+
+    let final_energy_a = frames.last().map(|f| f.energy_a).unwrap_or(0);
+    let final_energy_b = frames.last().map(|f| f.energy_b).unwrap_or(0);
+
+    tracing::info!(
+        "Battle visualization completed: winner={}, {} frames captured",
+        winner,
+        frames.len()
+    );
+
+    let response = BattleVisualizationResponse {
+        test_id,
+        winner,
+        steps,
+        final_energy_a,
+        final_energy_b,
+        frames,
+    };
+
     Ok(Json(response))
 }