@nklisch/pi-agile-workflow 0.15.3

package/work-view/crates/cli/src/board/open.rs

@@ -0,0 +1,144 @@
+//! Browser launching for the local board server.
+
+use std::env;
+use std::fs;
+use std::io;
+use std::process::Command;
+use std::thread;
+
+use super::BoardOptions;
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum BrowserOpenStatus {
+    Skipped,
+    Headless,
+    Spawned(&'static str),
+    Unavailable,
+}
+
+pub(crate) fn open_after_bind(url: &str, opts: &BoardOptions) -> BrowserOpenStatus {
+    if !should_try_open(opts.no_open, opts.once, graphical_session_available()) {
+        if !opts.no_open && !opts.once {
+            println!("work-view board: no graphical session detected; open {url}");
+            return BrowserOpenStatus::Headless;
+        }
+        return BrowserOpenStatus::Skipped;
+    }
+
+    for opener in ["xdg-open", "open", "wslview"] {
+        match Command::new(opener).arg(url).spawn() {
+            Ok(mut child) => {
+                thread::spawn(move || {
+                    let _ = child.wait();
+                });
+                println!("work-view board: opened browser with {opener}");
+                return BrowserOpenStatus::Spawned(opener);
+            }
+            Err(e) if e.kind() == io::ErrorKind::NotFound => {}
+            Err(_) => {}
+        }
+    }
+
+    println!("work-view board: could not open a browser automatically; open {url}");
+    BrowserOpenStatus::Unavailable
+}
+
+fn should_try_open(no_open: bool, once: bool, has_graphical_session: bool) -> bool {
+    !no_open && !once && has_graphical_session
+}
+
+fn graphical_session_available() -> bool {
+    graphical_session_from_env(
+        env::var_os("DISPLAY").as_deref(),
+        env::var_os("WAYLAND_DISPLAY").as_deref(),
+        cfg!(target_os = "macos"),
+        running_under_wsl(),
+    )
+}
+
+fn graphical_session_from_env(
+    display: Option<&std::ffi::OsStr>,
+    wayland_display: Option<&std::ffi::OsStr>,
+    is_macos: bool,
+    is_wsl: bool,
+) -> bool {
+    is_macos || is_wsl || nonempty_env(display) || nonempty_env(wayland_display)
+}
+
+fn nonempty_env(value: Option<&std::ffi::OsStr>) -> bool {
+    value.is_some_and(|v| !v.is_empty())
+}
+
+fn running_under_wsl() -> bool {
+    let Ok(release) = fs::read_to_string("/proc/sys/kernel/osrelease") else {
+        return false;
+    };
+    let release = release.to_ascii_lowercase();
+    release.contains("microsoft") || release.contains("wsl")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::OsStr;
+
+    #[test]
+    fn skips_when_user_disables_open() {
+        assert!(!should_try_open(true, false, true));
+    }
+
+    #[test]
+    fn skips_during_once_mode() {
+        assert!(!should_try_open(false, true, true));
+    }
+
+    #[test]
+    fn skips_without_graphical_session() {
+        assert!(!should_try_open(false, false, false));
+    }
+
+    #[test]
+    fn tries_when_graphical_session_available() {
+        assert!(should_try_open(false, false, true));
+    }
+
+    #[test]
+    fn detects_display_env() {
+        assert!(graphical_session_from_env(
+            Some(OsStr::new(":0")),
+            None,
+            false,
+            false
+        ));
+    }
+
+    #[test]
+    fn detects_wayland_env() {
+        assert!(graphical_session_from_env(
+            None,
+            Some(OsStr::new("wayland-0")),
+            false,
+            false
+        ));
+    }
+
+    #[test]
+    fn treats_macos_as_graphical() {
+        assert!(graphical_session_from_env(None, None, true, false));
+    }
+
+    #[test]
+    fn treats_wsl_as_openable() {
+        assert!(graphical_session_from_env(None, None, false, true));
+    }
+
+    #[test]
+    fn empty_env_values_do_not_count_as_graphical() {
+        assert!(!graphical_session_from_env(
+            Some(OsStr::new("")),
+            Some(OsStr::new("")),
+            false,
+            false
+        ));
+    }
+}

package/work-view/crates/cli/src/board/server.rs

@@ -0,0 +1,407 @@
+//! Localhost HTTP server for `work-view board`.
+
+use std::fmt;
+use std::io::{self, Read, Write};
+use std::net::{Ipv4Addr, TcpListener, TcpStream};
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use super::{assets, feed, open, BoardOptions};
+
+const MAX_REQUEST_HEADER_BYTES: usize = 8192;
+const READ_TIMEOUT: Duration = Duration::from_secs(2);
+
+const HEALTHZ: &[u8] = b"ok\n";
+const NOT_FOUND: &[u8] = b"not found\n";
+const BAD_REQUEST: &[u8] = b"bad request\n";
+const FORBIDDEN: &[u8] = b"forbidden\n";
+const METHOD_NOT_ALLOWED: &[u8] = b"method not allowed\n";
+const INTERNAL_ERROR: &[u8] = b"internal server error\n";
+
+pub(crate) struct BoundBoard {
+    pub url: String,
+    pub port: u16,
+}
+
+pub(crate) enum BoardServerError {
+    Bind { start: u16, message: String },
+    LocalAddr(io::Error),
+    Serve(io::Error),
+}
+
+impl fmt::Display for BoardServerError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BoardServerError::Bind { start, message } => {
+                write!(
+                    f,
+                    "could not bind 127.0.0.1:{start} or any higher port: {message}"
+                )
+            }
+            BoardServerError::LocalAddr(e) => write!(f, "could not inspect bound address: {e}"),
+            BoardServerError::Serve(e) => write!(f, "server error: {e}"),
+        }
+    }
+}
+
+pub(crate) fn serve_board(
+    root: PathBuf,
+    opts: BoardOptions,
+) -> Result<BoundBoard, BoardServerError> {
+    let listener = bind_localhost(opts.port)?;
+    let port = listener
+        .local_addr()
+        .map_err(BoardServerError::LocalAddr)?
+        .port();
+    let bound = BoundBoard {
+        url: format!("http://127.0.0.1:{port}/"),
+        port,
+    };
+
+    println!(
+        "work-view board: serving {} (port {})",
+        bound.url, bound.port
+    );
+    io::stdout().flush().map_err(BoardServerError::Serve)?;
+    open::open_after_bind(&bound.url, &opts);
+
+    let mut served = 0usize;
+    loop {
+        let (stream, _) = listener.accept().map_err(BoardServerError::Serve)?;
+        if let Err(e) = handle_connection(stream, &root) {
+            eprintln!("work-view board: request error: {e}");
+        }
+
+        served = served.saturating_add(1);
+        if opts.once && served >= 1 {
+            return Ok(bound);
+        }
+    }
+}
+
+fn bind_localhost(start: u16) -> Result<TcpListener, BoardServerError> {
+    let mut last_error = String::from("no ports were attempted");
+    for port in start..=u16::MAX {
+        match TcpListener::bind((Ipv4Addr::LOCALHOST, port)) {
+            Ok(listener) => return Ok(listener),
+            Err(e) if e.kind() == io::ErrorKind::AddrInUse => {
+                last_error = e.to_string();
+            }
+            Err(e) => {
+                return Err(BoardServerError::Bind {
+                    start,
+                    message: e.to_string(),
+                });
+            }
+        }
+    }
+
+    Err(BoardServerError::Bind {
+        start,
+        message: last_error,
+    })
+}
+
+fn handle_connection(mut stream: TcpStream, root: &Path) -> io::Result<()> {
+    let request = match read_request(&mut stream) {
+        Ok(request) => request,
+        Err(ReadRequestError::BadRequest) => {
+            return write_response(&mut stream, Method::Get, bad_request_response());
+        }
+        Err(ReadRequestError::Forbidden) => {
+            return write_response(&mut stream, Method::Get, forbidden_response());
+        }
+        Err(ReadRequestError::MethodNotAllowed) => {
+            return write_response(&mut stream, Method::Get, method_not_allowed_response());
+        }
+        Err(ReadRequestError::Io) => {
+            return write_response(&mut stream, Method::Get, internal_error_response());
+        }
+    };
+
+    let response = route_request(&request, root);
+    write_response(&mut stream, request.method, response)
+}
+
+#[derive(Clone, Copy)]
+enum Method {
+    Get,
+    Head,
+}
+
+struct Request {
+    method: Method,
+    path: String,
+}
+
+enum ReadRequestError {
+    BadRequest,
+    Forbidden,
+    MethodNotAllowed,
+    Io,
+}
+
+fn read_request(stream: &mut TcpStream) -> Result<Request, ReadRequestError> {
+    stream
+        .set_read_timeout(Some(READ_TIMEOUT))
+        .map_err(|_| ReadRequestError::Io)?;
+
+    let mut bytes = Vec::new();
+    let mut chunk = [0u8; 512];
+
+    while bytes.len() < MAX_REQUEST_HEADER_BYTES {
+        let read = stream.read(&mut chunk).map_err(|_| ReadRequestError::Io)?;
+        if read == 0 {
+            break;
+        }
+        bytes.extend(chunk.iter().take(read).copied());
+        if header_len(&bytes).is_some() {
+            break;
+        }
+    }
+
+    let header_len = match header_len(&bytes) {
+        Some(len) if !bytes.is_empty() => len,
+        _ => return Err(ReadRequestError::BadRequest),
+    };
+    let header_bytes = bytes
+        .get(..header_len)
+        .ok_or(ReadRequestError::BadRequest)?;
+    let text = std::str::from_utf8(header_bytes).map_err(|_| ReadRequestError::BadRequest)?;
+    let request_line = text.lines().next().ok_or(ReadRequestError::BadRequest)?;
+    if request_line.trim().is_empty() {
+        return Err(ReadRequestError::BadRequest);
+    }
+    let mut parts = request_line.split_whitespace();
+    let method = match parts.next() {
+        Some("GET") => Method::Get,
+        Some("HEAD") => Method::Head,
+        Some(_) => return Err(ReadRequestError::MethodNotAllowed),
+        None => return Err(ReadRequestError::BadRequest),
+    };
+    let target = parts.next().ok_or(ReadRequestError::BadRequest)?;
+    let version = parts.next().ok_or(ReadRequestError::BadRequest)?;
+    if parts.next().is_some() || !version.starts_with("HTTP/") {
+        return Err(ReadRequestError::BadRequest);
+    }
+
+    let path = match target.split('?').next() {
+        Some(path) => path,
+        None => target,
+    };
+    if !path.starts_with('/') {
+        return Err(ReadRequestError::BadRequest);
+    }
+
+    validate_host_header(text)?;
+
+    Ok(Request {
+        method,
+        path: path.to_string(),
+    })
+}
+
+fn validate_host_header(header_text: &str) -> Result<(), ReadRequestError> {
+    let mut host = None;
+
+    for line in header_text.lines().skip(1) {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let Some((name, value)) = line.split_once(':') else {
+            return Err(ReadRequestError::BadRequest);
+        };
+        if name.eq_ignore_ascii_case("host") {
+            if host.replace(value.trim()).is_some() {
+                return Err(ReadRequestError::Forbidden);
+            }
+        }
+    }
+
+    match host {
+        Some(value) if host_is_loopback(value) => Ok(()),
+        _ => Err(ReadRequestError::Forbidden),
+    }
+}
+
+fn host_is_loopback(raw: &str) -> bool {
+    let authority = raw.trim().trim_end_matches('.').to_ascii_lowercase();
+    if matches!(authority.as_str(), "localhost" | "127.0.0.1" | "::1") {
+        return true;
+    }
+
+    if let Some(bracketed) = authority.strip_prefix('[') {
+        let Some((host, rest)) = bracketed.split_once(']') else {
+            return false;
+        };
+        return host == "::1" && valid_optional_port(rest);
+    }
+
+    let Some((host, port)) = authority.rsplit_once(':') else {
+        return false;
+    };
+    !host.contains(':')
+        && !port.is_empty()
+        && port.chars().all(|c| c.is_ascii_digit())
+        && matches!(host, "localhost" | "127.0.0.1")
+}
+
+fn valid_optional_port(rest: &str) -> bool {
+    rest.is_empty()
+        || rest
+            .strip_prefix(':')
+            .is_some_and(|port| !port.is_empty() && port.chars().all(|c| c.is_ascii_digit()))
+}
+
+fn header_len(bytes: &[u8]) -> Option<usize> {
+    if let Some(position) = bytes.windows(4).position(|window| window == b"\r\n\r\n") {
+        return Some(position.saturating_add(4));
+    }
+    bytes
+        .windows(2)
+        .position(|window| window == b"\n\n")
+        .map(|position| position.saturating_add(2))
+}
+
+struct Response {
+    status: u16,
+    reason: &'static str,
+    content_type: &'static str,
+    body: Vec<u8>,
+    allow: Option<&'static str>,
+}
+
+fn route_request(request: &Request, root: &Path) -> Response {
+    match request.path.as_str() {
+        "/healthz" => ok_response("text/plain; charset=utf-8", HEALTHZ),
+        "/api/substrate" => match feed::build_feed(root) {
+            Ok(json) => ok_response("application/json; charset=utf-8", json.into_bytes()),
+            Err(e) => {
+                eprintln!("work-view board: feed error: {e}");
+                internal_error_response()
+            }
+        },
+        path => match assets::asset_for_path(path) {
+            Some(asset) => ok_response(asset.content_type, asset.bytes),
+            None => not_found_response(),
+        },
+    }
+}
+
+fn ok_response<B: Into<Vec<u8>>>(content_type: &'static str, body: B) -> Response {
+    Response {
+        status: 200,
+        reason: "OK",
+        content_type,
+        body: body.into(),
+        allow: None,
+    }
+}
+
+fn not_found_response() -> Response {
+    Response {
+        status: 404,
+        reason: "Not Found",
+        content_type: "text/plain; charset=utf-8",
+        body: NOT_FOUND.to_vec(),
+        allow: None,
+    }
+}
+
+fn bad_request_response() -> Response {
+    Response {
+        status: 400,
+        reason: "Bad Request",
+        content_type: "text/plain; charset=utf-8",
+        body: BAD_REQUEST.to_vec(),
+        allow: None,
+    }
+}
+
+fn forbidden_response() -> Response {
+    Response {
+        status: 403,
+        reason: "Forbidden",
+        content_type: "text/plain; charset=utf-8",
+        body: FORBIDDEN.to_vec(),
+        allow: None,
+    }
+}
+
+fn method_not_allowed_response() -> Response {
+    Response {
+        status: 405,
+        reason: "Method Not Allowed",
+        content_type: "text/plain; charset=utf-8",
+        body: METHOD_NOT_ALLOWED.to_vec(),
+        allow: Some("GET, HEAD"),
+    }
+}
+
+fn internal_error_response() -> Response {
+    Response {
+        status: 500,
+        reason: "Internal Server Error",
+        content_type: "text/plain; charset=utf-8",
+        body: INTERNAL_ERROR.to_vec(),
+        allow: None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn loopback_hosts_are_allowed() {
+        for host in [
+            "127.0.0.1",
+            "127.0.0.1:8181",
+            "localhost",
+            "LOCALHOST:8181",
+            "[::1]",
+            "[::1]:8181",
+            "::1",
+        ] {
+            assert!(host_is_loopback(host), "expected loopback host: {host}");
+        }
+    }
+
+    #[test]
+    fn non_loopback_hosts_are_rejected() {
+        for host in [
+            "",
+            "example.com",
+            "example.com:8181",
+            "127.0.0.2",
+            "0.0.0.0",
+            "[2001:db8::1]:8181",
+            "localhost:abc",
+            "[::1]:abc",
+        ] {
+            assert!(!host_is_loopback(host), "expected rejected host: {host}");
+        }
+    }
+}
+
+fn write_response(stream: &mut TcpStream, method: Method, response: Response) -> io::Result<()> {
+    let mut headers = format!(
+        "HTTP/1.1 {} {}\r\nContent-Type: {}\r\nContent-Length: {}\r\nConnection: close\r\nX-Content-Type-Options: nosniff\r\n",
+        response.status,
+        response.reason,
+        response.content_type,
+        response.body.len()
+    );
+    if let Some(allow) = response.allow {
+        headers.push_str("Allow: ");
+        headers.push_str(allow);
+        headers.push_str("\r\n");
+    }
+    headers.push_str("\r\n");
+
+    stream.write_all(headers.as_bytes())?;
+    if matches!(method, Method::Get) {
+        stream.write_all(&response.body)?;
+    }
+    stream.flush()
+}