(feat): rename example-usage to just example

(feat): add the example's web-client dist folder to a gitignore
(fix): format issues
(fix): a lot of duplicate code

example-usage/server/src/main.rs

@@ -1,125 +0,0 @@
-mod clients;
-mod handlers;
-mod keys;
-mod tls;
-
-use mtp::host::{HostConfig, MTPHost};
-use mtp::type_map::TypeMap;
-use std::path::Path;
-
-fn dev_cert_paths() -> (String, String) {
-    let cert = std::env::var("MTP_DEV_CERT").unwrap_or_else(|_| {
-        if Path::new("example-usage/dev-cert/cert.pem").exists() {
-            "example-usage/dev-cert/cert.pem".to_string()
-        } else {
-            "dev-cert/cert.pem".to_string()
-        }
-    });
-    let key = std::env::var("MTP_DEV_KEY").unwrap_or_else(|_| {
-        if Path::new("example-usage/dev-cert/key.pem").exists() {
-            "example-usage/dev-cert/key.pem".to_string()
-        } else {
-            "dev-cert/key.pem".to_string()
-        }
-    });
-    (cert, key)
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (cert_path, key_path) = dev_cert_paths();
-    let (cert_pem, key_pem) = tls::load_or_generate_tls(&cert_path, &key_path)?;
-    let cert_hash = tls::certificate_sha256_hex(&cert_pem)?;
-    tls::export_webtransport_cert_hash(&cert_hash)?;
-    println!("WebTransport certificate sha256: {cert_hash}");
-
-    let (host_id, host_keyring) = keys::load_or_generate_host_keys("host_keys.json")?;
-    keys::export_host_public_keys(&host_keyring)?;
-
-    // The keyring is moved into the host config; keep a copy for decrypting the
-    // demo payloads clients encrypt to our KEM public key.
-    let decrypt_keyring = mtp::crypto::Keyring::from_bytes(&host_keyring.to_bytes())
-        .expect("re-load host keyring for decryption");
-
-    let (clients, next_id) = clients::load_client_db("clients.json")?;
-
-    let clients_for_get = clients.clone();
-    let get_existing_user = Box::new(move |id: u64| -> Option<mtp::crypto::PublicKeyBundle> {
-        let result = clients_for_get.lock().unwrap().get(&id).cloned();
-        if result.is_some() {
-            println!("Auth lookup: client ID {id} found");
-        } else {
-            eprintln!("Auth lookup: unknown client ID {id}");
-        }
-        result
-    });
-
-    let clients_for_register = clients.clone();
-    let next_id_for_register = next_id.clone();
-    let clients_path = "clients.json".to_string();
-    let complete_register = Box::new(move |bundle: mtp::crypto::PublicKeyBundle| -> u64 {
-        let mut db = clients_for_register.lock().unwrap();
-        let mut nid = next_id_for_register.lock().unwrap();
-        let id = *nid;
-        *nid += 1;
-        db.insert(id, bundle);
-        match serde_json::to_string_pretty(&*db) {
-            Ok(json) => match std::fs::write(&clients_path, json) {
-                Ok(()) => {}
-                Err(e) => eprintln!("Failed to persist client database to {clients_path}: {e}"),
-            },
-            Err(e) => eprintln!("Failed to serialize client database after registering {id}: {e}"),
-        }
-        println!("Registered new client with ID: {}", id);
-        id
-    });
-
-    println!("Starting MTP server on port 8080 ...");
-
-    let config = HostConfig {
-        ip: std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED),
-        port: 8080,
-        tls_fullchain: cert_pem,
-        tls_key: key_pem,
-        require_authentication: true,
-        host_id,
-        host_keyring,
-        get_existing_user,
-        complete_register,
-    };
-
-    let mut host = MTPHost::new(config).await?;
-    println!("Server listening on {}", host.local_addr());
-
-    while let Some(conn) = host.accept().await {
-        println!(
-            "\n--- New authenticated connection (version {}) ---",
-            conn.version
-        );
-        println!("Client ID: {}", conn.client_id);
-
-        let tm: &TypeMap = conn.codec.registry().get(&conn.version).unwrap();
-
-        match conn.receiver.receive().await {
-            Ok(msg) => {
-                println!("Received: {msg}");
-                let response = handlers::process_and_respond(
-                    &msg,
-                    tm,
-                    conn.client_public_key.as_ref(),
-                    &decrypt_keyring,
-                );
-                println!("Sending: {response}");
-                conn.sender.send(&response).await?;
-            }
-            Err(e) => {
-                eprintln!("Receive error: {e}");
-            }
-        }
-
-        conn.sender.close();
-        println!("Connection closed\n");
-    }
-
-    Ok(())
-}