@cc-remote/iroh 1.0.0-rc.3

package/src/key.rs

@@ -0,0 +1,173 @@
+use std::str::FromStr;
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+/// An endpoint's identifier, a 32-byte ed25519 public key.
+#[derive(Debug, Clone, Eq)]
+#[napi]
+pub struct EndpointId {
+    key: [u8; 32],
+}
+
+impl From<iroh::EndpointId> for EndpointId {
+    fn from(key: iroh::EndpointId) -> Self {
+        EndpointId {
+            key: *key.as_bytes(),
+        }
+    }
+}
+
+impl From<&EndpointId> for iroh::EndpointId {
+    fn from(key: &EndpointId) -> Self {
+        iroh::EndpointId::from_bytes(&key.key).expect("EndpointId bytes are always valid")
+    }
+}
+
+impl EndpointId {
+    pub(crate) fn raw_bytes(&self) -> [u8; 32] {
+        self.key
+    }
+
+    pub(crate) fn from_raw_bytes(key: [u8; 32]) -> Self {
+        EndpointId { key }
+    }
+}
+
+#[napi]
+impl EndpointId {
+    /// Returns true if both [`EndpointId`]s are equal.
+    #[napi]
+    pub fn equals(&self, other: &EndpointId) -> bool {
+        *self == *other
+    }
+
+    /// Get the underlying 32 bytes.
+    #[napi]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.key.to_vec()
+    }
+
+    /// Parse an [`EndpointId`] from its base32 representation.
+    #[napi(factory)]
+    pub fn from_string(s: String) -> Result<Self> {
+        let key = iroh::EndpointId::from_str(&s).map_err(anyhow::Error::from)?;
+        Ok(key.into())
+    }
+
+    /// Construct an [`EndpointId`] from raw bytes (32 bytes).
+    #[napi(factory)]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<Self> {
+        let bytes: [u8; 32] = bytes
+            .try_into()
+            .map_err(|_| anyhow::anyhow!("EndpointId requires exactly 32 bytes"))?;
+        let key = iroh::EndpointId::from_bytes(&bytes).map_err(anyhow::Error::from)?;
+        Ok(key.into())
+    }
+
+    /// Short base32 prefix.
+    #[napi]
+    pub fn fmt_short(&self) -> String {
+        iroh::EndpointId::from(self).fmt_short().to_string()
+    }
+
+    /// Base32 string form.
+    #[napi]
+    pub fn to_string(&self) -> String {
+        iroh::EndpointId::from(self).to_string()
+    }
+
+    /// Verify a signature on `message` against this endpoint's key.
+    #[napi]
+    pub fn verify(&self, message: Vec<u8>, signature: &Signature) -> Result<()> {
+        iroh::EndpointId::from(self)
+            .verify(&message, &signature.0)
+            .map_err(|e| anyhow::anyhow!("signature verification failed: {e:?}").into())
+    }
+}
+
+impl PartialEq for EndpointId {
+    fn eq(&self, other: &EndpointId) -> bool {
+        self.key == other.key
+    }
+}
+
+/// The secret key half of an endpoint identity.
+#[derive(Debug, Clone)]
+#[napi]
+pub struct SecretKey(pub(crate) iroh::SecretKey);
+
+impl From<iroh::SecretKey> for SecretKey {
+    fn from(key: iroh::SecretKey) -> Self {
+        SecretKey(key)
+    }
+}
+
+#[napi]
+impl SecretKey {
+    /// Generate a new random secret key.
+    #[napi(factory)]
+    pub fn generate() -> Self {
+        SecretKey(iroh::SecretKey::generate())
+    }
+
+    /// Construct from raw bytes (32 bytes).
+    #[napi(factory)]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<Self> {
+        let bytes: [u8; 32] = bytes
+            .try_into()
+            .map_err(|_| anyhow::anyhow!("SecretKey requires exactly 32 bytes"))?;
+        Ok(SecretKey(iroh::SecretKey::from_bytes(&bytes)))
+    }
+
+    /// Raw 32-byte form.
+    #[napi]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes().to_vec()
+    }
+
+    /// The public [`EndpointId`] derived from this secret key.
+    #[napi]
+    pub fn public(&self) -> EndpointId {
+        self.0.public().into()
+    }
+
+    /// Sign a message, producing an ed25519 signature.
+    #[napi]
+    pub fn sign(&self, message: Vec<u8>) -> Signature {
+        Signature(self.0.sign(&message))
+    }
+}
+
+/// An ed25519 signature over a message.
+#[derive(Debug, Clone)]
+#[napi]
+pub struct Signature(pub(crate) iroh_base::Signature);
+
+#[napi]
+impl Signature {
+    /// Construct from raw bytes (64 bytes).
+    #[napi(factory)]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<Self> {
+        let bytes: [u8; 64] = bytes
+            .try_into()
+            .map_err(|_| anyhow::anyhow!("Signature requires exactly 64 bytes"))?;
+        Ok(Signature(iroh_base::Signature::from_bytes(&bytes)))
+    }
+
+    /// Raw 64-byte form.
+    #[napi]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes().to_vec()
+    }
+
+    /// Lowercase hex representation.
+    #[napi]
+    pub fn to_string(&self) -> String {
+        self.0
+            .to_bytes()
+            .iter()
+            .map(|b| format!("{b:02x}"))
+            .collect()
+    }
+}

package/src/lib.rs

@@ -0,0 +1,59 @@
+use napi_derive::napi;
+use tracing_subscriber::filter::LevelFilter;
+
+mod endpoint;
+mod key;
+mod net;
+mod path;
+mod relay;
+mod services;
+mod ticket;
+mod watch;
+
+pub use endpoint::*;
+pub use key::*;
+pub use net::*;
+pub use path::*;
+pub use relay::*;
+pub use services::*;
+pub use ticket::*;
+pub use watch::*;
+
+/// The logging level. See the rust (log crate)[https://docs.rs/log] for more information.
+#[derive(Debug)]
+#[napi(string_enum)]
+pub enum LogLevel {
+    Trace,
+    Debug,
+    Info,
+    Warn,
+    Error,
+    Off,
+}
+
+impl From<LogLevel> for LevelFilter {
+    fn from(level: LogLevel) -> LevelFilter {
+        match level {
+            LogLevel::Trace => LevelFilter::TRACE,
+            LogLevel::Debug => LevelFilter::DEBUG,
+            LogLevel::Info => LevelFilter::INFO,
+            LogLevel::Warn => LevelFilter::WARN,
+            LogLevel::Error => LevelFilter::ERROR,
+            LogLevel::Off => LevelFilter::OFF,
+        }
+    }
+}
+
+/// Set the logging level.
+#[napi]
+pub fn set_log_level(level: LogLevel) {
+    use tracing_subscriber::{fmt, prelude::*, reload};
+    let filter: LevelFilter = level.into();
+    let (filter, _) = reload::Layer::new(filter);
+    let mut layer = fmt::Layer::default();
+    layer.set_ansi(false);
+    tracing_subscriber::registry()
+        .with(filter)
+        .with(layer)
+        .init();
+}

package/src/net.rs

@@ -0,0 +1,106 @@
+use std::{collections::BTreeSet, net::SocketAddr, str::FromStr};
+
+use iroh_base::{RelayUrl, TransportAddr};
+use napi_derive::napi;
+
+use crate::EndpointId;
+
+/// An endpoint's id together with the network-level addresses where it can be
+/// reached. Mirrors the uniffi `EndpointAddr` object surface.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[napi]
+pub struct EndpointAddr {
+    pub(crate) id: [u8; 32],
+    pub(crate) relay_url: Option<String>,
+    pub(crate) addresses: Vec<String>,
+}
+
+#[napi]
+impl EndpointAddr {
+    /// Create a new [`EndpointAddr`].
+    #[napi(constructor)]
+    pub fn new(id: &EndpointId, relay_url: Option<String>, addresses: Option<Vec<String>>) -> Self {
+        Self {
+            id: id.raw_bytes(),
+            relay_url,
+            addresses: addresses.unwrap_or_default(),
+        }
+    }
+
+    /// The endpoint id.
+    #[napi]
+    pub fn id(&self) -> EndpointId {
+        EndpointId::from_raw_bytes(self.id)
+    }
+
+    /// The direct (ip:port) addresses of this peer.
+    #[napi]
+    pub fn direct_addresses(&self) -> Vec<String> {
+        self.addresses.clone()
+    }
+
+    /// The home relay URL for this peer, if known.
+    #[napi]
+    pub fn relay_url(&self) -> Option<String> {
+        self.relay_url.clone()
+    }
+
+    /// Returns true if both [`EndpointAddr`]s have the same values.
+    #[napi]
+    pub fn equal(&self, other: &EndpointAddr) -> bool {
+        self == other
+    }
+
+    /// Clean string representation.
+    #[napi]
+    pub fn to_string(&self) -> String {
+        let id = iroh::EndpointId::from_bytes(&self.id)
+            .map(|i| i.to_string())
+            .unwrap_or_else(|_| "<invalid>".to_string());
+        let mut s = id;
+        if let Some(relay) = &self.relay_url {
+            s.push_str(&format!(" relay={relay}"));
+        }
+        if !self.addresses.is_empty() {
+            s.push_str(&format!(" addrs=[{}]", self.addresses.join(", ")));
+        }
+        s
+    }
+}
+
+impl TryFrom<&EndpointAddr> for iroh::EndpointAddr {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &EndpointAddr) -> anyhow::Result<Self> {
+        let id = iroh::EndpointId::from_bytes(&value.id)?;
+        let mut addrs: BTreeSet<TransportAddr> = BTreeSet::new();
+        for addr in &value.addresses {
+            let socket = SocketAddr::from_str(addr)?;
+            addrs.insert(TransportAddr::Ip(socket));
+        }
+        if let Some(relay) = &value.relay_url {
+            let url = RelayUrl::from_str(relay)?;
+            addrs.insert(TransportAddr::Relay(url));
+        }
+        Ok(iroh::EndpointAddr { id, addrs })
+    }
+}
+
+impl From<iroh::EndpointAddr> for EndpointAddr {
+    fn from(value: iroh::EndpointAddr) -> Self {
+        let mut relay_url = None;
+        let mut addresses = Vec::new();
+        for addr in &value.addrs {
+            match addr {
+                TransportAddr::Relay(url) => relay_url = Some(url.to_string()),
+                TransportAddr::Ip(socket) => addresses.push(socket.to_string()),
+                _ => {}
+            }
+        }
+        EndpointAddr {
+            id: *value.id.as_bytes(),
+            relay_url,
+            addresses,
+        }
+    }
+}

package/src/path.rs

@@ -0,0 +1,167 @@
+use iroh::endpoint::LocalTransportAddr;
+use iroh_base::TransportAddr;
+use napi_derive::napi;
+
+/// Flattened headline numbers from `noq::PathStats`.
+#[derive(Debug, Clone)]
+#[napi(object)]
+pub struct PathStatsRecord {
+    pub rtt_ms: i64,
+    pub udp_tx_datagrams: i64,
+    pub udp_tx_bytes: i64,
+    pub udp_rx_datagrams: i64,
+    pub udp_rx_bytes: i64,
+    pub cwnd: i64,
+    pub congestion_events: i64,
+    pub lost_packets: i64,
+    pub lost_bytes: i64,
+    pub current_mtu: u32,
+}
+
+impl From<iroh::endpoint::PathStats> for PathStatsRecord {
+    fn from(s: iroh::endpoint::PathStats) -> Self {
+        Self {
+            rtt_ms: s.rtt.as_millis() as i64,
+            udp_tx_datagrams: s.udp_tx.datagrams as i64,
+            udp_tx_bytes: s.udp_tx.bytes as i64,
+            udp_rx_datagrams: s.udp_rx.datagrams as i64,
+            udp_rx_bytes: s.udp_rx.bytes as i64,
+            cwnd: s.cwnd as i64,
+            congestion_events: s.congestion_events as i64,
+            lost_packets: s.lost_packets as i64,
+            lost_bytes: s.lost_bytes as i64,
+            current_mtu: s.current_mtu as u32,
+        }
+    }
+}
+
+/// A flat snapshot of an open path's state.
+#[derive(Debug, Clone)]
+#[napi(object)]
+pub struct PathSnapshot {
+    pub id: String,
+    pub is_selected: bool,
+    pub remote_addr: String,
+    pub is_ip: bool,
+    pub is_relay: bool,
+    pub rtt_ms: i64,
+    pub stats: PathStatsRecord,
+}
+
+pub(crate) fn transport_addr_to_string(addr: &TransportAddr) -> String {
+    match addr {
+        TransportAddr::Ip(socket) => socket.to_string(),
+        TransportAddr::Relay(url) => url.to_string(),
+        _ => "unknown".to_string(),
+    }
+}
+
+pub(crate) fn local_transport_addr_to_string(addr: &LocalTransportAddr) -> String {
+    match addr {
+        LocalTransportAddr::Ip(Some(ip)) => ip.to_string(),
+        LocalTransportAddr::Ip(None) => "unknown".to_string(),
+        LocalTransportAddr::Relay(url) => url.to_string(),
+        LocalTransportAddr::Custom(Some(c)) => format!("{c:?}"),
+        _ => "unknown".to_string(),
+    }
+}
+
+/// An event from `Connection::watchPathEvents`.
+#[derive(Debug, Clone)]
+#[napi(string_enum)]
+pub enum PathEventKind {
+    Opened,
+    Closed,
+    Selected,
+    Lagged,
+}
+
+/// A path event with its associated data.
+#[derive(Debug, Clone)]
+#[napi(object)]
+pub struct PathEvent {
+    pub kind: PathEventKind,
+    pub id: Option<String>,
+    pub remote_addr: Option<String>,
+    pub local_addr: Option<String>,
+    pub last_stats: Option<PathStatsRecord>,
+    pub missed: Option<i64>,
+}
+
+impl From<iroh::endpoint::PathEvent> for PathEvent {
+    fn from(e: iroh::endpoint::PathEvent) -> Self {
+        match e {
+            iroh::endpoint::PathEvent::Opened {
+                id,
+                remote_addr,
+                local_addr,
+                ..
+            } => PathEvent {
+                kind: PathEventKind::Opened,
+                id: Some(id.to_string()),
+                remote_addr: Some(transport_addr_to_string(&remote_addr)),
+                local_addr: Some(local_transport_addr_to_string(&local_addr)),
+                last_stats: None,
+                missed: None,
+            },
+            iroh::endpoint::PathEvent::Closed {
+                id,
+                remote_addr,
+                local_addr,
+                last_stats,
+                ..
+            } => PathEvent {
+                kind: PathEventKind::Closed,
+                id: Some(id.to_string()),
+                remote_addr: Some(transport_addr_to_string(&remote_addr)),
+                local_addr: Some(local_transport_addr_to_string(&local_addr)),
+                last_stats: Some((*last_stats).into()),
+                missed: None,
+            },
+            iroh::endpoint::PathEvent::Selected {
+                id,
+                remote_addr,
+                local_addr,
+                ..
+            } => PathEvent {
+                kind: PathEventKind::Selected,
+                id: Some(id.to_string()),
+                remote_addr: Some(transport_addr_to_string(&remote_addr)),
+                local_addr: Some(local_transport_addr_to_string(&local_addr)),
+                last_stats: None,
+                missed: None,
+            },
+            iroh::endpoint::PathEvent::Lagged { missed, .. } => PathEvent {
+                kind: PathEventKind::Lagged,
+                id: None,
+                remote_addr: None,
+                local_addr: None,
+                last_stats: None,
+                missed: Some(missed as i64),
+            },
+            _ => PathEvent {
+                kind: PathEventKind::Lagged,
+                id: None,
+                remote_addr: None,
+                local_addr: None,
+                last_stats: None,
+                missed: Some(0),
+            },
+        }
+    }
+}
+
+pub(crate) fn snapshot_paths(conn: &iroh::endpoint::Connection) -> Vec<PathSnapshot> {
+    conn.paths()
+        .iter()
+        .map(|p| PathSnapshot {
+            id: p.id().to_string(),
+            is_selected: p.is_selected(),
+            remote_addr: transport_addr_to_string(p.remote_addr()),
+            is_ip: p.is_ip(),
+            is_relay: p.is_relay(),
+            rtt_ms: p.rtt().as_millis() as i64,
+            stats: p.stats().into(),
+        })
+        .collect()
+}

package/src/relay.rs

@@ -0,0 +1,194 @@
+use std::{str::FromStr, sync::Arc};
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+/// Config for a single relay server.
+#[derive(Debug, Clone)]
+#[napi(object)]
+pub struct RelayConfig {
+    pub url: String,
+    pub quic_port: Option<u16>,
+    pub auth_token: Option<String>,
+}
+
+impl TryFrom<RelayConfig> for iroh::RelayConfig {
+    type Error = anyhow::Error;
+
+    fn try_from(value: RelayConfig) -> anyhow::Result<Self> {
+        let url = iroh::RelayUrl::from_str(&value.url)?;
+        let quic = value.quic_port.map(iroh_relay::RelayQuicConfig::new);
+        let mut config = iroh::RelayConfig::new(url, quic);
+        if let Some(token) = value.auth_token {
+            config = config.with_auth_token(token);
+        }
+        Ok(config)
+    }
+}
+
+impl From<&iroh::RelayConfig> for RelayConfig {
+    fn from(value: &iroh::RelayConfig) -> Self {
+        Self {
+            url: value.url.to_string(),
+            quic_port: value.quic.as_ref().map(|q| q.port),
+            auth_token: value.auth_token.clone(),
+        }
+    }
+}
+
+/// A collection of relay servers an endpoint should consider.
+#[derive(Debug, Clone)]
+#[napi]
+pub struct RelayMap(pub(crate) iroh::RelayMap);
+
+impl From<iroh::RelayMap> for RelayMap {
+    fn from(map: iroh::RelayMap) -> Self {
+        Self(map)
+    }
+}
+
+#[napi]
+impl RelayMap {
+    /// Create an empty relay map.
+    #[napi(factory)]
+    pub fn empty() -> Self {
+        Self(iroh::RelayMap::empty())
+    }
+
+    /// Build a relay map from a list of relay URLs.
+    #[napi(factory)]
+    pub fn from_urls(urls: Vec<String>) -> Result<Self> {
+        let map = iroh::RelayMap::try_from_iter(urls.iter().map(|s| s.as_str()))
+            .map_err(anyhow::Error::from)?;
+        Ok(Self(map))
+    }
+
+    /// Insert a relay (replacing any prior entry for the same URL).
+    #[napi]
+    pub fn insert(&self, config: RelayConfig) -> Result<()> {
+        let config: iroh::RelayConfig = config.try_into()?;
+        let url = config.url.clone();
+        self.0.insert(url, Arc::new(config));
+        Ok(())
+    }
+
+    /// Remove the entry for the given relay URL. Returns true if removed.
+    #[napi]
+    pub fn remove(&self, url: String) -> Result<bool> {
+        let url = iroh::RelayUrl::from_str(&url).map_err(anyhow::Error::from)?;
+        Ok(self.0.remove(&url).is_some())
+    }
+
+    /// Check whether the given relay URL is in the map.
+    #[napi]
+    pub fn contains(&self, url: String) -> Result<bool> {
+        let url = iroh::RelayUrl::from_str(&url).map_err(anyhow::Error::from)?;
+        Ok(self.0.contains(&url))
+    }
+
+    /// Look up the configuration for the given relay URL.
+    #[napi]
+    pub fn get(&self, url: String) -> Result<Option<RelayConfig>> {
+        let url = iroh::RelayUrl::from_str(&url).map_err(anyhow::Error::from)?;
+        Ok(self.0.get(&url).map(|c| (c.as_ref()).into()))
+    }
+
+    /// All relay URLs currently in the map.
+    #[napi]
+    pub fn urls(&self) -> Vec<String> {
+        self.0
+            .urls::<Vec<_>>()
+            .into_iter()
+            .map(|u| u.to_string())
+            .collect()
+    }
+
+    /// Number of relays in the map.
+    #[napi]
+    pub fn len(&self) -> u32 {
+        self.0.len() as _
+    }
+
+    /// True if the map has no relays.
+    #[napi]
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Clean string representation.
+    #[napi]
+    pub fn to_string(&self) -> String {
+        let urls: Vec<String> = self
+            .0
+            .urls::<Vec<_>>()
+            .into_iter()
+            .map(|u| u.to_string())
+            .collect();
+        format!("RelayMap([{}])", urls.join(", "))
+    }
+}
+
+/// Configuration for which relay servers an endpoint uses.
+#[derive(Debug, Clone)]
+#[napi]
+pub struct RelayMode(pub(crate) iroh::RelayMode);
+
+impl From<iroh::RelayMode> for RelayMode {
+    fn from(mode: iroh::RelayMode) -> Self {
+        Self(mode)
+    }
+}
+
+#[napi]
+impl RelayMode {
+    /// No relays.
+    #[napi(factory)]
+    pub fn disabled() -> Self {
+        Self(iroh::RelayMode::Disabled)
+    }
+
+    /// Use the n0 production relay map.
+    #[napi(factory)]
+    pub fn default_mode() -> Self {
+        Self(iroh::RelayMode::Default)
+    }
+
+    /// Use the n0 staging relay map.
+    #[napi(factory)]
+    pub fn staging() -> Self {
+        Self(iroh::RelayMode::Staging)
+    }
+
+    /// Use a custom relay map.
+    #[napi(factory)]
+    pub fn custom(map: &RelayMap) -> Self {
+        Self(iroh::RelayMode::Custom(map.0.clone()))
+    }
+
+    /// Build a custom relay mode from a list of relay URLs.
+    #[napi(factory)]
+    pub fn custom_from_urls(urls: Vec<String>) -> Result<Self> {
+        let urls: Vec<iroh::RelayUrl> = urls
+            .into_iter()
+            .map(|s| iroh::RelayUrl::from_str(&s).map_err(anyhow::Error::from))
+            .collect::<anyhow::Result<Vec<_>>>()?;
+        Ok(Self(iroh::RelayMode::custom(urls)))
+    }
+
+    /// The relay map this mode resolves to.
+    #[napi]
+    pub fn relay_map(&self) -> RelayMap {
+        self.0.relay_map().into()
+    }
+
+    /// Clean string representation.
+    #[napi]
+    pub fn to_string(&self) -> String {
+        match &self.0 {
+            iroh::RelayMode::Disabled => "disabled".to_string(),
+            iroh::RelayMode::Default => "default".to_string(),
+            iroh::RelayMode::Staging => "staging".to_string(),
+            iroh::RelayMode::Custom(map) => format!("custom({} relays)", map.len()),
+        }
+    }
+}