Not Yet Done

Author: Steake

.gitignore

@@ -31,3 +31,6 @@ secrets/
 
 # Benchmarks
 criterion/
+.bitcell/
+help_output.txt
+target/

cleanup.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Quick manual cleanup - just delete the state file and you're done!
+
+echo "🧹 Clearing BitCell admin state..."
+
+# Kill existing processes
+echo "Killing existing BitCell processes..."
+pkill -f bitcell-node || true
+pkill -f bitcell-admin || true
+# Wait for ports to free up
+sleep 2
+
+# Clear admin deployment state
+rm -rf .bitcell/admin/*
+
+# Clear temp node data
+rm -rf /tmp/bitcell/*
+
+echo "✅ State cleared!"
+echo ""
+echo "Now restart admin console:"
+cargo run --release -p bitcell-admin

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

@@ -5,7 +5,7 @@ use axum::{
     http::StatusCode,
     Json,
 };
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::sync::Arc;
 
 use crate::AppState;

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

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
 use crate::AppState;
-use super::{NodeInfo, NodeStatus};
+use super::NodeInfo;
 
 #[derive(Debug, Serialize)]
 pub struct NodesResponse {

crates/bitcell-admin/src/deployment.rs

@@ -4,14 +4,16 @@ use std::sync::Arc;
 
 use crate::api::NodeType;
 use crate::process::{ProcessManager, NodeConfig};
+use crate::setup::{SetupManager, NodeEndpoint};
 
 pub struct DeploymentManager {
     process: Arc<ProcessManager>,
+    setup: Arc<SetupManager>,
 }
 
 impl DeploymentManager {
-    pub fn new(process: Arc<ProcessManager>) -> Self {
-        Self { process }
+    pub fn new(process: Arc<ProcessManager>, setup: Arc<SetupManager>) -> Self {
+        Self { process, setup }
     }
 
     pub async fn deploy_nodes(&self, deployment_id: &str, node_type: NodeType, count: usize) {
@@ -22,29 +24,91 @@ impl DeploymentManager {
             node_type
         );
 
-        let base_port = match node_type {
-            NodeType::Validator => 9000,
-            NodeType::Miner => 9100,
-            NodeType::FullNode => 9200,
+        // Find the highest used port to avoid conflicts
+        // Using higher ports (19000+) to avoid conflicts with system services
+        let mut base_port = match node_type {
+            NodeType::Validator => 19000,
+            NodeType::Miner => 19100,
+            NodeType::FullNode => 19200,
         };
+        
+        // Check existing nodes in process manager
+        let existing_nodes = self.process.list_nodes();
+        for node in &existing_nodes {
+            if node.port >= base_port {
+                // We use port (P2P) and port+1 (Metrics), so next available is port+2
+                base_port = std::cmp::max(base_port, node.port + 2);
+            }
+        }
+        
+        // Check existing nodes in setup manager
+        let setup_nodes = self.setup.get_nodes();
+        for node in &setup_nodes {
+            // Parse port from metrics endpoint if possible, or just skip
+            // This is a heuristic
+            if let Some(port_str) = node.metrics_endpoint.split(':').last() {
+                if let Some(port_part) = port_str.split('/').next() {
+                    if let Ok(metrics_port) = port_part.parse::<u16>() {
+                        // metrics_port is port + 1, so P2P port is metrics_port - 1
+                        let p2p_port = metrics_port.saturating_sub(1);
+                        if p2p_port >= base_port {
+                            base_port = std::cmp::max(base_port, p2p_port + 2);
+                        }
+                    }
+                }
+            }
+        }
 
         let base_rpc_port = base_port + 1000;
 
         for i in 0..count {
             let node_id = format!("{:?}-{}-{}", node_type, deployment_id, i);
+            // Increment by 2 to allow space for metrics port (port + 1)
+            let port = base_port + (i * 2) as u16;
+            let rpc_port = base_rpc_port + i as u16;
+            
             let config = NodeConfig {
                 node_type,
                 data_dir: format!("/tmp/bitcell/{}", node_id),
-                port: base_port + i as u16,
-                rpc_port: base_rpc_port + i as u16,
+                port,
+                rpc_port,
                 log_level: "info".to_string(),
                 network: "testnet".to_string(),
             };
 
             // Register the node (but don't start it automatically)
+            // Note: The UI calls start_node separately, or we could start it here.
+            // But wait, the UI "Deploy" button calls deploy_node, which spawns this task.
+            // The UI then refreshes the list. It doesn't automatically start them?
+            // The screenshot shows them as "Running".
+            // Let's check process.rs start_node again.
+            // Ah, register_node returns NodeStatus::Stopped.
+            // So the user must have clicked Start.
+            // But wait, if I register them in SetupManager, they appear in the list.
+            
             self.process.register_node(node_id.clone(), config);
+            
+            // Register in SetupManager so metrics can be fetched
+            let endpoint = NodeEndpoint {
+                id: node_id.clone(),
+                node_type: format!("{:?}", node_type).to_lowercase(),
+                metrics_endpoint: format!("http://127.0.0.1:{}/metrics", port + 1),
+                rpc_endpoint: format!("http://127.0.0.1:{}", rpc_port),
+            };
+            self.setup.add_node(endpoint);
 
             tracing::info!("Registered node '{}' in deployment {}", node_id, deployment_id);
+            
+            // Auto-start the node for convenience
+            if let Err(e) = self.process.start_node(&node_id) {
+                tracing::error!("Failed to auto-start node {}: {}", node_id, e);
+            }
+        }
+        
+        // Save setup state
+        let setup_path = std::path::PathBuf::from(crate::setup::SETUP_FILE_PATH);
+        if let Err(e) = self.setup.save_to_file(&setup_path) {
+            tracing::error!("Failed to save setup state: {}", e);
         }
 
         tracing::info!(

crates/bitcell-admin/src/lib.rs

@@ -47,8 +47,8 @@ impl AdminConsole {
     /// Create a new admin console
     pub fn new(addr: SocketAddr) -> Self {
         let process = Arc::new(ProcessManager::new());
-        let deployment = Arc::new(DeploymentManager::new(process.clone()));
         let setup = Arc::new(setup::SetupManager::new());
+        let deployment = Arc::new(DeploymentManager::new(process.clone(), setup.clone()));
 
         // Try to load setup state from default location
         let setup_path = std::path::PathBuf::from(SETUP_FILE_PATH);

crates/bitcell-admin/src/metrics_client.rs

@@ -31,15 +31,19 @@ impl MetricsClient {
     pub fn new() -> Self {
         Self {
             client: reqwest::Client::builder()
-                .timeout(Duration::from_secs(10))
+                .timeout(Duration::from_secs(2))
                 .build()
                 .expect("Failed to build HTTP client for metrics"),
         }
     }
 
     /// Fetch metrics from a node's Prometheus endpoint
     pub async fn fetch_node_metrics(&self, node_id: &str, endpoint: &str) -> Result<NodeMetrics, String> {
-        let url = format!("{}/metrics", endpoint);
+        let url = if endpoint.ends_with("/metrics") {
+            endpoint.to_string()
+        } else {
+            format!("{}/metrics", endpoint)
+        };
 
         let response = self.client
             .get(&url)

crates/bitcell-admin/src/process.rs

@@ -71,25 +71,32 @@ impl ProcessManager {
         // Build command to start node
         // NOTE: Uses 'cargo run' which is suitable for development only.
         // For production deployments, use a compiled binary path instead.
-        let mut cmd = Command::new("cargo");
-        cmd.arg("run")
-            .arg("-p")
-            .arg("bitcell-node")
-            .arg("--")
-            .arg(match node.config.node_type {
-                NodeType::Validator => "validator",
-                NodeType::Miner => "miner",
-                NodeType::FullNode => "full-node",
-            })
-            .arg("--port")
-            .arg(node.config.port.to_string())
-            .arg("--rpc-port")
-            .arg(node.config.rpc_port.to_string())
-            .arg("--data-dir")
-            .arg(&node.config.data_dir)
+        // Build command to start node using pre-built release binary
+        let binary_path = std::env::current_dir()
+            .unwrap()
+            .join("target/release/bitcell-node");
+        
+        let mut cmd = Command::new(binary_path);
+        
+        // Add node type and arguments
+        match node.config.node_type {
+            NodeType::Validator => {
+                cmd.arg("validator");
+            },
+            NodeType::Miner => {
+                cmd.arg("miner");
+            },
+            NodeType::FullNode => {
+                cmd.arg("full-node");
+            },
+        }
+        
+        cmd.arg("--port").arg(node.config.port.to_string())
+            .arg("--rpc-port").arg(node.config.rpc_port.to_string())
+            .arg("--data-dir").arg(&node.config.data_dir)
             .env("RUST_LOG", &node.config.log_level)
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit());
 
         tracing::info!("Starting node '{}' with command: {:?}", id, cmd);