format only changes -- ran cargo fmt for PR 418 files

Author: evomimic

host/conductora/plugins/tauri-plugin-holochain/holochain_runtime/src/launch.rs

@@ -30,10 +30,7 @@ pub(crate) async fn launch_holochain_runtime(
 ) -> crate::error::Result<HolochainRuntime> {
     let t_total = std::time::Instant::now();
     tracing::info!("[LAUNCH] Starting holochain runtime (dev_mode={})", config.dev_mode);
-    if rustls::crypto::aws_lc_rs::default_provider()
-        .install_default()
-        .is_err()
-    {
+    if rustls::crypto::aws_lc_rs::default_provider().install_default().is_err() {
         tracing::error!("could not set crypto provider for tls");
     }
 
@@ -50,7 +47,9 @@ pub(crate) async fn launch_holochain_runtime(
         // Dev mode: skip the WAN signal check entirely (avoids 1-5s TCP handshake/timeout).
         // Spin up an instant loopback signal server instead — the conductor needs *some*
         // signal URL in its network config, but it never actually needs to reach the internet.
-        tracing::info!("[LAUNCH] DEV MODE: skipping WAN signal check, starting local loopback signal server");
+        tracing::info!(
+            "[LAUNCH] DEV MODE: skipping WAN signal check, starting local loopback signal server"
+        );
         let loopback = std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST);
         let port = portpicker::pick_unused_port().expect("No ports free");
         let signal_handle = run_local_signal_service(loopback.to_string(), port).await?;
@@ -104,10 +103,7 @@ pub(crate) async fn launch_holochain_runtime(
         clean_dev_conductor_state(&dev_dir);
 
         // DangerTestKeystore is set in the config; no lair process needed.
-        Conductor::builder()
-            .config(conductor_config)
-            .build()
-            .await?
+        Conductor::builder().config(conductor_config).build().await?
     } else {
         tracing::info!("[LAUNCH] Spawning lair keystore (in-proc)...");
         let t0 = std::time::Instant::now();
@@ -117,20 +113,13 @@ pub(crate) async fn launch_holochain_runtime(
                 .map_err(|err| crate::Error::LairError(err))?;
         tracing::info!("[LAUNCH] Lair keystore ready in {:.1}s", t0.elapsed().as_secs_f64());
 
-        let seed_already_exists = keystore
-            .lair_client()
-            .get_entry(DEVICE_SEED_LAIR_KEYSTORE_TAG.into())
-            .await
-            .is_ok();
+        let seed_already_exists =
+            keystore.lair_client().get_entry(DEVICE_SEED_LAIR_KEYSTORE_TAG.into()).await.is_ok();
 
         if !seed_already_exists {
             keystore
                 .lair_client()
-                .new_seed(
-                    DEVICE_SEED_LAIR_KEYSTORE_TAG.into(),
-                    None,
-                    true,
-                )
+                .new_seed(DEVICE_SEED_LAIR_KEYSTORE_TAG.into(), None, true)
                 .await
                 .map_err(|err| crate::Error::LairError(err))?;
         }
@@ -155,7 +144,10 @@ pub(crate) async fn launch_holochain_runtime(
 
     // *lock = Some(info.clone());
 
-    tracing::info!("[LAUNCH] Total launch_holochain_runtime: {:.1}s", t_total.elapsed().as_secs_f64());
+    tracing::info!(
+        "[LAUNCH] Total launch_holochain_runtime: {:.1}s",
+        t_total.elapsed().as_secs_f64()
+    );
     Ok(HolochainRuntime {
         filesystem,
         apps_websockets_auths: Arc::new(Mutex::new(Vec::new())),
@@ -192,8 +184,8 @@ fn get_local_ip_address() -> std::net::IpAddr {
 }
 
 fn try_connect_method() -> Result<std::net::IpAddr, Box<dyn std::error::Error>> {
-    use std::net::{UdpSocket}; //SocketAddr
-    
+    use std::net::UdpSocket; //SocketAddr
+
     let socket = UdpSocket::bind("0.0.0.0:0")?;
     socket.connect("1.1.1.1:80")?; // Cloudflare DNS
     Ok(socket.local_addr()?.ip())
@@ -288,13 +280,19 @@ fn clean_dev_conductor_state(conductor_dir: &std::path::Path) {
                                 continue; // keep
                             }
                             let p = db_entry.path();
-                            if p.is_dir() { let _ = std::fs::remove_dir_all(&p); }
-                            else { let _ = std::fs::remove_file(&p); }
+                            if p.is_dir() {
+                                let _ = std::fs::remove_dir_all(&p);
+                            } else {
+                                let _ = std::fs::remove_file(&p);
+                            }
                         }
                     }
                 } else {
-                    if path.is_dir() { let _ = std::fs::remove_dir_all(&path); }
-                    else { let _ = std::fs::remove_file(&path); }
+                    if path.is_dir() {
+                        let _ = std::fs::remove_dir_all(&path);
+                    } else {
+                        let _ = std::fs::remove_file(&path);
+                    }
                 }
             }
         }

host/conductora/plugins/tauri-plugin-holochain/holochain_runtime/src/launch/config.rs

@@ -39,9 +39,7 @@ pub fn conductor_config(
         config.danger_generate_throwaway_device_seed = true;
     } else {
         config.data_root_path = Some(fs.conductor_dir().into());
-        config.keystore = KeystoreConfig::LairServerInProc {
-            lair_root: Some(lair_root),
-        };
+        config.keystore = KeystoreConfig::LairServerInProc { lair_root: Some(lair_root) };
         config.device_seed_lair_tag = Some(DEVICE_SEED_LAIR_KEYSTORE_TAG.into());
     }
 
@@ -94,10 +92,7 @@ pub fn conductor_config(
     let allowed_origins = AllowedOrigins::Any;
 
     config.admin_interfaces = Some(vec![AdminInterfaceConfig {
-        driver: InterfaceDriver::Websocket {
-            port: admin_port,
-            allowed_origins,
-        },
+        driver: InterfaceDriver::Websocket { port: admin_port, allowed_origins },
     }]);
 
     config

host/conductora/src/logging.rs

@@ -198,4 +198,4 @@ fn push_holochain_noise_filter(parts: &mut Vec<String>) {
     for (krate, level) in HOLOCHAIN_NOISY_CRATES {
         parts.push(format!("{krate}={level}"));
     }
-}
+}

host/conductora/src/setup/providers/holochain_setup.rs

@@ -1,13 +1,13 @@
 use crate::config::providers::holochain::*;
 use crate::config::StorageProvider;
 use crate::setup::common_setup::{create_snapshot_store, serialize_props};
-use std::sync::{Arc, Mutex};
 use crate::setup::receptor_config_registry::ReceptorConfigRegistry;
 use crate::setup::window_setup::ProviderWindowSetup;
 use async_trait::async_trait;
 use holochain_client::{AdminWebsocket, AppInfo, AppWebsocket};
 use holochain_receptor::HolochainConductorClient;
 use holons_client::shared_types::base_receptor::BaseReceptor;
+use std::sync::{Arc, Mutex};
 use tauri::{AppHandle, Manager, Theme};
 use tauri_plugin_holochain::AgentPubKey;
 use tauri_plugin_holochain::{AppBundle, HolochainExt};
@@ -37,11 +37,17 @@ impl HolochainSetup {
                 return Err(anyhow::anyhow!("Failed to load happ bundle: {}", e));
             }
         };
-        tracing::info!("[HOLOCHAIN SETUP] happ bundle loaded in {:.1}s", t_setup.elapsed().as_secs_f64());
+        tracing::info!(
+            "[HOLOCHAIN SETUP] happ bundle loaded in {:.1}s",
+            t_setup.elapsed().as_secs_f64()
+        );
 
         let t_admin = std::time::Instant::now();
         let admin_ws = handle.holochain()?.admin_websocket().await?;
-        tracing::info!("[HOLOCHAIN SETUP] Admin websocket obtained in {:.1}s", t_admin.elapsed().as_secs_f64());
+        tracing::info!(
+            "[HOLOCHAIN SETUP] Admin websocket obtained in {:.1}s",
+            t_admin.elapsed().as_secs_f64()
+        );
 
         let installed_apps = admin_ws
             .list_apps(None)
@@ -59,40 +65,40 @@ impl HolochainSetup {
             // Dev mode: conductor state (except wasm.db) was wiped before the
             // conductor started (see clean_dev_conductor_state in launch.rs), so
             // there is no stale app record.  Install fresh with an ephemeral key.
-            Self::handle_new_app_installation(
-                &handle,
-                &admin_ws,
-                happ,
-                app_id.clone(),
-                true,
-            )
-            .await?;
+            Self::handle_new_app_installation(&handle, &admin_ws, happ, app_id.clone(), true)
+                .await?;
         } else if Self::is_app_installed(&installed_apps, app_id.clone()) {
             Self::handle_existing_app(&handle, happ, app_id.clone()).await?;
         } else {
-            Self::handle_new_app_installation(
-                &handle,
-                &admin_ws,
-                happ,
-                app_id.clone(),
-                false,
-            )
-            .await?;
+            Self::handle_new_app_installation(&handle, &admin_ws, happ, app_id.clone(), false)
+                .await?;
         }
-        tracing::info!("[HOLOCHAIN SETUP] App install/update done in {:.1}s", t_install.elapsed().as_secs_f64());
+        tracing::info!(
+            "[HOLOCHAIN SETUP] App install/update done in {:.1}s",
+            t_install.elapsed().as_secs_f64()
+        );
 
         let t_appws = std::time::Instant::now();
         let app_ws = handle.holochain()?.app_websocket(app_id.clone()).await?;
-        tracing::info!("[HOLOCHAIN SETUP] App websocket obtained in {:.1}s", t_appws.elapsed().as_secs_f64());
+        tracing::info!(
+            "[HOLOCHAIN SETUP] App websocket obtained in {:.1}s",
+            t_appws.elapsed().as_secs_f64()
+        );
 
         // After successful setup, build and register the base receptor
         let t_receptor = std::time::Instant::now();
         let receptor_cfg: BaseReceptor =
             Self::build_receptor(app_ws, admin_ws, &handle, name, hc_cfg).await?;
         Self::register_receptor(&handle, receptor_cfg).await?;
-        tracing::info!("[HOLOCHAIN SETUP] Base receptor built in {:.1}s", t_receptor.elapsed().as_secs_f64());
+        tracing::info!(
+            "[HOLOCHAIN SETUP] Base receptor built in {:.1}s",
+            t_receptor.elapsed().as_secs_f64()
+        );
 
-        tracing::info!("[HOLOCHAIN SETUP] Total setup time: {:.1}s", t_setup.elapsed().as_secs_f64());
+        tracing::info!(
+            "[HOLOCHAIN SETUP] Total setup time: {:.1}s",
+            t_setup.elapsed().as_secs_f64()
+        );
         Ok(())
     }
 

host/crates/holochain_receptor/src/holochain_conductor_client.rs

@@ -11,9 +11,9 @@ use holochain_client::{
     AdminWebsocket, AgentPubKey, AppInfo, AppWebsocket, CellInfo, ExternIO, SerializedBytes,
     ZomeCallTarget,
 };
-use holons_client::shared_types::holon_space::{HolonSpace, SpaceInfo};
 use holons_boundary::envelopes::{InternalDanceRequestEnvelope, InternalDanceResponseEnvelope};
 use holons_boundary::{DanceResponseWire, ResponseBodyWire};
+use holons_client::shared_types::holon_space::{HolonSpace, SpaceInfo};
 use holons_core::dances::ResponseStatusCode;
 use holons_trust_channel::DanceEnvelopeTransport;
 
@@ -51,7 +51,10 @@ impl HolochainConductorClient {
             Ok(Some(app_info)) => {
                 // Successfully retrieved AppInfo, now convert it.
                 let space_info = convert_to_space_info(app_info)?;
-                tracing::info!("[ReceptorService] Successfully retrieved space info: {:?}", space_info);
+                tracing::info!(
+                    "[ReceptorService] Successfully retrieved space info: {:?}",
+                    space_info
+                );
                 Ok(space_info)
             }
             Ok(None) => {

host/crates/holochain_receptor/src/holochain_receptor.rs

@@ -10,12 +10,15 @@ use crate::holochain_conductor_client::HolochainConductorClient;
 use base_types::MapString;
 use core_types::HolonError;
 use holons_client::{
-    client_context::ClientSession, dances_client::ClientDanceBuilder, init_client_context, shared_types::{
+    client_context::ClientSession,
+    dances_client::ClientDanceBuilder,
+    init_client_context,
+    shared_types::{
         base_receptor::{BaseReceptor, ReceptorBehavior},
         holon_space::{HolonSpace, SpaceInfo},
         map_request::{MapRequest, MapRequestBody},
         map_response::MapResponse,
-    }
+    },
 };
 use holons_core::core_shared_objects::transactions::TransactionContext;
 use holons_core::dances::{DanceInitiator, DanceResponse, ResponseBody, ResponseStatusCode};
@@ -60,7 +63,10 @@ impl HolochainReceptor {
         // Downcast the stored snapshot store into our concrete recovery store
         let session: ClientSession;
         if let Some(snapshot_store_any) = base.snapshot_store.as_ref() {
-            let recovery_store = snapshot_store_any.clone().downcast::<TransactionRecoveryStore>().expect("Failed to deserialize TransactionRecoveryStore");    
+            let recovery_store = snapshot_store_any
+                .clone()
+                .downcast::<TransactionRecoveryStore>()
+                .expect("Failed to deserialize TransactionRecoveryStore");
             session = init_client_context(Some(initiator), Some(recovery_store.clone()));
         } else {
             session = init_client_context(Some(initiator), None);
@@ -95,7 +101,8 @@ impl ReceptorBehavior for HolochainReceptor {
         if Self::is_commit_dance_request(request.name.as_str()) {
             let _commit_guard = self.session.context.begin_host_commit_ingress_guard()?;
             // Preserve request-shape validation before routing to context-owned commit execution.
-            let _validated_request = ClientDanceBuilder::validate_and_execute(&self.session.context, &request)?;
+            let _validated_request =
+                ClientDanceBuilder::validate_and_execute(&self.session.context, &request)?;
             let response_reference = self.session.context.commit()?;
             let dance_response = DanceResponse::new(
                 ResponseStatusCode::OK,
@@ -121,7 +128,8 @@ impl ReceptorBehavior for HolochainReceptor {
                 }
             };
 
-            let response_reference = load_holons_from_files(self.session.context.clone(), content_set).await?;
+            let response_reference =
+                load_holons_from_files(self.session.context.clone(), content_set).await?;
             tracing::info!(
                 "HolochainReceptor: loaded holons with reference: {:?}",
                 response_reference
@@ -145,15 +153,14 @@ impl ReceptorBehavior for HolochainReceptor {
         if !is_read_only {
             self.session.context.ensure_host_mutation_entry_allowed()?;
         }
-        let dance_request = ClientDanceBuilder::validate_and_execute(&self.session.context, &request)?;
-        
+        let dance_request =
+            ClientDanceBuilder::validate_and_execute(&self.session.context, &request)?;
+
         //here depending on the command we create/undo/redo a snapshot checkpoint
         //see tests below for examples
-        
-        let dance_response = self
-            .session.context
-            .initiate_ingress_dance(dance_request, is_read_only)
-            .await?;
+
+        let dance_response =
+            self.session.context.initiate_ingress_dance(dance_request, is_read_only).await?;
 
         Ok(MapResponse::new_from_dance_response(request.space.id, dance_response))
     }
@@ -180,8 +187,6 @@ impl Debug for HolochainReceptor {
 mod tests {
     use super::HolochainReceptor;
     use base_types::{BaseValue, MapString};
-    use holons_recovery::TransactionRecoveryStore;
-    use std::{path::Path, sync::Arc};
     use core_types::{PropertyMap, PropertyName};
     use holons_client::{
         dances_client::ClientDanceBuilder,
@@ -192,6 +197,8 @@ mod tests {
         },
     };
     use holons_core::dances::DanceType;
+    use holons_recovery::TransactionRecoveryStore;
+    use std::{path::Path, sync::Arc};
 
     /// Helper: open an in-memory recovery store (`:memory:` is a rusqlite built-in).
     fn in_memory_store() -> Arc<TransactionRecoveryStore> {
@@ -219,7 +226,11 @@ mod tests {
         assert!(undone.is_some(), "undo should return the snapshot that was undone");
 
         let history_after_undo = session.list_undo_history().await;
-        assert_eq!(history_after_undo.len(), 0, "undo stack should be empty after undoing the only entry");
+        assert_eq!(
+            history_after_undo.len(),
+            0,
+            "undo stack should be empty after undoing the only entry"
+        );
 
         // ── 3. Redo restores the entry ────────────────────────────────────
         let redone = session.redo().await;
@@ -235,7 +246,8 @@ mod tests {
 
         let history_after_no_undo = session.list_undo_history().await;
         assert_eq!(
-            history_after_no_undo.len(), 1,
+            history_after_no_undo.len(),
+            1,
             "disable_undo persist must not grow the undo stack"
         );
 
@@ -254,7 +266,6 @@ mod tests {
         assert!(after_cleanup.is_none(), "recover_last_snapshot should return None after cleanup");
     }
 
-
     #[test]
     fn commit_route_classification_is_exact() {
         assert!(HolochainReceptor::is_commit_dance_request("commit"));
@@ -279,7 +290,7 @@ mod tests {
 
     #[test]
     fn host_mutation_precheck_blocks_create_new_holon_before_builder_side_effects() {
-        let session = init_client_context(None,None);
+        let session = init_client_context(None, None);
         let context = session.context.clone();
         let _guard = context.begin_host_commit_ingress_guard().expect("guard should acquire");