pitchfork_cli/web/
server.rs

1use crate::Result;
2use crate::settings::settings;
3use axum::{
4    Router,
5    body::Body,
6    extract::Request,
7    http::StatusCode,
8    middleware::{self, Next},
9    response::{Redirect, Response},
10    routing::{get, post},
11};
12use std::net::SocketAddr;
13
14use super::routes;
15use super::static_files::{set_static_base, set_static_token, static_handler};
16
17/// API token middleware - rejects requests without valid X-Pitchfork-Token header
18/// when the server is bound to a non-loopback address and a token is configured.
19async fn token_auth(
20    request: Request<Body>,
21    next: Next,
22    expected_token: String,
23) -> Result<Response, StatusCode> {
24    if expected_token.is_empty() {
25        return Ok(next.run(request).await);
26    }
27    let token = request
28        .headers()
29        .get("X-Pitchfork-Token")
30        .and_then(|v| v.to_str().ok())
31        .unwrap_or("");
32    if token != expected_token {
33        let addr: std::borrow::Cow<'_, str> = request
34            .extensions()
35            .get::<axum::extract::ConnectInfo<SocketAddr>>()
36            .map(|a| a.0.to_string().into())
37            .unwrap_or_else(|| "unknown".into());
38        warn!(
39            "API request rejected: invalid or missing X-Pitchfork-Token from {} to {}",
40            addr,
41            request.uri()
42        );
43        return Err(StatusCode::UNAUTHORIZED);
44    }
45    Ok(next.run(request).await)
46}
47
48/// Check if an IP address is loopback (127.0.0.1 or ::1).
49fn is_loopback(addr: &str) -> bool {
50    addr.parse::<SocketAddr>()
51        .map(|a| a.ip().is_loopback())
52        .unwrap_or_else(|_| {
53            // Try parsing as just an IP without port
54            addr.parse::<std::net::IpAddr>()
55                .map(|ip| ip.is_loopback())
56                .unwrap_or(false)
57        })
58}
59/// Generate a random 32-byte hex token (64 characters).
60fn generate_token() -> String {
61    let a = uuid::Uuid::new_v4();
62    let b = uuid::Uuid::new_v4();
63    format!("{}{}", a.simple(), b.simple())
64}
65
66/// Build the API router (no CSRF - SPA uses JSON).
67fn api_router(token: String) -> Router {
68    let token_clone = token.clone();
69    Router::new()
70        .route("/api/stats", get(routes::api::stats::stats))
71        .route("/api/daemons", get(routes::api::daemons::list))
72        .route("/api/daemons/{id}", get(routes::api::daemons::show))
73        .route("/api/daemons/{id}/start", post(routes::api::daemons::start))
74        .route("/api/daemons/{id}/stop", post(routes::api::daemons::stop))
75        .route(
76            "/api/daemons/{id}/restart",
77            post(routes::api::daemons::restart),
78        )
79        .route(
80            "/api/daemons/{id}/enable",
81            post(routes::api::daemons::enable),
82        )
83        .route(
84            "/api/daemons/{id}/disable",
85            post(routes::api::daemons::disable),
86        )
87        .route("/api/logs/{id}/tail", get(routes::api::logs::tail))
88        .route("/api/logs/{id}/loggers", get(routes::api::logs::loggers))
89        .route(
90            "/api/logs/{id}/field-keys",
91            get(routes::api::logs::field_keys),
92        )
93        .route("/api/namespaces", get(routes::api::namespaces::list))
94        .route("/api/namespaces", post(routes::api::namespaces::register))
95        .route(
96            "/api/namespaces/{name}",
97            axum::routing::delete(routes::api::namespaces::remove),
98        )
99        .route("/api/proxies", get(routes::api::proxies::list))
100        .route(
101            "/api/processes/{id}/tree",
102            get(routes::api::processes::tree),
103        )
104        .route("/logs/{id}/stream", get(routes::logs::stream_sse))
105        .layer(middleware::from_fn(move |req, next| {
106            let t = token_clone.clone();
107            async move { token_auth(req, next, t).await }
108        }))
109}
110
111/// Bind a `TcpListener` and return `(listener, actual_port)`, trying
112/// `port_attempts` ports starting from `port`.
113async fn try_bind(
114    bind_address: &str,
115    port: u16,
116    port_attempts: u16,
117) -> Result<(tokio::net::TcpListener, u16)> {
118    let ip_addr: std::net::IpAddr = bind_address
119        .parse()
120        .map_err(|e| miette::miette!("Invalid bind address '{}': {}", bind_address, e))?;
121
122    let mut last_error = None;
123    for offset in 0..port_attempts {
124        let try_port = port.saturating_add(offset);
125        let addr = SocketAddr::from((ip_addr, try_port));
126
127        match tokio::net::TcpListener::bind(addr).await {
128            Ok(listener) => {
129                let actual_port = listener
130                    .local_addr()
131                    .map_err(|e| miette::miette!("Failed to inspect bound port: {}", e))?;
132                return Ok((listener, actual_port.port()));
133            }
134            Err(e) => {
135                debug!("Port {try_port} unavailable: {e}");
136                last_error = Some(e);
137            }
138        }
139    }
140
141    Err(miette::miette!(
142        "Failed to bind: tried ports {}-{}, all in use. Last error: {}",
143        port,
144        port.saturating_add(port_attempts - 1),
145        last_error.map(|e| e.to_string()).unwrap_or_default()
146    ))
147}
148
149pub async fn serve(port: u16, web_path: Option<String>) -> Result<()> {
150    let base_path = super::normalize_base_path(web_path.as_deref())?;
151    super::BASE_PATH
152        .set(base_path.clone())
153        .expect("BASE_PATH already set; serve() must only be called once per process");
154    let s = settings();
155    let bind_address = &s.web.bind_address;
156    let port_attempts: u16 = u16::try_from(s.web.port_attempts)
157        .unwrap_or_else(|_| {
158            warn!(
159                "web.port_attempts value {} is out of range (1-65535), clamping to 10",
160                s.web.port_attempts
161            );
162            10
163        })
164        .max(1);
165
166    // Determine token: use configured token, or auto-generate one if binding to non-loopback
167    let mut token = s.api.token.clone();
168    if token.is_empty() && !is_loopback(bind_address) {
169        token = generate_token();
170        info!(
171            "Web UI bound to non-loopback address {}. Auto-generated API token: {}",
172            bind_address, token
173        );
174        // Also print to stderr so it's visible even with log level filtering
175        eprintln!("pitchfork API security token (auto-generated): {}", token);
176    }
177
178    set_static_token(token.clone());
179    set_static_base(base_path.clone());
180
181    let inner = api_router(token.clone()).fallback(static_handler);
182
183    let app = if base_path.is_empty() {
184        inner
185    } else {
186        let redirect_target = format!("{base_path}/");
187        Router::new()
188            .route(
189                "/",
190                get(move || async move { Redirect::temporary(&redirect_target) }),
191            )
192            .nest(&base_path, inner)
193    };
194
195    let (listener, actual_port) = try_bind(bind_address, port, port_attempts).await?;
196    let _ = super::WEB_PORT.set(actual_port);
197    let actual_addr = listener.local_addr().unwrap();
198    let url_host = match actual_addr.ip() {
199        ip if ip.is_unspecified() => "localhost".to_string(),
200        std::net::IpAddr::V6(ip) => format!("[{ip}]"),
201        std::net::IpAddr::V4(ip) => ip.to_string(),
202    };
203    // The scheme is hardcoded because the web server only speaks plain HTTP.
204    // If TLS support is ever added, this must pick the scheme accordingly or
205    // the URL reported by `supervisor status` will be wrong.
206    let _ = super::WEB_URL.set(format!("http://{url_host}:{actual_port}{base_path}"));
207
208    info!("Web UI listening on http://{actual_addr}");
209
210    axum::serve(listener, app)
211        .await
212        .map_err(|e| miette::miette!("Web server error: {}", e))
213}
214
215/// Serve the API on a dedicated port, separate from the web UI.
216/// Called by the supervisor when `settings.api.bind_port` is configured.
217pub async fn serve_api(port: u16, _web_path: Option<String>) -> Result<()> {
218    let s = settings();
219    let bind_address = &s.api.bind_address;
220    let port_attempts: u16 = u16::try_from(s.api.port_attempts)
221        .unwrap_or_else(|_| {
222            warn!(
223                "api.port_attempts value {} is out of range (1-65535), clamping to 10",
224                s.api.port_attempts
225            );
226            10
227        })
228        .max(1);
229
230    // Determine token for standalone API server
231    let mut token = s.api.token.clone();
232    if token.is_empty() && !is_loopback(bind_address) {
233        token = generate_token();
234        info!(
235            "API server bound to non-loopback address {}. Auto-generated API token: {}",
236            bind_address, token
237        );
238        eprintln!("pitchfork API security token (auto-generated): {}", token);
239    }
240
241    let app = api_router(token);
242
243    let (listener, _actual_port) = try_bind(bind_address, port, port_attempts).await?;
244    let actual_addr = listener.local_addr().unwrap();
245    info!("API server listening on http://{actual_addr}");
246
247    axum::serve(listener, app)
248        .await
249        .map_err(|e| miette::miette!("API server error: {}", e))
250}
pitchfork_cli/web/server.rs

pitchfork_cli/web/
server.rs
