radrootsd

JSON-RPC bridge for Radroots event publishing
git clone https://radroots.dev/git/radrootsd.git
Log | Files | Refs | README | LICENSE

runtime.rs (41579B)


      1 use crate::app::identity_storage::DaemonIdentity;
      2 use anyhow::{Context, Result, bail};
      3 use jsonrpsee::server::ServerHandle;
      4 use std::time::Duration;
      5 use tracing::{info, warn};
      6 #[cfg(not(test))]
      7 use tracing_subscriber::EnvFilter;
      8 
      9 use crate::app::identity_storage::load_service_identity;
     10 use crate::app::{cli, config, paths};
     11 use crate::core::Radrootsd;
     12 use crate::core::transport_publish::{
     13     PublishPrincipalInit, TransportPublishStore, generate_bearer_token, hash_bearer_token,
     14     parse_explicit_transport_kind, parse_nostr_source_policy, parse_target_policy,
     15     write_token_file,
     16 };
     17 use crate::host_nostr::{ApplicationHandlerSpec, Kind, build_application_handler, build_profile};
     18 use crate::transport::jsonrpc;
     19 #[cfg(not(test))]
     20 use crate::transport::nostr::listener::spawn_nip46_listener;
     21 #[cfg(not(test))]
     22 use clap::Parser;
     23 use radroots_event::profile::AuthoredProfile;
     24 use std::path::PathBuf;
     25 
     26 #[cfg(test)]
     27 type RunLoadHookValue = Result<(cli::Args, config::Settings), String>;
     28 
     29 #[cfg(test)]
     30 type RunLoadHook = std::sync::Mutex<Option<RunLoadHookValue>>;
     31 
     32 #[cfg(test)]
     33 static RUN_LOAD_HOOK: std::sync::OnceLock<RunLoadHook> = std::sync::OnceLock::new();
     34 
     35 #[cfg(test)]
     36 static RUN_BOOTSTRAP_HOOK: std::sync::OnceLock<std::sync::Mutex<Option<Result<(), String>>>> =
     37     std::sync::OnceLock::new();
     38 
     39 #[cfg(test)]
     40 static RUN_WAIT_HOOK: std::sync::OnceLock<std::sync::Mutex<Option<RunWaitOutcome>>> =
     41     std::sync::OnceLock::new();
     42 
     43 #[cfg(test)]
     44 static RUN_START_RPC_HOOK: std::sync::OnceLock<
     45     std::sync::Mutex<Option<Result<ServerHandle, String>>>,
     46 > = std::sync::OnceLock::new();
     47 
     48 #[derive(Clone, Copy)]
     49 enum RunWaitOutcome {
     50     Shutdown,
     51     Stopped,
     52 }
     53 
     54 #[cfg(not(test))]
     55 fn init_logging(logs_dir: &std::path::Path, default_level: Option<&str>) -> Result<()> {
     56     std::fs::create_dir_all(logs_dir)
     57         .with_context(|| format!("create log directory {}", logs_dir.display()))?;
     58     let appender = tracing_appender::rolling::never(logs_dir, "radrootsd.log");
     59     let (writer, guard) = tracing_appender::non_blocking(appender);
     60     static LOG_GUARD: std::sync::OnceLock<tracing_appender::non_blocking::WorkerGuard> =
     61         std::sync::OnceLock::new();
     62     let filter = std::env::var("RADROOTS_LOG_LEVEL")
     63         .or_else(|_| std::env::var("RUST_LOG"))
     64         .ok()
     65         .or_else(|| default_level.map(str::to_owned))
     66         .unwrap_or_else(|| "info".to_owned());
     67     tracing_subscriber::fmt()
     68         .with_env_filter(EnvFilter::new(filter))
     69         .with_writer(writer)
     70         .try_init()
     71         .map_err(|error| anyhow::anyhow!("initialize logging: {error}"))?;
     72     LOG_GUARD
     73         .set(guard)
     74         .map_err(|_| anyhow::anyhow!("logging is already initialized"))?;
     75     Ok(())
     76 }
     77 
     78 #[cfg(not(test))]
     79 async fn shutdown_signal() {
     80     let ctrl_c = async {
     81         tokio::signal::ctrl_c()
     82             .await
     83             .expect("failed to install Ctrl+C handler");
     84     };
     85     #[cfg(unix)]
     86     let terminate = async {
     87         tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
     88             .expect("failed to install signal handler")
     89             .recv()
     90             .await;
     91     };
     92     #[cfg(not(unix))]
     93     let terminate = std::future::pending::<()>();
     94     tokio::select! {
     95         _ = ctrl_c => {},
     96         _ = terminate => {},
     97     }
     98 }
     99 
    100 #[derive(Debug, Clone, PartialEq, Eq)]
    101 struct RadrootsdRuntimeStartupReport {
    102     active_profile: String,
    103     config_path: PathBuf,
    104     config_path_source: String,
    105     canonical_config_path: PathBuf,
    106     logs_dir: PathBuf,
    107     logs_dir_source: String,
    108     canonical_logs_dir: PathBuf,
    109     identity_path: PathBuf,
    110     identity_path_source: String,
    111     canonical_identity_path: PathBuf,
    112     transport_publish_database_path: PathBuf,
    113     transport_publish_database_path_source: String,
    114     canonical_transport_publish_database_path: PathBuf,
    115     path_overrides: paths::RadrootsdRuntimePathOverrideContractOutput,
    116     default_shared_secret_backend: String,
    117     allowed_shared_secret_backends: Vec<String>,
    118 }
    119 
    120 #[cfg(test)]
    121 fn run_load_hook() -> &'static RunLoadHook {
    122     RUN_LOAD_HOOK.get_or_init(|| std::sync::Mutex::new(None))
    123 }
    124 
    125 #[cfg(test)]
    126 fn run_bootstrap_hook() -> &'static std::sync::Mutex<Option<Result<(), String>>> {
    127     RUN_BOOTSTRAP_HOOK.get_or_init(|| std::sync::Mutex::new(None))
    128 }
    129 
    130 #[cfg(test)]
    131 fn run_wait_hook() -> &'static std::sync::Mutex<Option<RunWaitOutcome>> {
    132     RUN_WAIT_HOOK.get_or_init(|| std::sync::Mutex::new(None))
    133 }
    134 
    135 #[cfg(test)]
    136 fn run_start_rpc_hook() -> &'static std::sync::Mutex<Option<Result<ServerHandle, String>>> {
    137     RUN_START_RPC_HOOK.get_or_init(|| std::sync::Mutex::new(None))
    138 }
    139 
    140 #[cfg(test)]
    141 fn take_load_hook_result() -> Option<Result<(cli::Args, config::Settings), String>> {
    142     run_load_hook()
    143         .lock()
    144         .unwrap_or_else(std::sync::PoisonError::into_inner)
    145         .take()
    146 }
    147 
    148 #[cfg(test)]
    149 fn take_bootstrap_hook_result() -> Option<Result<(), String>> {
    150     run_bootstrap_hook()
    151         .lock()
    152         .unwrap_or_else(std::sync::PoisonError::into_inner)
    153         .take()
    154 }
    155 
    156 #[cfg(not(test))]
    157 fn take_bootstrap_hook_result() -> Option<Result<(), String>> {
    158     None
    159 }
    160 
    161 #[cfg(test)]
    162 fn take_wait_hook_result() -> Option<RunWaitOutcome> {
    163     run_wait_hook()
    164         .lock()
    165         .unwrap_or_else(std::sync::PoisonError::into_inner)
    166         .take()
    167 }
    168 
    169 #[cfg(test)]
    170 fn take_start_rpc_hook_result() -> Option<Result<ServerHandle, String>> {
    171     run_start_rpc_hook()
    172         .lock()
    173         .unwrap_or_else(std::sync::PoisonError::into_inner)
    174         .take()
    175 }
    176 
    177 fn load_args_and_settings() -> Result<Option<(cli::Args, config::Settings)>> {
    178     #[cfg(test)]
    179     {
    180         if let Some(result) = take_load_hook_result() {
    181             return result.map(Some).map_err(anyhow::Error::msg);
    182         }
    183         Err(anyhow::anyhow!("run loader hook not set"))
    184     }
    185 
    186     #[cfg(not(test))]
    187     {
    188         let args = match cli::Args::try_parse() {
    189             Ok(args) => args,
    190             Err(display)
    191                 if matches!(
    192                     display.kind(),
    193                     clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion
    194                 ) =>
    195             {
    196                 display.print()?;
    197                 return Ok(None);
    198             }
    199             Err(error) => return Err(error.into()),
    200         };
    201         let config_path = args
    202             .service
    203             .config
    204             .clone()
    205             .map(Ok)
    206             .unwrap_or_else(paths::default_config_path_for_process)?;
    207         let settings =
    208             config::load_settings_from_path(&config_path).context("load configuration")?;
    209         init_logging(
    210             std::path::Path::new(settings.config.service.logs_dir.as_str()),
    211             None,
    212         )?;
    213         Ok(Some((args, settings)))
    214     }
    215 }
    216 
    217 fn runtime_startup_report(
    218     args: &cli::Args,
    219     settings: &config::Settings,
    220     contract: &paths::RadrootsdRuntimeContractOutput,
    221 ) -> RadrootsdRuntimeStartupReport {
    222     RadrootsdRuntimeStartupReport {
    223         active_profile: contract.active_profile.clone(),
    224         config_path: args
    225             .service
    226             .config
    227             .clone()
    228             .unwrap_or_else(|| contract.canonical_config_path.clone()),
    229         config_path_source: cli_or_profile_path_source(
    230             args.service.config.is_some(),
    231             &args
    232                 .service
    233                 .config
    234                 .clone()
    235                 .unwrap_or_else(|| contract.canonical_config_path.clone()),
    236             &contract.canonical_config_path,
    237         ),
    238         canonical_config_path: contract.canonical_config_path.clone(),
    239         logs_dir: PathBuf::from(settings.config.service.logs_dir.as_str()),
    240         logs_dir_source: config_or_profile_path_source(
    241             &PathBuf::from(settings.config.service.logs_dir.as_str()),
    242             &contract.canonical_logs_dir,
    243         ),
    244         canonical_logs_dir: contract.canonical_logs_dir.clone(),
    245         identity_path: args
    246             .service
    247             .identity
    248             .clone()
    249             .unwrap_or_else(|| contract.canonical_identity_path.clone()),
    250         identity_path_source: cli_or_profile_path_source(
    251             args.service.identity.is_some(),
    252             &args
    253                 .service
    254                 .identity
    255                 .clone()
    256                 .unwrap_or_else(|| contract.canonical_identity_path.clone()),
    257             &contract.canonical_identity_path,
    258         ),
    259         canonical_identity_path: contract.canonical_identity_path.clone(),
    260         transport_publish_database_path: settings.config.transport_publish.database_path.clone(),
    261         transport_publish_database_path_source: config_or_profile_path_source(
    262             &settings.config.transport_publish.database_path,
    263             &contract.canonical_transport_publish_database_path,
    264         ),
    265         canonical_transport_publish_database_path: contract
    266             .canonical_transport_publish_database_path
    267             .clone(),
    268         path_overrides: contract.path_overrides.clone(),
    269         default_shared_secret_backend: contract.default_shared_secret_backend.clone(),
    270         allowed_shared_secret_backends: contract.allowed_shared_secret_backends.clone(),
    271     }
    272 }
    273 
    274 fn cli_or_profile_path_source(
    275     is_cli_arg: bool,
    276     actual_path: &PathBuf,
    277     canonical_path: &PathBuf,
    278 ) -> String {
    279     if is_cli_arg {
    280         "cli_arg".to_owned()
    281     } else {
    282         config_or_profile_path_source(actual_path, canonical_path)
    283     }
    284 }
    285 
    286 fn config_or_profile_path_source(actual_path: &PathBuf, canonical_path: &PathBuf) -> String {
    287     if actual_path == canonical_path {
    288         "profile_default".to_owned()
    289     } else {
    290         "config_artifact".to_owned()
    291     }
    292 }
    293 
    294 #[cfg(not(test))]
    295 fn log_runtime_startup_report(report: &RadrootsdRuntimeStartupReport) {
    296     info!(
    297         active_profile = report.active_profile.as_str(),
    298         profile_source = report.path_overrides.profile_source.as_str(),
    299         root_source = report.path_overrides.root_source.as_str(),
    300         repo_local_root = ?report.path_overrides.repo_local_root,
    301         repo_local_root_source = ?report.path_overrides.repo_local_root_source,
    302         subordinate_path_override_source = report.path_overrides.subordinate_path_override_source.as_str(),
    303         config_path = %report.config_path.display(),
    304         config_path_source = report.config_path_source.as_str(),
    305         canonical_config_path = %report.canonical_config_path.display(),
    306         logs_dir = %report.logs_dir.display(),
    307         logs_dir_source = report.logs_dir_source.as_str(),
    308         canonical_logs_dir = %report.canonical_logs_dir.display(),
    309         identity_path = %report.identity_path.display(),
    310         identity_path_source = report.identity_path_source.as_str(),
    311         canonical_identity_path = %report.canonical_identity_path.display(),
    312         transport_publish_database_path = %report.transport_publish_database_path.display(),
    313         transport_publish_database_path_source = report.transport_publish_database_path_source.as_str(),
    314         canonical_transport_publish_database_path = %report.canonical_transport_publish_database_path.display(),
    315         default_shared_secret_backend = report.default_shared_secret_backend.as_str(),
    316         allowed_shared_secret_backends = ?report.allowed_shared_secret_backends,
    317         "radrootsd runtime contract"
    318     );
    319 }
    320 
    321 #[cfg_attr(coverage_nightly, coverage(off))]
    322 async fn bootstrap_presence(
    323     client: &crate::host_nostr::DaemonNostrClient,
    324     identity: &DaemonIdentity,
    325     profile: &AuthoredProfile,
    326     handler_spec: &ApplicationHandlerSpec,
    327 ) -> Result<()> {
    328     if let Some(result) = take_bootstrap_hook_result() {
    329         return result.map_err(anyhow::Error::msg);
    330     }
    331 
    332     let (profile_event, handler_event) =
    333         build_service_presence_events(identity, profile, handler_spec)?;
    334 
    335     client.connect().await;
    336     client.wait_for_connection(Duration::from_secs(5)).await;
    337     if !client
    338         .relays()
    339         .await
    340         .into_values()
    341         .any(|relay| relay.is_connected())
    342     {
    343         bail!("service presence requires at least one connected relay");
    344     }
    345 
    346     publish_presence_event(client, &profile_event, "service Profile").await?;
    347     publish_presence_event(client, &handler_event, "NIP-89 application handler").await?;
    348     Ok(())
    349 }
    350 
    351 fn build_service_presence_events(
    352     identity: &DaemonIdentity,
    353     profile: &AuthoredProfile,
    354     handler_spec: &ApplicationHandlerSpec,
    355 ) -> Result<(nostr::Event, nostr::Event)> {
    356     let profile_event = build_profile(profile)
    357         .context("build service Profile event")?
    358         .sign_with_keys(identity.keys())
    359         .context("sign service Profile event")?;
    360     let handler_event = build_application_handler(handler_spec)
    361         .context("build NIP-89 application handler event")?
    362         .sign_with_keys(identity.keys())
    363         .context("sign NIP-89 application handler event")?;
    364     Ok((profile_event, handler_event))
    365 }
    366 
    367 async fn publish_presence_event(
    368     client: &crate::host_nostr::DaemonNostrClient,
    369     event: &nostr::Event,
    370     event_name: &str,
    371 ) -> Result<()> {
    372     let output = client
    373         .send_event(event)
    374         .await
    375         .with_context(|| format!("publish {event_name}"))?;
    376     if output.success.is_empty() {
    377         bail!("{event_name} publication did not succeed on any relay");
    378     }
    379     Ok(())
    380 }
    381 
    382 #[cfg_attr(coverage_nightly, coverage(off))]
    383 async fn publish_service_presence(
    384     client: crate::host_nostr::DaemonNostrClient,
    385     identity: DaemonIdentity,
    386     profile: AuthoredProfile,
    387     metadata: crate::host_nostr::Metadata,
    388     service_cfg: config::NostrServiceConfig,
    389     nip46_config: config::Nip46Config,
    390 ) -> Result<()> {
    391     let kinds = service_presence_kinds();
    392     let mut handler_spec = ApplicationHandlerSpec::new(kinds)
    393         .with_metadata(metadata.clone())
    394         .with_extra_tags(service_cfg.nip89_extra_tags.clone())
    395         .with_relays(service_cfg.relays.clone());
    396     if let Some(identifier) = service_cfg.nip89_identifier.clone() {
    397         handler_spec = handler_spec.with_identifier(identifier);
    398     }
    399     if let Some(url) = nip46_config.nostrconnect_url.clone() {
    400         handler_spec = handler_spec.with_nostr_connect_url(url);
    401     }
    402     bootstrap_presence(&client, &identity, &profile, &handler_spec).await
    403 }
    404 
    405 #[cfg_attr(coverage_nightly, coverage(off))]
    406 async fn maybe_publish_service_presence(
    407     client: crate::host_nostr::DaemonNostrClient,
    408     identity: DaemonIdentity,
    409     profile: AuthoredProfile,
    410     metadata: crate::host_nostr::Metadata,
    411     service_cfg: config::NostrServiceConfig,
    412     nip46_config: config::Nip46Config,
    413 ) {
    414     #[cfg(test)]
    415     {
    416         let result = publish_service_presence(
    417             client,
    418             identity,
    419             profile,
    420             metadata,
    421             service_cfg,
    422             nip46_config,
    423         )
    424         .await;
    425         if let Err(err) = result {
    426             warn!("Failed to publish service presence on startup: {err}");
    427         } else {
    428             info!("Published service presence on startup");
    429         }
    430     }
    431 
    432     #[cfg(not(test))]
    433     tokio::spawn(async move {
    434         let result = publish_service_presence(
    435             client,
    436             identity,
    437             profile,
    438             metadata,
    439             service_cfg,
    440             nip46_config,
    441         )
    442         .await;
    443         if let Err(err) = result {
    444             warn!("Failed to publish service presence on startup: {err}");
    445         } else {
    446             info!("Published service presence on startup");
    447         }
    448     });
    449 }
    450 
    451 #[cfg(not(test))]
    452 #[cfg_attr(coverage_nightly, coverage(off))]
    453 fn spawn_nip46_listener_io(radrootsd: Radrootsd) {
    454     spawn_nip46_listener(radrootsd);
    455 }
    456 
    457 #[cfg(test)]
    458 fn spawn_nip46_listener_io(_radrootsd: Radrootsd) {}
    459 
    460 #[cfg(test)]
    461 async fn start_rpc_io(
    462     state: Radrootsd,
    463     addr: std::net::SocketAddr,
    464     rpc_cfg: &config::RpcConfig,
    465 ) -> Result<ServerHandle> {
    466     if let Some(result) = take_start_rpc_hook_result() {
    467         return result.map_err(anyhow::Error::msg);
    468     }
    469     jsonrpc::start_rpc(state, addr, rpc_cfg).await
    470 }
    471 
    472 #[cfg(not(test))]
    473 #[cfg_attr(coverage_nightly, coverage(off))]
    474 async fn start_rpc_io(
    475     state: Radrootsd,
    476     addr: std::net::SocketAddr,
    477     rpc_cfg: &config::RpcConfig,
    478 ) -> Result<ServerHandle> {
    479     jsonrpc::start_rpc(state, addr, rpc_cfg).await
    480 }
    481 
    482 #[cfg(test)]
    483 async fn wait_for_shutdown_or_stopped(handle: ServerHandle) -> RunWaitOutcome {
    484     if let Some(outcome) = take_wait_hook_result() {
    485         return outcome;
    486     }
    487     handle.stopped().await;
    488     RunWaitOutcome::Stopped
    489 }
    490 
    491 #[cfg(not(test))]
    492 #[cfg_attr(coverage_nightly, coverage(off))]
    493 async fn wait_for_shutdown_or_stopped(handle: ServerHandle) -> RunWaitOutcome {
    494     tokio::select! {
    495         _ = shutdown_signal() => RunWaitOutcome::Shutdown,
    496         _ = handle.stopped() => RunWaitOutcome::Stopped,
    497     }
    498 }
    499 
    500 async fn handle_command(command: cli::Command, settings: &config::Settings) -> Result<()> {
    501     match command {
    502         cli::Command::TransportPublish(command) => match command.command {
    503             cli::TransportPublishSubcommand::Principal(command) => match command.command {
    504                 cli::PrincipalSubcommand::Init(args) => {
    505                     let token = generate_bearer_token();
    506                     let token_hash = hash_bearer_token(token.as_str());
    507                     let store = TransportPublishStore::open(
    508                         settings.config.transport_publish.database_path.clone(),
    509                     )?;
    510                     let allowed_target_policies = args
    511                         .allowed_target_policy
    512                         .iter()
    513                         .map(|policy| parse_target_policy(policy.as_str()))
    514                         .collect::<Result<Vec<_>, _>>()?;
    515                     let allowed_explicit_transport_kinds = args
    516                         .allowed_explicit_transport_kind
    517                         .iter()
    518                         .map(|transport_kind| {
    519                             parse_explicit_transport_kind(transport_kind.as_str())
    520                         })
    521                         .collect::<Result<Vec<_>, _>>()?;
    522                     let allowed_nostr_source_policies = args
    523                         .allowed_nostr_source_policy
    524                         .iter()
    525                         .map(|policy| parse_nostr_source_policy(policy.as_str()))
    526                         .collect::<Result<Vec<_>, _>>()?;
    527                     let principal = store.create_principal(PublishPrincipalInit {
    528                         label: args.label,
    529                         token_hash,
    530                         allowed_pubkeys: args.allowed_pubkey,
    531                         allowed_kinds: args.allowed_kind,
    532                         allowed_target_policies,
    533                         allowed_explicit_transport_kinds,
    534                         allowed_nostr_source_policies,
    535                         allow_request_targets: args.allow_request_targets,
    536                         job_visibility: args.job_visibility.parse()?,
    537                         expires_at_unix: None,
    538                     })?;
    539                     write_token_file(&args.token_file, token.as_str())?;
    540                     println!(
    541                         "{}",
    542                         serde_json::json!({
    543                             "principal_id": principal.principal_id,
    544                             "label": principal.label,
    545                             "token_file": args.token_file,
    546                             "database_path": settings.config.transport_publish.database_path,
    547                         })
    548                     );
    549                     Ok(())
    550                 }
    551             },
    552         },
    553     }
    554 }
    555 
    556 pub async fn run() -> Result<()> {
    557     let Some((args, settings)) = load_args_and_settings()? else {
    558         return Ok(());
    559     };
    560     settings.validate()?;
    561     let authored_profile = settings.authored_profile()?;
    562 
    563     #[cfg(not(test))]
    564     {
    565         let contract = paths::runtime_contract_for_process().context("resolve runtime contract")?;
    566         let report = runtime_startup_report(&args, &settings, &contract);
    567         log_runtime_startup_report(&report);
    568     }
    569 
    570     if let Some(command) = args.command.clone() {
    571         return handle_command(command, &settings).await;
    572     }
    573 
    574     info!("Starting radrootsd");
    575 
    576     let identity = load_service_identity(
    577         args.service.identity.as_deref(),
    578         args.service.allow_generate_identity,
    579     )?;
    580     let radrootsd = Radrootsd::new(
    581         identity.clone(),
    582         settings.config.transport_publish.clone(),
    583         settings.config.nip46.clone(),
    584     );
    585     let radrootsd = radrootsd?;
    586 
    587     for relay in settings.config.service.relays.iter() {
    588         radrootsd.client.add_relay(relay).await?;
    589     }
    590 
    591     if !settings.config.service.relays.is_empty() {
    592         maybe_publish_service_presence(
    593             radrootsd.client.clone(),
    594             identity.clone(),
    595             authored_profile,
    596             settings.metadata.clone(),
    597             settings.config.service.clone(),
    598             settings.config.nip46.clone(),
    599         )
    600         .await;
    601 
    602         spawn_nip46_listener_io(radrootsd.clone());
    603     }
    604 
    605     let addr: std::net::SocketAddr = settings.config.rpc_addr().parse()?;
    606     let handle = start_rpc_io(radrootsd.clone(), addr, &settings.config.rpc).await?;
    607     info!("JSON-RPC listening on {addr}");
    608 
    609     let stop_handle = handle.clone();
    610 
    611     match wait_for_shutdown_or_stopped(handle).await {
    612         RunWaitOutcome::Shutdown => {
    613             info!("Shutting down…");
    614             let _ = stop_handle.stop();
    615         }
    616         RunWaitOutcome::Stopped => {}
    617     }
    618 
    619     Ok(())
    620 }
    621 
    622 fn service_presence_kinds() -> Vec<u32> {
    623     let mut kinds = vec![Kind::NostrConnect.as_u16() as u32];
    624     kinds.sort_unstable();
    625     kinds.dedup();
    626     kinds
    627 }
    628 
    629 #[cfg(test)]
    630 #[cfg_attr(coverage_nightly, coverage(off))]
    631 mod tests {
    632     use super::{
    633         RadrootsdRuntimeStartupReport, RunWaitOutcome, build_service_presence_events, run,
    634         run_bootstrap_hook, run_load_hook, run_start_rpc_hook, run_wait_hook,
    635         runtime_startup_report,
    636     };
    637     use crate::app::identity_storage::DaemonIdentity;
    638     use crate::app::{cli, config, paths};
    639     use crate::core::Radrootsd;
    640     use crate::host_nostr::{ApplicationHandlerSpec, Kind, Metadata};
    641     use crate::transport::jsonrpc;
    642     use std::path::Path;
    643     use std::path::PathBuf;
    644     use tokio::sync::{Mutex, MutexGuard};
    645 
    646     static TEST_LOCK: Mutex<()> = Mutex::const_new(());
    647 
    648     async fn test_guard() -> MutexGuard<'static, ()> {
    649         let guard = TEST_LOCK.lock().await;
    650         *run_load_hook()
    651             .lock()
    652             .unwrap_or_else(std::sync::PoisonError::into_inner) = None;
    653         *run_bootstrap_hook()
    654             .lock()
    655             .unwrap_or_else(std::sync::PoisonError::into_inner) = None;
    656         *run_wait_hook()
    657             .lock()
    658             .unwrap_or_else(std::sync::PoisonError::into_inner) = None;
    659         *run_start_rpc_hook()
    660             .lock()
    661             .unwrap_or_else(std::sync::PoisonError::into_inner) = None;
    662         guard
    663     }
    664 
    665     fn unique_identity_path(suffix: &str) -> PathBuf {
    666         let nanos = std::time::SystemTime::now()
    667             .duration_since(std::time::UNIX_EPOCH)
    668             .expect("time")
    669             .as_nanos();
    670         std::env::temp_dir().join(format!("radrootsd-{suffix}-{nanos}.secret.json"))
    671     }
    672 
    673     fn cleanup_identity_artifacts(path: &Path) {
    674         let _ = std::fs::remove_file(path);
    675         let _ = std::fs::remove_file(crate::app::identity_storage::encrypted_identity_key_path(
    676             path,
    677         ));
    678     }
    679 
    680     fn args_for_identity(path: PathBuf, allow_generate: bool) -> cli::Args {
    681         cli::Args {
    682             service: cli::ServiceCliArgs {
    683                 config: Some(PathBuf::from("config.toml")),
    684                 identity: Some(path),
    685                 allow_generate_identity: allow_generate,
    686             },
    687             command: None,
    688         }
    689     }
    690 
    691     fn settings_with_relays(relays: Vec<String>) -> config::Settings {
    692         let metadata: Metadata =
    693             serde_json::from_str(r#"{"name":"radrootsd-test"}"#).expect("metadata");
    694         config::Settings {
    695             metadata,
    696             config: config::Configuration {
    697                 service: config::NostrServiceConfig {
    698                     logs_dir: "logs".to_string(),
    699                     relays,
    700                     nip89_identifier: Some("radrootsd".to_string()),
    701                     nip89_extra_tags: Vec::new(),
    702                 },
    703                 rpc: config::RpcConfig {
    704                     addr: "127.0.0.1:0".to_string(),
    705                     ..config::RpcConfig::default()
    706                 },
    707                 rpc_addr: Some("127.0.0.1:0".to_string()),
    708                 nip46: config::Nip46Config::default(),
    709                 transport_publish: config::TransportPublishConfig::default(),
    710             },
    711         }
    712     }
    713 
    714     fn sample_runtime_contract() -> paths::RadrootsdRuntimeContractOutput {
    715         paths::RadrootsdRuntimeContractOutput {
    716             active_profile: "interactive_user".to_string(),
    717             allowed_profiles: vec![
    718                 "interactive_user".to_string(),
    719                 "service_host".to_string(),
    720                 "repo_local".to_string(),
    721             ],
    722             path_overrides: paths::RadrootsdRuntimePathOverrideContractOutput {
    723                 profile_source: "caller".to_string(),
    724                 root_source: "host_defaults".to_string(),
    725                 repo_local_root: None,
    726                 repo_local_root_source: None,
    727                 subordinate_path_override_source: "config_artifact".to_string(),
    728                 subordinate_path_override_keys: vec![
    729                     "config.service.logs_dir".to_string(),
    730                     "config.transport_publish.database_path".to_string(),
    731                 ],
    732             },
    733             default_shared_secret_backend: "encrypted_file".to_string(),
    734             allowed_shared_secret_backends: vec!["encrypted_file".to_string()],
    735             canonical_config_path: PathBuf::from(
    736                 "/home/treesap/.radroots/config/services/radrootsd/config.toml",
    737             ),
    738             canonical_logs_dir: PathBuf::from("/home/treesap/.radroots/logs/services/radrootsd"),
    739             canonical_identity_path: PathBuf::from(
    740                 "/home/treesap/.radroots/secrets/services/radrootsd/identity.secret.json",
    741             ),
    742             canonical_transport_publish_database_path: PathBuf::from(
    743                 "/home/treesap/.radroots/data/services/radrootsd/transport_publish.sqlite",
    744             ),
    745         }
    746     }
    747 
    748     async fn make_handle(settings: &config::Settings) -> jsonrpsee::server::ServerHandle {
    749         let identity = DaemonIdentity::generate();
    750         let state = Radrootsd::new(
    751             identity,
    752             settings.config.transport_publish.clone(),
    753             settings.config.nip46.clone(),
    754         )
    755         .expect("state");
    756         jsonrpc::start_rpc(
    757             state,
    758             "127.0.0.1:0".parse().expect("addr"),
    759             &settings.config.rpc,
    760         )
    761         .await
    762         .expect("rpc handle")
    763     }
    764 
    765     #[tokio::test]
    766     async fn run_returns_error_when_hook_is_missing() {
    767         let _guard = test_guard().await;
    768         let err = run().await.expect_err("missing loader hook should error");
    769         let msg = format!("{err:#}");
    770         assert!(msg.contains("run loader hook not set"));
    771     }
    772 
    773     #[tokio::test]
    774     async fn run_returns_error_when_identity_missing() {
    775         let _guard = test_guard().await;
    776         let args = args_for_identity(PathBuf::from("/tmp/radrootsd-missing.secret.json"), false);
    777         let settings = settings_with_relays(Vec::new());
    778         *run_load_hook()
    779             .lock()
    780             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings)));
    781         let err = run().await.expect_err("missing identity should error");
    782         let msg = format!("{err:#}");
    783         assert!(msg.contains("identity"));
    784     }
    785 
    786     #[tokio::test]
    787     async fn run_covers_shutdown_path_and_presence_success() {
    788         let _guard = test_guard().await;
    789         let path = unique_identity_path("shutdown");
    790         let args = args_for_identity(path.clone(), true);
    791         let settings = settings_with_relays(vec!["wss://relay.example.com".to_string()]);
    792         let handle = make_handle(&settings).await;
    793         *run_load_hook()
    794             .lock()
    795             .unwrap_or_else(std::sync::PoisonError::into_inner) =
    796             Some(Ok((args, settings.clone())));
    797         *run_start_rpc_hook()
    798             .lock()
    799             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle));
    800         *run_wait_hook()
    801             .lock()
    802             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Shutdown);
    803         *run_bootstrap_hook()
    804             .lock()
    805             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(()));
    806         assert!(run().await.is_ok());
    807         cleanup_identity_artifacts(&path);
    808     }
    809 
    810     #[tokio::test]
    811     async fn run_covers_stopped_path_and_presence_failure() {
    812         let _guard = test_guard().await;
    813         let path = unique_identity_path("stopped");
    814         let args = args_for_identity(path.clone(), true);
    815         let settings = settings_with_relays(vec!["wss://relay.example.com".to_string()]);
    816         let handle = make_handle(&settings).await;
    817         let _ = handle.stop();
    818         *run_load_hook()
    819             .lock()
    820             .unwrap_or_else(std::sync::PoisonError::into_inner) =
    821             Some(Ok((args, settings.clone())));
    822         *run_start_rpc_hook()
    823             .lock()
    824             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle));
    825         *run_wait_hook()
    826             .lock()
    827             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Stopped);
    828         *run_bootstrap_hook()
    829             .lock()
    830             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Err("boom".to_string()));
    831         assert!(run().await.is_ok());
    832         cleanup_identity_artifacts(&path);
    833     }
    834 
    835     #[tokio::test]
    836     async fn run_skips_presence_when_relays_empty() {
    837         let _guard = test_guard().await;
    838         let path = unique_identity_path("empty");
    839         let args = args_for_identity(path.clone(), true);
    840         let settings = settings_with_relays(Vec::new());
    841         let handle = make_handle(&settings).await;
    842         *run_load_hook()
    843             .lock()
    844             .unwrap_or_else(std::sync::PoisonError::into_inner) =
    845             Some(Ok((args, settings.clone())));
    846         *run_start_rpc_hook()
    847             .lock()
    848             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle));
    849         *run_wait_hook()
    850             .lock()
    851             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Shutdown);
    852         assert!(run().await.is_ok());
    853         cleanup_identity_artifacts(&path);
    854     }
    855 
    856     #[tokio::test]
    857     async fn run_returns_error_when_relay_is_invalid() {
    858         let _guard = test_guard().await;
    859         let path = unique_identity_path("invalid-relay");
    860         let args = args_for_identity(path.clone(), true);
    861         let settings = settings_with_relays(vec!["not-a-relay".to_string()]);
    862         *run_load_hook()
    863             .lock()
    864             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings)));
    865         let err = run().await.expect_err("invalid relay should error");
    866         let msg = format!("{err:#}");
    867         assert!(!msg.is_empty());
    868         cleanup_identity_artifacts(&path);
    869     }
    870 
    871     #[tokio::test]
    872     async fn run_returns_error_when_rpc_addr_is_invalid() {
    873         let _guard = test_guard().await;
    874         let path = unique_identity_path("invalid-rpc-addr");
    875         let args = args_for_identity(path.clone(), true);
    876         let mut settings = settings_with_relays(Vec::new());
    877         settings.config.rpc_addr = Some("not-an-addr".to_string());
    878         *run_load_hook()
    879             .lock()
    880             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings)));
    881         let err = run().await.expect_err("invalid rpc addr should error");
    882         let msg = format!("{err:#}");
    883         assert!(msg.contains("invalid"));
    884         cleanup_identity_artifacts(&path);
    885     }
    886 
    887     #[tokio::test]
    888     async fn run_returns_error_when_rpc_start_fails() {
    889         let _guard = test_guard().await;
    890         let path = unique_identity_path("rpc-start-fail");
    891         let args = args_for_identity(path.clone(), true);
    892         let settings = settings_with_relays(Vec::new());
    893         *run_load_hook()
    894             .lock()
    895             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings)));
    896         *run_start_rpc_hook()
    897             .lock()
    898             .unwrap_or_else(std::sync::PoisonError::into_inner) =
    899             Some(Err("rpc start failed".to_string()));
    900         let err = run().await.expect_err("rpc start hook should fail");
    901         let msg = format!("{err:#}");
    902         assert!(msg.contains("rpc start failed"));
    903         cleanup_identity_artifacts(&path);
    904     }
    905 
    906     #[tokio::test]
    907     async fn run_waits_for_stopped_when_wait_hook_is_not_set() {
    908         let _guard = test_guard().await;
    909         let path = unique_identity_path("wait-no-hook");
    910         let args = args_for_identity(path.clone(), true);
    911         let settings = settings_with_relays(Vec::new());
    912         let handle = make_handle(&settings).await;
    913         let _ = handle.stop();
    914         *run_load_hook()
    915             .lock()
    916             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings)));
    917         *run_start_rpc_hook()
    918             .lock()
    919             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle));
    920         assert!(run().await.is_ok());
    921         cleanup_identity_artifacts(&path);
    922     }
    923 
    924     #[tokio::test]
    925     async fn run_starts_rpc_when_start_hook_is_not_set() {
    926         let _guard = test_guard().await;
    927         let path = unique_identity_path("start-rpc-real");
    928         let args = args_for_identity(path.clone(), true);
    929         let settings = settings_with_relays(Vec::new());
    930         *run_load_hook()
    931             .lock()
    932             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings)));
    933         *run_wait_hook()
    934             .lock()
    935             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Shutdown);
    936         assert!(run().await.is_ok());
    937         cleanup_identity_artifacts(&path);
    938     }
    939 
    940     #[test]
    941     fn service_presence_kinds_include_nostr_connect_only() {
    942         let kinds = super::service_presence_kinds();
    943 
    944         assert!(kinds.contains(&(crate::host_nostr::Kind::NostrConnect.as_u16() as u32)));
    945         assert_eq!(kinds.len(), 1);
    946     }
    947 
    948     #[test]
    949     fn service_presence_events_use_strict_profile_and_nip89_contracts() {
    950         let identity = DaemonIdentity::generate();
    951         let settings = settings_with_relays(vec!["wss://relay.example.com".to_owned()]);
    952         let profile = settings.authored_profile().expect("authored profile");
    953         let handler_spec = ApplicationHandlerSpec::new(super::service_presence_kinds())
    954             .with_identifier("radrootsd")
    955             .with_metadata(settings.metadata)
    956             .with_relays(settings.config.service.relays);
    957 
    958         let (profile_event, handler_event) =
    959             build_service_presence_events(&identity, &profile, &handler_spec)
    960                 .expect("service presence events");
    961 
    962         assert_eq!(profile_event.kind, Kind::Metadata);
    963         assert!(profile_event.tags.is_empty());
    964         assert_eq!(profile_event.pubkey, identity.public_key());
    965         assert_eq!(
    966             serde_json::from_str::<serde_json::Value>(&profile_event.content)
    967                 .expect("profile JSON"),
    968             serde_json::json!({"name": "radrootsd-test"})
    969         );
    970         assert_eq!(
    971             handler_event.kind,
    972             Kind::Custom(radroots_event::envelope::kind::KIND_APPLICATION_HANDLER as u16)
    973         );
    974         assert_eq!(handler_event.pubkey, identity.public_key());
    975         assert!(
    976             handler_event.tags.iter().any(|tag| {
    977                 tag.as_slice() == ["d".to_owned(), "radrootsd".to_owned()].as_slice()
    978             })
    979         );
    980         assert!(handler_event.tags.iter().any(|tag| {
    981             tag.as_slice() == ["k".to_owned(), Kind::NostrConnect.as_u16().to_string()].as_slice()
    982         }));
    983         assert!(handler_event.tags.iter().any(|tag| {
    984             tag.as_slice() == ["relay".to_owned(), "wss://relay.example.com".to_owned()].as_slice()
    985         }));
    986         assert!(handler_event.verify().is_ok());
    987     }
    988 
    989     #[tokio::test]
    990     async fn bootstrap_presence_fails_closed_without_a_connected_relay() {
    991         let _guard = test_guard().await;
    992         let identity = DaemonIdentity::generate();
    993         let client = crate::host_nostr::DaemonNostrClient::from_identity(&identity);
    994         let settings = settings_with_relays(Vec::new());
    995         let profile = settings.authored_profile().expect("authored profile");
    996         let handler_spec = ApplicationHandlerSpec::new(super::service_presence_kinds())
    997             .with_identifier("radrootsd")
    998             .with_metadata(settings.metadata);
    999 
   1000         let error = super::bootstrap_presence(&client, &identity, &profile, &handler_spec)
   1001             .await
   1002             .expect_err("missing relay connection must fail closed");
   1003         assert!(error.to_string().contains("at least one connected relay"));
   1004     }
   1005 
   1006     #[test]
   1007     fn runtime_startup_report_prefers_explicit_cli_paths() {
   1008         let args = cli::Args {
   1009             service: cli::ServiceCliArgs {
   1010                 config: Some(PathBuf::from("/tmp/radrootsd/config.toml")),
   1011                 identity: Some(PathBuf::from("/tmp/radrootsd/identity.secret.json")),
   1012                 allow_generate_identity: false,
   1013             },
   1014             command: None,
   1015         };
   1016         let mut settings = settings_with_relays(Vec::new());
   1017         settings.config.service.logs_dir = "/tmp/radrootsd/logs".to_string();
   1018         settings.config.transport_publish.database_path =
   1019             PathBuf::from("/tmp/radrootsd/transport_publish.sqlite");
   1020 
   1021         let contract = sample_runtime_contract();
   1022         let report = runtime_startup_report(&args, &settings, &contract);
   1023 
   1024         assert_eq!(
   1025             report,
   1026             RadrootsdRuntimeStartupReport {
   1027                 active_profile: "interactive_user".to_string(),
   1028                 config_path: PathBuf::from("/tmp/radrootsd/config.toml"),
   1029                 config_path_source: "cli_arg".to_string(),
   1030                 canonical_config_path: PathBuf::from(
   1031                     "/home/treesap/.radroots/config/services/radrootsd/config.toml"
   1032                 ),
   1033                 logs_dir: PathBuf::from("/tmp/radrootsd/logs"),
   1034                 logs_dir_source: "config_artifact".to_string(),
   1035                 canonical_logs_dir: PathBuf::from(
   1036                     "/home/treesap/.radroots/logs/services/radrootsd"
   1037                 ),
   1038                 identity_path: PathBuf::from("/tmp/radrootsd/identity.secret.json"),
   1039                 identity_path_source: "cli_arg".to_string(),
   1040                 canonical_identity_path: PathBuf::from(
   1041                     "/home/treesap/.radroots/secrets/services/radrootsd/identity.secret.json"
   1042                 ),
   1043                 transport_publish_database_path: PathBuf::from(
   1044                     "/tmp/radrootsd/transport_publish.sqlite"
   1045                 ),
   1046                 transport_publish_database_path_source: "config_artifact".to_string(),
   1047                 canonical_transport_publish_database_path: PathBuf::from(
   1048                     "/home/treesap/.radroots/data/services/radrootsd/transport_publish.sqlite"
   1049                 ),
   1050                 path_overrides: sample_runtime_contract().path_overrides,
   1051                 default_shared_secret_backend: "encrypted_file".to_string(),
   1052                 allowed_shared_secret_backends: vec!["encrypted_file".to_string()],
   1053             }
   1054         );
   1055     }
   1056 
   1057     #[test]
   1058     fn runtime_startup_report_falls_back_to_canonical_contract_paths() {
   1059         let args = cli::Args {
   1060             service: cli::ServiceCliArgs {
   1061                 config: None,
   1062                 identity: None,
   1063                 allow_generate_identity: false,
   1064             },
   1065             command: None,
   1066         };
   1067         let contract = sample_runtime_contract();
   1068         let mut settings = settings_with_relays(Vec::new());
   1069         settings.config.service.logs_dir = contract.canonical_logs_dir.display().to_string();
   1070         settings.config.transport_publish.database_path =
   1071             contract.canonical_transport_publish_database_path.clone();
   1072 
   1073         let report = runtime_startup_report(&args, &settings, &contract);
   1074 
   1075         assert_eq!(report.config_path, contract.canonical_config_path);
   1076         assert_eq!(report.config_path_source, "profile_default");
   1077         assert_eq!(report.logs_dir, contract.canonical_logs_dir);
   1078         assert_eq!(report.logs_dir_source, "profile_default");
   1079         assert_eq!(report.identity_path, contract.canonical_identity_path);
   1080         assert_eq!(report.identity_path_source, "profile_default");
   1081         assert_eq!(
   1082             report.transport_publish_database_path,
   1083             contract.canonical_transport_publish_database_path
   1084         );
   1085         assert_eq!(
   1086             report.transport_publish_database_path_source,
   1087             "profile_default"
   1088         );
   1089         assert_eq!(report.path_overrides, contract.path_overrides);
   1090         assert_eq!(report.default_shared_secret_backend, "encrypted_file");
   1091         assert_eq!(
   1092             report.allowed_shared_secret_backends,
   1093             vec!["encrypted_file".to_string()]
   1094         );
   1095     }
   1096 }