maestro/crates/maestro-web/src/main.rs

//! `maestro-web` — local web-UI front-end.

use std::error::Error;
use std::net::SocketAddr;
use std::process::ExitCode;
use std::sync::Arc;

use maestro_web::proxy::UpstreamConfig;
use maestro_web::router;
use tokio::net::TcpListener;
use tracing_subscriber::EnvFilter;

const DEFAULT_BIND_ADDR: &str = "127.0.0.1:8888";

#[tokio::main]
async fn main() -> ExitCode {
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
    tracing_subscriber::fmt().with_env_filter(filter).init();

    match run().await {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            tracing::error!(error = %e, "maestro-web failed");
            eprintln!("maestro-web: {e}");
            ExitCode::FAILURE
        }
    }
}

async fn run() -> Result<(), Box<dyn Error>> {
    let upstream_raw = std::env::var("MAESTRO_REGISTRY")
        .map_err(|_| "MAESTRO_REGISTRY must be set (e.g. https://maestro-registry.example.com)")?;
    // Accept the daemon-facing URL form too (wss://.../daemon) — the proxy
    // wants the base URL.
    let upstream = normalize_upstream(&upstream_raw);
    let upstream = UpstreamConfig::new(&upstream)?;
    let upstream = Arc::new(upstream);

    let bind_raw =
        std::env::var("MAESTRO_WEB_BIND_ADDR").unwrap_or_else(|_| DEFAULT_BIND_ADDR.to_string());
    let bind: SocketAddr = bind_raw
        .parse()
        .map_err(|e| format!("invalid MAESTRO_WEB_BIND_ADDR ({bind_raw:?}): {e}"))?;

    tracing::info!(
        upstream = %upstream.http_base,
        bind = %bind,
        "maestro-web starting"
    );

    let app = router(upstream);
    let listener = TcpListener::bind(bind).await?;
    let bound = listener.local_addr()?;
    tracing::info!(addr = %bound, "listening");

    let shutdown = async {
        let _ = tokio::signal::ctrl_c().await;
        tracing::info!("ctrl-c received — shutting down");
    };

    axum::serve(listener, app)
        .with_graceful_shutdown(shutdown)
        .await?;
    Ok(())
}

/// Turn a daemon-facing URL (`wss://x/daemon`) into the base URL the proxy
/// needs (`https://x`). Bare HTTPS/HTTP URLs pass through with any trailing
/// `/daemon` stripped, so users can paste either form.
fn normalize_upstream(raw: &str) -> String {
    let s = raw
        .strip_prefix("wss://")
        .map(|rest| format!("https://{rest}"))
        .or_else(|| {
            raw.strip_prefix("ws://")
                .map(|rest| format!("http://{rest}"))
        })
        .unwrap_or_else(|| raw.to_string());
    let trimmed = s.trim_end_matches('/');
    let without_daemon = trimmed.strip_suffix("/daemon").unwrap_or(trimmed);
    without_daemon.to_string()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn normalize_strips_ws_scheme_and_daemon_suffix() {
        assert_eq!(
            normalize_upstream("wss://maestro.example.com/daemon"),
            "https://maestro.example.com"
        );
        assert_eq!(
            normalize_upstream("ws://127.0.0.1:8080/daemon/"),
            "http://127.0.0.1:8080"
        );
    }

    #[test]
    fn normalize_passes_through_https() {
        assert_eq!(
            normalize_upstream("https://example.com/"),
            "https://example.com"
        );
    }
}