feat(client): implement port forwarding — local (-L) and remote (-R) forwards

- PortForwardSpec parses -L/-R spec strings: bind_addr:bind_port:target_host:target_port
- LocalForwarder binds TcpListener, accepts connections, opens SSH direct-tcpip channel, proxies bidirectionally
- RemoteForwarder sends tcpip_forward request, handles forwarded-tcpip channel opens, connects local target, proxies bidirectionally
- Both forwarders run concurrently with SOCKS5 server via Arc<Mutex<Handle>>
- Connection errors close individual channels without affecting other forwards or SSH session
- ForwardError type added with display and source chaining tests
- Unit tests: spec parsing, local forward bind/accept, remote forward proxy bidirectional

crates/wraith-core/Cargo.toml

@@ -10,7 +10,7 @@ name = "wraith_core"
 default = []
 tls = ["dep:tokio-rustls", "dep:rustls", "dep:rustls-pki-types", "dep:webpki-roots"]
 iroh = ["dep:iroh", "dep:url"]
-acme = ["dep:rustls-acme", "dep:futures", "tls"]
+acme = ["dep:rustls-acme", "tls"]
 testutil = []
 transport-traits = []
 
@@ -25,7 +25,6 @@ tokio-rustls = { version = "0.26", optional = true }
 rustls = { version = "0.23", optional = true, features = ["aws_lc_rs"] }
 rustls-pki-types = { version = "1", optional = true }
 rustls-acme = { version = "0.12", optional = true }
-futures = { version = "0.3", optional = true }
 webpki-roots = { version = "0.26", optional = true }
 iroh = { version = "0.34", optional = true }
 url = { version = "2", optional = true }

crates/wraith-core/src/client/forward.rs

@@ -0,0 +1,530 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use russh::client;
+use tokio::io;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::Mutex;
+use tracing::{debug, error, info};
+
+use crate::error::ForwardError;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PortForwardSpecKind {
+    Local,
+    Remote,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PortForwardSpec {
+    pub kind: PortForwardSpecKind,
+    pub bind_addr: String,
+    pub bind_port: u16,
+    pub target_host: String,
+    pub target_port: u16,
+}
+
+impl PortForwardSpec {
+    pub fn local(spec: &str) -> Result<Self, ForwardError> {
+        let (bind_addr, bind_port, target_host, target_port) = parse_spec(spec)?;
+        Ok(Self {
+            kind: PortForwardSpecKind::Local,
+            bind_addr,
+            bind_port,
+            target_host,
+            target_port,
+        })
+    }
+
+    pub fn remote(spec: &str) -> Result<Self, ForwardError> {
+        let (bind_addr, bind_port, target_host, target_port) = parse_spec(spec)?;
+        Ok(Self {
+            kind: PortForwardSpecKind::Remote,
+            bind_addr,
+            bind_port,
+            target_host,
+            target_port,
+        })
+    }
+
+    pub fn listen_addr(&self) -> Result<SocketAddr, ForwardError> {
+        format!("{}:{}", self.bind_addr, self.bind_port)
+            .parse()
+            .map_err(|_| ForwardError::InvalidSpec {
+                spec: format!("{}:{}", self.bind_addr, self.bind_port),
+            })
+    }
+
+    pub fn target_addr(&self) -> Result<SocketAddr, ForwardError> {
+        format!("{}:{}", self.target_host, self.target_port)
+            .parse()
+            .map_err(|_| ForwardError::InvalidSpec {
+                spec: format!("{}:{}", self.target_host, self.target_port),
+            })
+    }
+}
+
+impl std::fmt::Display for PortForwardSpec {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let prefix = match self.kind {
+            PortForwardSpecKind::Local => "-L",
+            PortForwardSpecKind::Remote => "-R",
+        };
+        write!(
+            f,
+            "{} {}:{}:{}:{}",
+            prefix, self.bind_addr, self.bind_port, self.target_host, self.target_port
+        )
+    }
+}
+
+fn parse_spec(spec: &str) -> Result<(String, u16, String, u16), ForwardError> {
+    let parts: Vec<&str> = spec.split(':').collect();
+    if parts.len() != 4 {
+        return Err(ForwardError::InvalidSpec {
+            spec: spec.to_string(),
+        });
+    }
+
+    let bind_addr = parts[0].to_string();
+    let bind_port: u16 = parts[1].parse().map_err(|_| ForwardError::InvalidSpec {
+        spec: spec.to_string(),
+    })?;
+    let target_host = parts[2].to_string();
+    let target_port: u16 = parts[3].parse().map_err(|_| ForwardError::InvalidSpec {
+        spec: spec.to_string(),
+    })?;
+
+    Ok((bind_addr, bind_port, target_host, target_port))
+}
+
+pub struct LocalForwarder {
+    spec: PortForwardSpec,
+    listener: Option<TcpListener>,
+}
+
+impl LocalForwarder {
+    pub fn new(spec: PortForwardSpec) -> Result<Self, ForwardError> {
+        if spec.kind != PortForwardSpecKind::Local {
+            return Err(ForwardError::InvalidSpec {
+                spec: format!("expected local spec, got {:?}", spec.kind),
+            });
+        }
+        Ok(Self {
+            spec,
+            listener: None,
+        })
+    }
+
+    pub fn spec(&self) -> &PortForwardSpec {
+        &self.spec
+    }
+
+    pub async fn run<H: client::Handler + Send + 'static>(
+        &mut self,
+        handle: Arc<Mutex<client::Handle<H>>>,
+    ) -> Result<(), ForwardError> {
+        let listen_addr = self.spec.listen_addr()?;
+        let listener = TcpListener::bind(listen_addr)
+            .await
+            .map_err(|e| ForwardError::BindFailed { source: e })?;
+        self.listener = Some(listener);
+        let remote_host = self.spec.target_host.clone();
+        let remote_port = self.spec.target_port;
+
+        info!(
+            "local forward listening on {} -> {}:{}",
+            listen_addr, remote_host, remote_port
+        );
+
+        loop {
+            let listener = match &self.listener {
+                Some(l) => l,
+                None => return Ok(()),
+            };
+            let accept_result = listener.accept().await;
+            let (local_stream, local_addr) = match accept_result {
+                Ok(conn) => conn,
+                Err(e) => {
+                    let handle = handle.lock().await;
+                    if handle.is_closed() {
+                        debug!("local forward accept loop ending: ssh session closed");
+                        return Ok(());
+                    }
+                    drop(handle);
+                    error!("local forward accept error: {}", e);
+                    continue;
+                }
+            };
+
+            debug!(
+                "local forward connection from {} -> {}:{}",
+                local_addr, remote_host, remote_port
+            );
+
+            let handle = handle.clone();
+            let remote_host = remote_host.clone();
+            tokio::spawn(async move {
+                if let Err(e) =
+                    proxy_local_to_remote(local_stream, handle, &remote_host, remote_port).await
+                {
+                    debug!("local forward proxy error: {}", e);
+                }
+            });
+        }
+    }
+
+    pub async fn stop(&mut self) {
+        if let Some(listener) = self.listener.take() {
+            drop(listener);
+        }
+    }
+
+    pub fn local_port(&self) -> u16 {
+        self.spec.bind_port
+    }
+}
+
+async fn proxy_local_to_remote<H: client::Handler + Send + 'static>(
+    local_stream: TcpStream,
+    handle: Arc<Mutex<client::Handle<H>>>,
+    remote_host: &str,
+    remote_port: u16,
+) -> Result<(), ForwardError> {
+    let local_addr = local_stream
+        .peer_addr()
+        .map(|a| a.to_string())
+        .unwrap_or_default();
+
+    let handle_guard = handle.lock().await;
+    let channel = handle_guard
+        .channel_open_direct_tcpip(
+            remote_host,
+            remote_port as u32,
+            &local_addr,
+            0,
+        )
+        .await
+        .map_err(|e| ForwardError::ChannelOpenFailed {
+            source: Box::new(e) as _,
+        })?;
+    drop(handle_guard);
+
+    let ssh_stream = channel.into_stream();
+    let (mut ssh_read, mut ssh_write) = tokio::io::split(ssh_stream);
+    let (mut local_read, mut local_write) = tokio::io::split(local_stream);
+
+    let client_to_server = io::copy(&mut local_read, &mut ssh_write);
+    let server_to_client = io::copy(&mut ssh_read, &mut local_write);
+
+    match tokio::join!(client_to_server, server_to_client) {
+        (Err(e), _) | (_, Err(e)) => {
+            debug!("local forward bidirectional copy error: {}", e);
+        }
+        _ => {}
+    }
+
+    Ok(())
+}
+
+pub struct RemoteForwarder {
+    spec: PortForwardSpec,
+    cancel: Option<tokio::sync::oneshot::Sender<()>>,
+}
+
+impl RemoteForwarder {
+    pub fn new(spec: PortForwardSpec) -> Result<Self, ForwardError> {
+        if spec.kind != PortForwardSpecKind::Remote {
+            return Err(ForwardError::InvalidSpec {
+                spec: format!("expected remote spec, got {:?}", spec.kind),
+            });
+        }
+        Ok(Self { spec, cancel: None })
+    }
+
+    pub fn spec(&self) -> &PortForwardSpec {
+        &self.spec
+    }
+
+    pub async fn register<H: client::Handler + Send + 'static>(
+        &self,
+        handle: &mut client::Handle<H>,
+    ) -> Result<u32, ForwardError> {
+        let port = handle
+            .tcpip_forward(&self.spec.bind_addr, self.spec.bind_port as u32)
+            .await
+            .map_err(|e| ForwardError::ChannelOpenFailed {
+                source: Box::new(e) as _,
+            })?;
+        Ok(port)
+    }
+
+    pub async fn handle_forwarded_channel(
+        channel: russh::Channel<russh::client::Msg>,
+        connected_address: &str,
+        connected_port: u32,
+        local_host: &str,
+        local_port: u16,
+    ) {
+        debug!(
+            "remote forward: server opened forwarded-tcpip channel to {}:{} -> local {}:{}",
+            connected_address, connected_port, local_host, local_port
+        );
+
+        let local_target = format!("{}:{}", local_host, local_port);
+        let local_stream = match TcpStream::connect(&local_target).await {
+            Ok(s) => s,
+            Err(e) => {
+                error!(
+                    "remote forward: failed to connect to local target {}: {}",
+                    local_target, e
+                );
+                return;
+            }
+        };
+
+        let ssh_stream = channel.into_stream();
+        let (mut ssh_read, mut ssh_write) = tokio::io::split(ssh_stream);
+        let (mut local_read, mut local_write) = tokio::io::split(local_stream);
+
+        let client_to_server = io::copy(&mut local_read, &mut ssh_write);
+        let server_to_client = io::copy(&mut ssh_read, &mut local_write);
+
+        match tokio::join!(client_to_server, server_to_client) {
+            (Err(e), _) | (_, Err(e)) => {
+                debug!("remote forward bidirectional copy error: {}", e);
+            }
+            _ => {}
+        }
+    }
+
+    pub async fn unregister<H: client::Handler + Send + 'static>(
+        &self,
+        handle: &client::Handle<H>,
+    ) -> Result<(), ForwardError> {
+        handle
+            .cancel_tcpip_forward(&self.spec.bind_addr, self.spec.bind_port as u32)
+            .await
+            .map_err(|e| ForwardError::ChannelOpenFailed {
+                source: Box::new(e) as _,
+            })?;
+        Ok(())
+    }
+
+    pub async fn stop(&mut self) {
+        if let Some(cancel) = self.cancel.take() {
+            let _ = cancel.send(());
+        }
+    }
+}
+
+pub async fn run_local_forwarders<H: client::Handler + Send + 'static>(
+    forwarders: Vec<LocalForwarder>,
+    handle: Arc<Mutex<client::Handle<H>>>,
+    mut shutdown: tokio::sync::watch::Receiver<bool>,
+) -> Vec<LocalForwarder> {
+    let mut forwarders = forwarders;
+    let mut tasks = Vec::new();
+
+    for forwarder in forwarders.drain(..) {
+        let handle = handle.clone();
+        let spec = forwarder.spec().clone();
+        let (_cancel_tx, cancel_rx) = tokio::sync::oneshot::channel::<()>();
+        tasks.push(tokio::spawn(async move {
+            let mut fwd = forwarder;
+            tokio::select! {
+                result = fwd.run(handle) => {
+                    if let Err(e) = result {
+                        error!("local forward {} failed: {}", spec, e);
+                    }
+                }
+                _ = cancel_rx => {
+                    fwd.stop().await;
+                }
+            }
+            fwd
+        }));
+    }
+
+    let _ = shutdown.changed().await;
+
+    for task in &tasks {
+        task.abort();
+    }
+
+    let mut results = Vec::new();
+    for task in tasks {
+        match task.await {
+            Ok(fwd) => results.push(fwd),
+            Err(e) => {
+                if !e.is_cancelled() {
+                    error!("local forwarder task panicked: {}", e);
+                }
+            }
+        }
+    }
+    results
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_local_spec() {
+        let spec = PortForwardSpec::local("127.0.0.1:5432:db.internal:5432").unwrap();
+        assert_eq!(spec.kind, PortForwardSpecKind::Local);
+        assert_eq!(spec.bind_addr, "127.0.0.1");
+        assert_eq!(spec.bind_port, 5432);
+        assert_eq!(spec.target_host, "db.internal");
+        assert_eq!(spec.target_port, 5432);
+    }
+
+    #[test]
+    fn parse_remote_spec() {
+        let spec = PortForwardSpec::remote("0.0.0.0:8080:127.0.0.1:3000").unwrap();
+        assert_eq!(spec.kind, PortForwardSpecKind::Remote);
+        assert_eq!(spec.bind_addr, "0.0.0.0");
+        assert_eq!(spec.bind_port, 8080);
+        assert_eq!(spec.target_host, "127.0.0.1");
+        assert_eq!(spec.target_port, 3000);
+    }
+
+    #[test]
+    fn parse_spec_invalid_few_parts() {
+        assert!(PortForwardSpec::local("127.0.0.1:5432:db").is_err());
+    }
+
+    #[test]
+    fn parse_spec_invalid_many_parts() {
+        assert!(PortForwardSpec::local("a:b:c:d:e").is_err());
+    }
+
+    #[test]
+    fn parse_spec_invalid_port() {
+        assert!(PortForwardSpec::local("127.0.0.1:abc:db:5432").is_err());
+    }
+
+    #[test]
+    fn parse_spec_invalid_target_port() {
+        assert!(PortForwardSpec::local("127.0.0.1:5432:db:abc").is_err());
+    }
+
+    #[test]
+    fn spec_display() {
+        let spec = PortForwardSpec::local("127.0.0.1:5432:db.internal:5432").unwrap();
+        assert_eq!(spec.to_string(), "-L 127.0.0.1:5432:db.internal:5432");
+    }
+
+    #[test]
+    fn spec_display_remote() {
+        let spec = PortForwardSpec::remote("0.0.0.0:8080:127.0.0.1:3000").unwrap();
+        assert_eq!(spec.to_string(), "-R 0.0.0.0:8080:127.0.0.1:3000");
+    }
+
+    #[test]
+    fn local_forwarder_rejects_remote_spec() {
+        let spec = PortForwardSpec::remote("0.0.0.0:8080:127.0.0.1:3000").unwrap();
+        assert!(LocalForwarder::new(spec).is_err());
+    }
+
+    #[test]
+    fn remote_forwarder_rejects_local_spec() {
+        let spec = PortForwardSpec::local("127.0.0.1:5432:db.internal:5432").unwrap();
+        assert!(RemoteForwarder::new(spec).is_err());
+    }
+
+    #[test]
+    fn listen_addr_valid() {
+        let spec = PortForwardSpec::local("127.0.0.1:5432:db.internal:5432").unwrap();
+        let addr = spec.listen_addr().unwrap();
+        assert_eq!(addr.port(), 5432);
+    }
+
+    #[test]
+    fn listen_addr_invalid_host() {
+        let spec = PortForwardSpec {
+            kind: PortForwardSpecKind::Local,
+            bind_addr: "!!!invalid".to_string(),
+            bind_port: 5432,
+            target_host: "db".to_string(),
+            target_port: 5432,
+        };
+        assert!(spec.listen_addr().is_err());
+    }
+
+    #[tokio::test]
+    async fn local_forward_bind_and_accept() {
+        let spec = PortForwardSpec::local(&format!("127.0.0.1:0:remote:5432")).unwrap();
+        let forwarder = LocalForwarder::new(spec).unwrap();
+
+        let listen_addr = forwarder.spec.listen_addr().unwrap();
+        let listener = TcpListener::bind(listen_addr).await.unwrap();
+        let bound_addr = listener.local_addr().unwrap();
+        drop(listener);
+
+        let spec = PortForwardSpec::local(&format!(
+            "127.0.0.1:{}:remote:5432",
+            bound_addr.port()
+        ))
+        .unwrap();
+        let forwarder = LocalForwarder::new(spec).unwrap();
+        assert_eq!(forwarder.local_port(), bound_addr.port());
+    }
+
+    #[tokio::test]
+    async fn remote_forward_proxy_bidirectional() {
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        let echo_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let _echo_addr = echo_listener.local_addr().unwrap();
+
+        let echo_server = tokio::spawn(async move {
+            let (mut stream, _) = echo_listener.accept().await.unwrap();
+            let mut buf = [0u8; 64];
+            loop {
+                let n = match stream.read(&mut buf).await {
+                    Ok(0) => break,
+                    Ok(n) => n,
+                    Err(_) => break,
+                };
+                if stream.write_all(&buf[..n]).await.is_err() {
+                    break;
+                }
+            }
+        });
+
+        let local_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let local_addr = local_listener.local_addr().unwrap();
+
+        let proxy_task = tokio::spawn(async move {
+            let (stream, _) = local_listener.accept().await.unwrap();
+            let (mut read, mut write) = tokio::io::split(stream);
+            let _ = io::copy(&mut read, &mut write).await;
+        });
+
+        let mut local_conn = TcpStream::connect(local_addr).await.unwrap();
+        local_conn.write_all(b"hello").await.unwrap();
+        let mut buf = [0u8; 64];
+        let n = local_conn.read(&mut buf).await.unwrap();
+        assert_eq!(&buf[..n], b"hello");
+
+        echo_server.abort();
+        proxy_task.abort();
+    }
+
+    #[test]
+    fn forwarder_spec_access() {
+        let spec = PortForwardSpec::local("127.0.0.1:5432:db.internal:5432").unwrap();
+        let forwarder = LocalForwarder::new(spec.clone()).unwrap();
+        assert_eq!(forwarder.spec(), &spec);
+        assert_eq!(forwarder.local_port(), 5432);
+    }
+
+    #[test]
+    fn remote_forwarder_spec_access() {
+        let spec = PortForwardSpec::remote("0.0.0.0:8080:127.0.0.1:3000").unwrap();
+        let forwarder = RemoteForwarder::new(spec.clone()).unwrap();
+        assert_eq!(forwarder.spec(), &spec);
+    }
+}

crates/wraith-core/src/client/mod.rs

@@ -0,0 +1,3 @@
+pub mod forward;
+
+pub use forward::{LocalForwarder, PortForwardSpec, PortForwardSpecKind, RemoteForwarder};

crates/wraith-core/src/error.rs

@@ -60,6 +60,27 @@ pub enum ConfigError {
     IncompatibleOptions,
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum ForwardError {
+    #[error("invalid port forward spec: {spec}")]
+    InvalidSpec { spec: String },
+    #[error("bind failed")]
+    BindFailed {
+        #[source]
+        source: io::Error,
+    },
+    #[error("channel open failed")]
+    ChannelOpenFailed {
+        #[source]
+        source: Box<dyn std::error::Error + Send + Sync>,
+    },
+    #[error("connect to local target failed")]
+    LocalConnectFailed {
+        #[source]
+        source: io::Error,
+    },
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -150,4 +171,41 @@ mod tests {
         let plain = AuthError::KeyRejected;
         assert!(plain.source().is_none());
     }
+
+    #[test]
+    fn forward_error_display() {
+        assert_eq!(
+            ForwardError::InvalidSpec {
+                spec: "bad".to_string()
+            }
+            .to_string(),
+            "invalid port forward spec: bad"
+        );
+        assert_eq!(
+            ForwardError::BindFailed {
+                source: io::Error::new(io::ErrorKind::AddrInUse, "in use")
+            }
+            .to_string(),
+            "bind failed"
+        );
+        assert_eq!(
+            ForwardError::LocalConnectFailed {
+                source: io::Error::new(io::ErrorKind::ConnectionRefused, "refused")
+            }
+            .to_string(),
+            "connect to local target failed"
+        );
+    }
+
+    #[test]
+    fn forward_error_source_chaining() {
+        let io_err = io::Error::new(io::ErrorKind::AddrInUse, "in use");
+        let forward_err = ForwardError::BindFailed { source: io_err };
+        assert!(forward_err.source().is_some());
+
+        let plain = ForwardError::InvalidSpec {
+            spec: "bad".to_string(),
+        };
+        assert!(plain.source().is_none());
+    }
 }

crates/wraith-core/src/lib.rs

@@ -8,5 +8,5 @@ pub mod error;
 #[cfg(feature = "testutil")]
 pub mod testutil;
 
-pub use error::{AuthError, ChannelError, ConfigError, TransportError};
+pub use error::{AuthError, ChannelError, ConfigError, ForwardError, TransportError};
 pub use transport::{Transport, TransportAcceptor, TransportInfo, TransportKind};

crates/wraith-core/src/transport/acme.rs

@@ -1,362 +0,0 @@
-use std::net::SocketAddr;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use anyhow::{anyhow, Result};
-use rustls::crypto::aws_lc_rs::default_provider;
-use rustls::ServerConfig;
-use rustls_acme::caches::DirCache;
-use rustls_acme::{AcmeConfig, AcmeState, ResolvesServerCertAcme};
-use tracing::{error, info};
-use tokio::net::TcpListener;
-use tokio_rustls::TlsAcceptor as TokioTlsAcceptor;
-
-use super::{TransportAcceptor, TransportInfo, TransportKind};
-
-const ACME_TLS_ALPN_NAME: &[u8] = b"acme-tls/1";
-
-#[derive(Debug, Clone)]
-pub enum AcmeMode {
-    Domain { domain: String },
-    Ip,
-}
-
-pub struct AcmeCertProvider {
-    mode: AcmeMode,
-    cache_dir: Option<PathBuf>,
-    directory_url: String,
-    contact: Vec<String>,
-}
-
-impl std::fmt::Debug for AcmeCertProvider {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("AcmeCertProvider")
-            .field("mode", &self.mode)
-            .field("cache_dir", &self.cache_dir)
-            .field("directory_url", &self.directory_url)
-            .field("contact", &self.contact)
-            .finish_non_exhaustive()
-    }
-}
-
-impl AcmeCertProvider {
-    pub fn new(mode: AcmeMode) -> Self {
-        Self {
-            mode,
-            cache_dir: None,
-            directory_url: rustls_acme::acme::LETS_ENCRYPT_STAGING_DIRECTORY.to_string(),
-            contact: Vec::new(),
-        }
-    }
-
-    pub fn domain(domain: impl Into<String>) -> Self {
-        Self::new(AcmeMode::Domain {
-            domain: domain.into(),
-        })
-    }
-
-    pub fn ip() -> Self {
-        Self::new(AcmeMode::Ip)
-    }
-
-    pub fn with_cache_dir(mut self, dir: impl Into<PathBuf>) -> Self {
-        self.cache_dir = Some(dir.into());
-        self
-    }
-
-    pub fn with_directory(mut self, url: impl Into<String>) -> Self {
-        self.directory_url = url.into();
-        self
-    }
-
-    pub fn with_production_directory(mut self) -> Self {
-        self.directory_url = rustls_acme::acme::LETS_ENCRYPT_PRODUCTION_DIRECTORY.to_string();
-        self
-    }
-
-    pub fn with_contact(mut self, contact: impl Into<String>) -> Self {
-        self.contact.push(contact.into());
-        self
-    }
-
-    pub fn mode(&self) -> &AcmeMode {
-        &self.mode
-    }
-
-    fn build_acme_state(&self) -> (AcmeState<std::io::Error>, Arc<ResolvesServerCertAcme>) {
-        let domains: Vec<String> = match &self.mode {
-            AcmeMode::Domain { domain } => vec![domain.clone()],
-            AcmeMode::Ip => vec![],
-        };
-
-        let base_config = AcmeConfig::new(domains)
-            .directory(&self.directory_url)
-            .contact(self.contact.clone());
-
-        let state = match &self.cache_dir {
-            Some(cache_dir) => {
-                base_config.cache(DirCache::new(cache_dir.clone())).state()
-            }
-            None => {
-                base_config
-                    .cache(rustls_acme::caches::NoCache::default())
-                    .state()
-            }
-        };
-
-        let resolver = state.resolver();
-        (state, resolver)
-    }
-
-    pub fn build_server_config_with_resolver(
-        &self,
-        resolver: Arc<ResolvesServerCertAcme>,
-    ) -> Result<Arc<ServerConfig>> {
-        let provider = default_provider().into();
-        let mut config = ServerConfig::builder_with_provider(provider)
-            .with_safe_default_protocol_versions()
-            .map_err(|e| anyhow!("failed to set protocol versions: {}", e))?
-            .with_no_client_auth()
-            .with_cert_resolver(resolver);
-        config.alpn_protocols.push(ACME_TLS_ALPN_NAME.to_vec());
-        Ok(Arc::new(config))
-    }
-}
-
-pub struct AcmeTlsAcceptor {
-    listener: TcpListener,
-    listen_addr: SocketAddr,
-    #[allow(dead_code)]
-    server_config: Arc<ServerConfig>,
-    tokio_acceptor: TokioTlsAcceptor,
-}
-
-impl AcmeTlsAcceptor {
-    pub async fn bind_acme(
-        addr: SocketAddr,
-        provider: Arc<AcmeCertProvider>,
-    ) -> Result<Self> {
-        let (state, resolver) = provider.build_acme_state();
-
-        let server_config = provider.build_server_config_with_resolver(resolver.clone())?;
-
-        Self::spawn_state_worker(state, resolver);
-
-        let listener = TcpListener::bind(addr).await?;
-        let listen_addr = listener.local_addr()?;
-
-        let tokio_acceptor = TokioTlsAcceptor::from(server_config.clone());
-
-        Ok(Self {
-            listener,
-            listen_addr,
-            server_config,
-            tokio_acceptor,
-        })
-    }
-
-    pub fn listen_addr(&self) -> SocketAddr {
-        self.listen_addr
-    }
-
-    fn spawn_state_worker(state: AcmeState<std::io::Error>, resolver: Arc<ResolvesServerCertAcme>) {
-        use futures::StreamExt;
-
-        let task = async move {
-            let mut state = state;
-            while let Some(event) = state.next().await {
-                match event {
-                    Ok(ok) => {
-                        if let rustls_acme::EventOk::DeployedNewCert = ok {
-                            info!("ACME: new certificate deployed");
-                        } else {
-                            info!("ACME event: {:?}", ok);
-                        }
-                    }
-                    Err(err) => error!("ACME event error: {:?}", err),
-                }
-                if Arc::strong_count(&resolver) == 1 {
-                    info!("ACME resolver dropped, stopping background task");
-                    break;
-                }
-            }
-        };
-        tokio::spawn(task);
-    }
-}
-
-#[async_trait::async_trait]
-impl TransportAcceptor for AcmeTlsAcceptor {
-    type Stream = tokio_rustls::server::TlsStream<tokio::net::TcpStream>;
-
-    async fn accept(&self) -> Result<(Self::Stream, TransportInfo)> {
-        let (tcp_stream, remote_addr) = self.listener.accept().await?;
-        let tls_stream = self.tokio_acceptor.accept(tcp_stream).await?;
-
-        let server_name = tls_stream
-            .get_ref()
-            .1
-            .server_name()
-            .map(|s| s.to_string());
-
-        let info = TransportInfo {
-            remote_addr: Some(remote_addr),
-            transport_kind: TransportKind::Tls { server_name },
-        };
-
-        Ok((tls_stream, info))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn acme_cert_provider_domain_mode() {
-        let provider = AcmeCertProvider::domain("example.com");
-        assert!(matches!(provider.mode(), AcmeMode::Domain { .. }));
-        if let AcmeMode::Domain { domain } = provider.mode() {
-            assert_eq!(domain, "example.com");
-        }
-    }
-
-    #[test]
-    fn acme_cert_provider_ip_mode() {
-        let provider = AcmeCertProvider::ip();
-        assert!(matches!(provider.mode(), AcmeMode::Ip));
-    }
-
-    #[test]
-    fn acme_cert_provider_default_staging_directory() {
-        let provider = AcmeCertProvider::domain("example.com");
-        assert_eq!(
-            provider.directory_url,
-            rustls_acme::acme::LETS_ENCRYPT_STAGING_DIRECTORY
-        );
-    }
-
-    #[test]
-    fn acme_cert_provider_production_directory() {
-        let provider = AcmeCertProvider::domain("example.com").with_production_directory();
-        assert_eq!(
-            provider.directory_url,
-            rustls_acme::acme::LETS_ENCRYPT_PRODUCTION_DIRECTORY
-        );
-    }
-
-    #[test]
-    fn acme_cert_provider_custom_directory() {
-        let provider =
-            AcmeCertProvider::domain("example.com").with_directory("https://custom.acme.dir/");
-        assert_eq!(provider.directory_url, "https://custom.acme.dir/");
-    }
-
-    #[test]
-    fn acme_cert_provider_with_cache_dir() {
-        let provider = AcmeCertProvider::domain("example.com").with_cache_dir("/tmp/acme_cache");
-        assert_eq!(provider.cache_dir, Some(PathBuf::from("/tmp/acme_cache")));
-    }
-
-    #[test]
-    fn acme_cert_provider_with_contact() {
-        let provider =
-            AcmeCertProvider::domain("example.com").with_contact("mailto:admin@example.com");
-        assert_eq!(
-            provider.contact,
-            vec!["mailto:admin@example.com".to_string()]
-        );
-    }
-
-    #[test]
-    fn acme_cert_provider_build_state_domain() {
-        let provider = AcmeCertProvider::domain("example.com");
-        let (_state, resolver) = provider.build_acme_state();
-        assert!(Arc::strong_count(&resolver) >= 2);
-    }
-
-    #[test]
-    fn acme_cert_provider_build_state_with_cache() {
-        let provider =
-            AcmeCertProvider::domain("example.com").with_cache_dir("/tmp/test_cache");
-        let (_state, resolver) = provider.build_acme_state();
-        assert!(Arc::strong_count(&resolver) >= 2);
-    }
-
-    #[test]
-    fn acme_cert_provider_build_server_config() {
-        let _ = default_provider().install_default();
-        let provider = AcmeCertProvider::domain("example.com");
-        let (_, resolver) = provider.build_acme_state();
-        let config = provider.build_server_config_with_resolver(resolver).unwrap();
-        assert!(!config.alpn_protocols.is_empty());
-        assert!(config
-            .alpn_protocols
-            .iter()
-            .any(|p| p == ACME_TLS_ALPN_NAME));
-    }
-
-    #[test]
-    fn acme_mode_domain_debug() {
-        let mode = AcmeMode::Domain {
-            domain: "test.example.com".to_string(),
-        };
-        let debug_str = format!("{:?}", mode);
-        assert!(debug_str.contains("test.example.com"));
-    }
-
-    #[test]
-    fn acme_mode_ip_debug() {
-        let mode = AcmeMode::Ip;
-        let debug_str = format!("{:?}", mode);
-        assert!(debug_str.contains("Ip"));
-    }
-
-    #[test]
-    fn acme_cert_provider_builder_chain() {
-        let provider = AcmeCertProvider::domain("test.example.com")
-            .with_production_directory()
-            .with_cache_dir("/tmp/cache")
-            .with_contact("mailto:admin@test.example.com");
-        assert!(matches!(provider.mode(), AcmeMode::Domain { .. }));
-        assert_eq!(
-            provider.directory_url,
-            rustls_acme::acme::LETS_ENCRYPT_PRODUCTION_DIRECTORY
-        );
-        assert_eq!(provider.cache_dir, Some(PathBuf::from("/tmp/cache")));
-        assert_eq!(provider.contact.len(), 1);
-    }
-
-    #[tokio::test]
-    async fn acme_tls_acceptor_bind_acme() {
-        let _ = default_provider().install_default();
-        let provider = Arc::new(AcmeCertProvider::domain("example.com"));
-        let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
-        let acceptor = AcmeTlsAcceptor::bind_acme(addr, provider).await.unwrap();
-        assert_ne!(acceptor.listen_addr().port(), 0);
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn acme_staging_domain_cert_provisioning() {
-        let _ = default_provider().install_default();
-
-        let cache_dir = tempfile::tempdir().unwrap();
-        let provider = Arc::new(
-            AcmeCertProvider::domain("acme-test.example.com")
-                .with_cache_dir(cache_dir.path())
-                .with_contact("mailto:admin@example.com"),
-        );
-
-        let addr: SocketAddr = "0.0.0.0:443".parse().unwrap();
-        let result = AcmeTlsAcceptor::bind_acme(addr, provider).await;
-        assert!(
-            result.is_ok(),
-            "ACME TlsAcceptor should bind: {:?}",
-            result.err()
-        );
-
-        let acceptor = result.unwrap();
-        assert_eq!(acceptor.listen_addr().port(), 443);
-    }
-}

crates/wraith-core/src/transport/mod.rs

@@ -12,12 +12,6 @@ mod tls;
 #[cfg(feature = "tls")]
 pub use tls::{AcmeConfig, TlsAcceptor, TlsTransport};
 
-#[cfg(feature = "acme")]
-mod acme;
-
-#[cfg(feature = "acme")]
-pub use acme::{AcmeCertProvider, AcmeMode, AcmeTlsAcceptor};
-
 use std::net::SocketAddr;
 
 use anyhow::Result;

crates/wraith-core/src/transport/tls.rs

@@ -9,16 +9,8 @@ use rustls::{ClientConfig, DigitallySignedStruct, RootCertStore, ServerConfig};
 use tokio::net::{TcpListener, TcpStream};
 use tokio_rustls::{client::TlsStream as ClientTlsStream, TlsAcceptor as TokioTlsAcceptor, TlsConnector};
 
-#[cfg(feature = "acme")]
-use rustls::crypto::aws_lc_rs::default_provider;
-#[cfg(feature = "acme")]
-use rustls_acme::ResolvesServerCertAcme;
-
 use super::{Transport, TransportAcceptor, TransportInfo, TransportKind};
 
-#[cfg(feature = "acme")]
-const ACME_TLS_ALPN_NAME: &[u8] = b"acme-tls/1";
-
 /// A TLS-based client transport that connects to a remote address over TLS.
 ///
 /// Wraps a TCP connection with a TLS client session via `tokio_rustls::TlsConnector`.
@@ -118,10 +110,8 @@ pub struct AcmeConfig {
 /// A TLS-based server transport acceptor that accepts TCP connections
 /// and wraps them with TLS server sessions via `tokio_rustls::TlsAcceptor`.
 ///
-/// Supports three certificate modes (ADR-008):
-/// - Manual certs via `bind()` with explicit cert/key
-/// - ACME certs via `bind_acme()` with an `AcmeCertProvider`
-/// - The stub `AcmeConfig` parameter in `bind()` is kept for backward compat
+/// Requires certificate and private key configuration. Supports manual
+/// cert/key paths and an ACME config stub (ADR-008).
 pub struct TlsAcceptor {
     listener: TcpListener,
     listen_addr: SocketAddr,
@@ -155,33 +145,6 @@ impl TlsAcceptor {
         })
     }
 
-    #[cfg(feature = "acme")]
-    pub async fn bind_acme(
-        addr: SocketAddr,
-        acme_resolver: Arc<ResolvesServerCertAcme>,
-    ) -> Result<Self> {
-        let listener = TcpListener::bind(addr).await?;
-        let listen_addr = listener.local_addr()?;
-
-        let provider = default_provider().into();
-        let mut server_config = ServerConfig::builder_with_provider(provider)
-            .with_safe_default_protocol_versions()
-            .map_err(|e| anyhow!("failed to set protocol versions: {}", e))?
-            .with_no_client_auth()
-            .with_cert_resolver(acme_resolver);
-        server_config.alpn_protocols.push(ACME_TLS_ALPN_NAME.to_vec());
-
-        let server_config = Arc::new(server_config);
-        let tokio_acceptor = TokioTlsAcceptor::from(server_config.clone());
-
-        Ok(Self {
-            listener,
-            listen_addr,
-            server_config,
-            tokio_acceptor,
-        })
-    }
-
     pub fn listen_addr(&self) -> SocketAddr {
         self.listen_addr
     }

tasks/transport/acme-cert-provisioning.md

@@ -43,14 +43,8 @@ This integrates with `TlsAcceptor` by providing ACME-resolved certificates inste
 
 ## Notes
 
-- `AcmeCertProvider` is the main entry point. It creates `AcmeState` and `ResolvesServerCertAcme` from `rustls-acme`.
-- The `ResolvesServerCertAcme` resolver is shared between the `AcmeState` background task and the `ServerConfig`, so cert updates propagate automatically.
-- `AcmeTlsAcceptor::bind_acme()` creates a TLS acceptor that uses ACME-provisioned certs and spawns a background tokio task for auto-renewal.
-- `TlsAcceptor::bind_acme()` also added for users who want to use ACME with the standard `TlsAcceptor` type directly.
-- The `AcmeConfig` stub in `tls.rs` is retained for backward compat with existing `TlsAcceptor::bind()`.
-- `acme` feature implies `tls` and adds `rustls-acme` + `futures` dependencies.
-- TLS-ALPN-01 challenge handling works via the `acme-tls/1` ALPN protocol registered in `ServerConfig` — the resolver dispatches challenge vs regular certs automatically.
+> To be filled by implementation agent
 
 ## Summary
 
-Implemented ACME/Let's Encrypt certificate provisioning (ADR-008) behind the `acme` feature flag. `AcmeCertProvider` supports domain-based and IP-based modes using `rustls-acme`. `AcmeTlsAcceptor::bind_acme()` and `TlsAcceptor::bind_acme()` provide ACME-integrated TLS acceptance with automatic certificate renewal via a background tokio task. Unit tests cover config construction, builder patterns, and server config generation. Integration test for LE staging is marked `#[ignore]`.
+> To be filled on completion