refactor: split linkup_server into modules

linkup-cli/src/commands/server.rs

@@ -5,12 +5,6 @@ use linkup::MemoryStringStore;
 
 #[derive(clap::Args)]
 pub struct Args {
-    #[arg(long)]
-    session_name: String,
-
-    #[arg(long, value_parser, num_args = 1.., value_delimiter = ',')]
-    domains: Vec<String>,
-
     #[arg(long)]
     certs_dir: String,
 }
@@ -19,13 +13,7 @@ pub async fn server(args: &Args) -> Result<()> {
     let config_store = MemoryStringStore::default();
     let https_certs_dir = PathBuf::from(&args.certs_dir);
 
-    linkup_local_server::start(
-        config_store,
-        &https_certs_dir,
-        args.session_name.clone(),
-        args.domains.clone(),
-    )
-    .await;
+    linkup_local_server::start(config_store, &https_certs_dir).await;
 
     Ok(())
 }

linkup-cli/src/services/local_server.rs

@@ -13,9 +13,10 @@ use tokio::time::sleep;
 use url::Url;
 
 use crate::{
-    linkup_certs_dir_path, linkup_file_path,
+    linkup_certs_dir_path, linkup_file_path, services,
     state::{upload_state, State},
-    worker_client, Result,
+    worker_client::{self, WorkerClient},
+    Result,
 };
 
 use super::{BackgroundService, PidError};
@@ -50,7 +51,7 @@ impl LocalServer {
         Url::parse("http://localhost:80").expect("linkup url invalid")
     }
 
-    fn start(&self, session_name: String, domains: Vec<String>) -> Result<()> {
+    fn start(&self) -> Result<()> {
         log::debug!("Starting {}", Self::NAME);
 
         let stdout_file = File::create(&self.stdout_file_path)?;
@@ -66,10 +67,6 @@ impl LocalServer {
         command.env("LINKUP_SERVICE_ID", Self::ID);
         command.args([
             "server",
-            "--session-name",
-            &session_name,
-            "--domains",
-            &domains.join(","),
             "--certs-dir",
             linkup_certs_dir_path().to_str().unwrap(),
         ]);
@@ -132,7 +129,7 @@ impl BackgroundService for LocalServer {
             return Ok(());
         }
 
-        if let Err(e) = self.start(session_name, domains) {
+        if let Err(e) = self.start() {
             self.notify_update_with_details(
                 &status_sender,
                 super::RunStatus::Error,
@@ -171,6 +168,15 @@ impl BackgroundService for LocalServer {
             }
         }
 
+        // TODO(augustoccesar)[2026-03-26]: Maybe send all the domains on one request?
+        for domain in &domains {
+            let full_domain = format!("{session_name}.{domain}");
+
+            WorkerClient::new(&services::LocalServer::url(), "")
+                .create_dns_record(&full_domain)
+                .await?;
+        }
+
         match self.update_state(state).await {
             Ok(_) => {
                 self.notify_update(&status_sender, super::RunStatus::Started);

linkup-cli/src/worker_client.rs

@@ -70,6 +70,21 @@ impl WorkerClient {
         self.post("/linkup/local-session", params).await
     }
 
+    pub async fn create_dns_record(&self, domain: &str) -> Result<(), Error> {
+        #[derive(Serialize)]
+        struct Params {
+            domain: String,
+        }
+
+        let params = Params {
+            domain: domain.to_owned(),
+        };
+
+        self.post("/linkup/dns/records", &params).await?;
+
+        Ok(())
+    }
+
     pub async fn get_tunnel(&self, session_name: &str) -> Result<TunnelData, Error> {
         let query = GetTunnelParams {
             session_name: String::from(session_name),
@@ -101,15 +116,14 @@ impl WorkerClient {
             .send()
             .await?;
 
-        match response.status() {
-            StatusCode::OK => {
-                let content = response.text().await?;
-                Ok(content)
-            }
-            _ => Err(Error::Response(
+        if response.status().is_success() {
+            let content = response.text().await?;
+            Ok(content)
+        } else {
+            Err(Error::Response(
                 response.status(),
                 response.text().await.unwrap_or_else(|_| "".to_string()),
-            )),
+            ))
         }
     }
 }

local-server/Cargo.toml

@@ -10,6 +10,7 @@ path = "src/lib.rs"
 [dependencies]
 axum = { version = "0.8.1", features = ["http2", "json", "ws"] }
 axum-server = { version = "0.8.0", features = ["tls-rustls"] }
+async-trait = "0.1.43"
 http = "1.2.0"
 hickory-server = { version = "0.25.1", features = ["resolver"] }
 hyper = { version = "1.5.2", features = ["server"] }
@@ -22,6 +23,8 @@ futures = "0.3.31"
 linkup = { path = "../linkup" }
 rustls = { version = "0.23.37", default-features = false, features = ["ring"] }
 rustls-native-certs = "0.8.1"
+serde = "1.0.217"
+serde_json = "1.0.137"
 thiserror = "2.0.11"
 tokio = { version = "1.49.0", features = [
     "macros",

local-server/src/dns_server.rs

@@ -0,0 +1,78 @@
+use hickory_server::{
+    authority::Catalog,
+    proto::{rr::Name, xfer::Protocol},
+    resolver::{
+        config::{NameServerConfig, NameServerConfigGroup, ResolverOpts},
+        name_server::TokioConnectionProvider,
+    },
+    server::{RequestHandler, ResponseHandler, ResponseInfo},
+    store::forwarder::{ForwardAuthority, ForwardConfig},
+    ServerFuture,
+};
+use std::sync::Arc;
+use std::{net::SocketAddr, ops::Deref};
+use tokio::{net::UdpSocket, sync::RwLock};
+
+#[derive(Clone)]
+pub struct DnsCatalog(Arc<RwLock<Catalog>>);
+
+impl DnsCatalog {
+    pub fn new() -> Self {
+        Self(Arc::new(RwLock::new(Catalog::new())))
+    }
+}
+
+impl Default for DnsCatalog {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Deref for DnsCatalog {
+    type Target = Arc<RwLock<Catalog>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[async_trait::async_trait]
+impl RequestHandler for DnsCatalog {
+    async fn handle_request<R: ResponseHandler>(
+        &self,
+        request: &hickory_server::server::Request,
+        response_handle: R,
+    ) -> ResponseInfo {
+        let catalog = self.read().await;
+
+        catalog.handle_request(request, response_handle).await
+    }
+}
+
+pub async fn serve(dns_catalog: DnsCatalog) {
+    let cf_name_server = NameServerConfig::new("1.1.1.1:53".parse().unwrap(), Protocol::Udp);
+    let forward_config = ForwardConfig {
+        name_servers: NameServerConfigGroup::from(vec![cf_name_server]),
+        options: Some(ResolverOpts::default()),
+    };
+
+    let forwarder =
+        ForwardAuthority::builder_with_config(forward_config, TokioConnectionProvider::default())
+            .with_origin(Name::root())
+            .build()
+            .unwrap();
+
+    {
+        let mut catalog = dns_catalog.write().await;
+        catalog.upsert(Name::root().into(), vec![Arc::new(forwarder)]);
+    }
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 8053));
+    let sock = UdpSocket::bind(&addr).await.unwrap();
+
+    let mut server = ServerFuture::new(dns_catalog);
+    server.register_socket(sock);
+
+    println!("DNS server listening on {addr}");
+    server.block_until_done().await.unwrap();
+}