feat: dev/prod node isolation — lockfile, --dev flag, network modes, production build flag

cli/src/ad4m.rs

@@ -73,6 +73,10 @@ struct ClapApp {
     /// Provide admin credential to gain all capabilities
     #[arg(short, long)]
     admin_credential: Option<String>,
+
+    /// Data directory to read executor-port from (default: ~/.ad4m)
+    #[arg(long)]
+    data_path: Option<String>,
 }
 
 #[derive(Debug, Subcommand)]
@@ -117,7 +121,7 @@ async fn get_ad4m_client(args: &ClapApp) -> Result<Ad4mClient> {
     let executor_url = if let Some(custom_url) = args.executor_url.clone() {
         custom_url
     } else {
-        crate::startup::get_executor_url()?
+        crate::startup::get_executor_url(args.data_path.as_deref())?
     };
 
     let cap_token = if let Some(admin_credential) = &args.admin_credential {

cli/src/ad4m_executor.rs

@@ -140,6 +140,12 @@ enum Domain {
         /// Useful for test harnesses that need targeted process cleanup.
         #[arg(long)]
         pid_file: Option<String>,
+        /// Run in development mode (data: ~/.ad4m-dev, network: devnet, log: debug)
+        #[arg(long, action)]
+        dev: bool,
+        /// Network mode: mainnet (default), devnet, or local
+        #[arg(long)]
+        network_mode: Option<String>,
     },
     RunLocalHcServices {},
 }
@@ -169,19 +175,19 @@ async fn main() -> Result<()> {
     };
 
     if let Domain::Run {
-        app_data_path,
-        network_bootstrap_seed,
+        mut app_data_path,
+        mut network_bootstrap_seed,
         language_language_only,
         run_dapp_server,
         gql_port,
         hc_admin_port,
         hc_app_port,
-        hc_use_bootstrap,
+        mut hc_use_bootstrap,
         hc_use_local_proxy,
-        hc_use_mdns,
+        mut hc_use_mdns,
         hc_use_proxy,
-        hc_proxy_url,
-        hc_bootstrap_url,
+        mut hc_proxy_url,
+        mut hc_bootstrap_url,
         hc_relay_url,
         connect_holochain,
         admin_credential,
@@ -194,8 +200,75 @@ async fn main() -> Result<()> {
         enable_mcp,
         mcp_port,
         pid_file,
+        dev,
+        network_mode,
     } = args.domain
     {
+        use rust_executor::config::NetworkMode;
+
+        // Refuse --dev in production builds
+        if rust_executor::globals::IS_PRODUCTION_BUILD && dev {
+            eprintln!("ERROR: Cannot use --dev with production builds");
+            std::process::exit(1);
+        }
+
+        // Parse network mode
+        let network_mode: NetworkMode = if let Some(ref mode_str) = network_mode {
+            mode_str.parse().unwrap_or_else(|_| {
+                eprintln!(
+                    "ERROR: Invalid network mode '{}'. Use: mainnet, devnet, local",
+                    mode_str
+                );
+                std::process::exit(1);
+            })
+        } else if dev {
+            NetworkMode::Devnet
+        } else {
+            NetworkMode::Mainnet
+        };
+
+        // Apply --dev defaults
+        if dev && app_data_path.is_none() {
+            let home = dirs::home_dir().expect("Could not get home directory");
+            app_data_path = Some(home.join(".ad4m-dev").to_string_lossy().into_owned());
+        }
+
+        // Apply network mode to config
+        match network_mode {
+            NetworkMode::Local => {
+                hc_use_mdns = Some(true);
+                hc_use_bootstrap = Some(false);
+                hc_proxy_url = Some(String::new());
+                hc_bootstrap_url = Some(String::new());
+            }
+            _ => {}
+        };
+
+        // For devnet mode, write devnet seed
+        if network_mode == NetworkMode::Devnet && network_bootstrap_seed.is_none() {
+            let data_path = app_data_path.clone().unwrap_or_else(|| {
+                let home = dirs::home_dir().expect("Could not get home directory");
+                home.join(".ad4m").to_string_lossy().into_owned()
+            });
+            std::fs::create_dir_all(&data_path).ok();
+            let seed_path = std::path::PathBuf::from(&data_path).join("devnet_seed.seed");
+            std::fs::write(&seed_path, rust_executor::globals::DEVNET_JSON)
+                .expect("Could not write devnet seed file");
+            network_bootstrap_seed = Some(seed_path.to_string_lossy().into_owned());
+        }
+
+        if dev {
+            eprintln!(
+                "⚠️  DEVELOPMENT MODE — data: {} | network: {}",
+                app_data_path.as_deref().unwrap_or("~/.ad4m-dev"),
+                network_mode
+            );
+            if std::env::var("RUST_LOG").is_err() {
+                std::env::set_var("RUST_LOG", "debug");
+            }
+        } else if !rust_executor::globals::IS_PRODUCTION_BUILD {
+            eprintln!("[dev build] Use --dev for development mode defaults");
+        }
         let tls = if tls_cert_file.is_some() && tls_key_file.is_some() {
             Some(TlsConfig {
                 cert_file_path: tls_cert_file.unwrap(),

cli/src/main.rs

@@ -34,6 +34,7 @@ use ad4m_client::*;
 use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
 use rust_executor::Ad4mConfig;
+use rust_executor::config::NetworkMode;
 use startup::executor_data_path;
 
 /// AD4M command line interface.
@@ -78,6 +79,10 @@ struct ClapApp {
     /// Provide admin credential to gain all capabilities
     #[arg(short, long)]
     admin_credential: Option<String>,
+
+    /// Data directory to read executor-port from (default: ~/.ad4m)
+    #[arg(long)]
+    data_path: Option<String>,
 }
 
 #[derive(Debug, Subcommand)]
@@ -166,6 +171,12 @@ enum Domain {
         /// Write the executor PID to this file on startup (removed on clean shutdown).
         #[arg(long)]
         pid_file: Option<String>,
+        /// Run in development mode (data: ~/.ad4m-dev, network: devnet, log: debug)
+        #[arg(long, action)]
+        dev: bool,
+        /// Network mode: mainnet (default), devnet, or local
+        #[arg(long)]
+        network_mode: Option<String>,
     },
     RunLocalHcServices {},
     Eve {
@@ -178,7 +189,7 @@ async fn get_ad4m_client(args: &ClapApp) -> Result<Ad4mClient> {
     let executor_url = if let Some(custom_url) = args.executor_url.clone() {
         custom_url
     } else {
-        crate::startup::get_executor_url()?
+        crate::startup::get_executor_url(args.data_path.as_deref())?
     };
 
     let cap_token = if let Some(admin_credential) = &args.admin_credential {
@@ -247,8 +258,70 @@ async fn main() -> Result<()> {
         enable_mcp,
         mcp_port,
         pid_file,
+        dev,
+        network_mode,
     } = args.domain
     {
+        // Validate production build constraints
+        if rust_executor::globals::IS_PRODUCTION_BUILD && dev {
+            eprintln!("ERROR: Cannot use --dev with production builds");
+            std::process::exit(1);
+        }
+
+        // Parse network mode
+        let network_mode: NetworkMode = if let Some(ref mode_str) = network_mode {
+            mode_str.parse().unwrap_or_else(|e: String| {
+                eprintln!("ERROR: {}", e);
+                std::process::exit(1);
+            })
+        } else if dev {
+            NetworkMode::Devnet
+        } else {
+            NetworkMode::Mainnet
+        };
+
+        // Apply --dev defaults
+        let app_data_path = if dev && app_data_path.is_none() {
+            let home = dirs::home_dir().expect("Could not get home directory");
+            Some(home.join(".ad4m-dev").to_string_lossy().into_owned())
+        } else {
+            app_data_path
+        };
+
+        // Apply network mode to config
+        let (hc_use_mdns, hc_use_bootstrap, hc_use_proxy, hc_proxy_url, hc_bootstrap_url) = match network_mode {
+            NetworkMode::Local => {
+                (Some(true), Some(false), Some(false), Some(String::new()), Some(String::new()))
+            }
+            _ => (hc_use_mdns, hc_use_bootstrap, hc_use_proxy, hc_proxy_url, hc_bootstrap_url),
+        };
+
+        // For devnet mode, write devnet seed instead of mainnet
+        let network_bootstrap_seed = if network_mode == NetworkMode::Devnet && network_bootstrap_seed.is_none() {
+            // Will be handled in config.prepare() — write devnet seed file
+            let data_path = app_data_path.clone().unwrap_or_else(|| {
+                let home = dirs::home_dir().expect("Could not get home directory");
+                home.join(".ad4m").to_string_lossy().into_owned()
+            });
+            std::fs::create_dir_all(&data_path).ok();
+            let seed_path = std::path::PathBuf::from(&data_path).join("devnet_seed.seed");
+            std::fs::write(&seed_path, rust_executor::globals::DEVNET_JSON)
+                .expect("Could not write devnet seed file");
+            Some(seed_path.to_string_lossy().into_owned())
+        } else {
+            network_bootstrap_seed
+        };
+
+        if dev {
+            eprintln!("⚠️  DEVELOPMENT MODE — data: {} | network: {}",
+                app_data_path.as_deref().unwrap_or("~/.ad4m-dev"),
+                network_mode);
+            // Set RUST_LOG to debug if not already set
+            if std::env::var("RUST_LOG").is_err() {
+                std::env::set_var("RUST_LOG", "debug");
+            }
+        }
+
         let _ = tokio::spawn(async move {
             rust_executor::run(Ad4mConfig {
                 app_data_path,
@@ -348,6 +421,8 @@ async fn main() -> Result<()> {
             enable_mcp: _,
             mcp_port: _,
             pid_file: _,
+            dev: _,
+            network_mode: _,
         } => unreachable!(),
         Domain::RunLocalHcServices {} => unreachable!(),
         Domain::Eve { command: _ } => unreachable!(),

cli/src/startup.rs

@@ -18,21 +18,19 @@ pub fn data_path() -> Result<PathBuf> {
 
 pub fn executor_data_path() -> PathBuf {
     let home_dir = dirs::home_dir().expect("Could not get home directory");
-
     home_dir.join(".ad4m")
 }
 
-pub fn get_executor_port() -> Result<u16> {
-    let executor_data_path = executor_data_path();
-    let file_path = executor_data_path.join("executor-port");
+pub fn get_executor_port_from_path(data_path: &std::path::Path) -> Result<u16> {
+    let file_path = data_path.join("executor-port");
     let executor_port = std::fs::read_to_string(file_path.clone()).with_context(|| {
         format!(
             "Could not get executor port file `{}`!\nIs AD4M executor running?",
             file_path.display()
         )
     });
     match executor_port {
-        Ok(port) => Ok(port.parse::<u16>().unwrap()),
+        Ok(port) => Ok(port.trim().parse::<u16>().unwrap()),
         Err(err) => {
             println!("{}", err);
             println!("Attempting to connect on default port 12000...\n");
@@ -41,8 +39,16 @@ pub fn get_executor_port() -> Result<u16> {
     }
 }
 
-pub fn get_executor_url() -> Result<String> {
-    let port = get_executor_port()?;
+pub fn get_executor_port() -> Result<u16> {
+    get_executor_port_from_path(&executor_data_path())
+}
+
+pub fn get_executor_url(data_path: Option<&str>) -> Result<String> {
+    let port = if let Some(dp) = data_path {
+        get_executor_port_from_path(std::path::Path::new(dp))?
+    } else {
+        get_executor_port()?
+    };
     Ok(format!("http://127.0.0.1:{}/graphql", port))
 }
 

rust-executor/Cargo.toml

@@ -32,6 +32,7 @@ default = []
 metal = ["kalosm/metal"]
 cuda = ["kalosm/cuda"]
 generate_snapshot = []  # Feature flag for snapshot generation mode
+production = []  # Production build: disables --dev flag, defaults to mainnet
 
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -46,6 +47,7 @@ deno_snapshots = {version = "0.19.0", git = "https://github.com/coasys/deno.git"
 sys_traits = "=0.1.9"
 # deno_runtime = {version = "0.162.0", path = "../../deno/runtime"}
 tokio = { version = "1.25.0", features = ["full"] }
+fs2 = "0.4"
 url = "2.3.1"
 urlencoding = "2.1"
 percent-encoding = "2"

rust-executor/src/config.rs

@@ -4,6 +4,40 @@ use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
+/// Network mode for the AD4M executor
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum NetworkMode {
+    Mainnet,
+    Devnet,
+    Local,
+}
+
+impl std::fmt::Display for NetworkMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            NetworkMode::Mainnet => write!(f, "mainnet"),
+            NetworkMode::Devnet => write!(f, "devnet"),
+            NetworkMode::Local => write!(f, "local"),
+        }
+    }
+}
+
+impl std::str::FromStr for NetworkMode {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "mainnet" => Ok(NetworkMode::Mainnet),
+            "devnet" => Ok(NetworkMode::Devnet),
+            "local" => Ok(NetworkMode::Local),
+            _ => Err(format!(
+                "Invalid network mode: '{}'. Must be mainnet, devnet, or local",
+                s
+            )),
+        }
+    }
+}
+
 lazy_static::lazy_static! {
     /// Global SMTP configuration for sending emails
     pub static ref SMTP_CONFIG: Arc<Mutex<Option<SmtpConfig>>> = Arc::new(Mutex::new(None));