pensieve-server 0.1.0

HTTP + gRPC query API, auth stub, health, observability.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! UI static-serving routes. Compiled in only when the `web-ui` feature is on.

use axum::{
    body::Body,
    http::{header, HeaderValue, StatusCode, Uri},
    response::{IntoResponse, Response},
    routing::get,
    Router,
};
use pensieve_web_assets::{mime_for, DIST};

/// Router exposing: `GET /`, `GET /assets/*`, and a SPA fallback.
pub fn router() -> Router {
    Router::new()
        .route("/", get(serve_index))
        .route("/assets/*path", get(serve_asset))
        .fallback(serve_spa_fallback)
}

async fn serve_index() -> Response {
    match DIST.get_file("index.html") {
        Some(f) => html_response(f.contents()),
        None => (
            StatusCode::NOT_FOUND,
            "index.html missing from embedded assets",
        )
            .into_response(),
    }
}

/// Safe: DIST is compile-time, not filesystem — no traversal possible.
async fn serve_asset(uri: Uri) -> Response {
    // path strips the leading "/"
    let raw = uri.path().trim_start_matches('/');
    match DIST.get_file(raw) {
        Some(f) => asset_response(raw, f.contents()),
        None => (StatusCode::NOT_FOUND, "asset not found").into_response(),
    }
}

/// Unknown paths fall back to `index.html` so client-side routing works on
/// reload / deep-link — with two exceptions:
///
/// 1. Real embedded files outside `/assets/` (Vite copies `web/public/*` to
///    the dist root: `/icons/pensieve-mark.svg`, brand SVGs, …) are served as
///    themselves. Without this the logo/favicon came back as HTML — a broken
///    image on every installed bundle (dev was fine: Vite serves `public/`).
/// 2. API prefixes get a real JSON 404, not a 200 with HTML: clients
///    expecting JSON would choke on the body and the missing route (e.g.
///    control-plane-only surfaces in local mode) would be invisible.
pub async fn serve_spa_fallback(uri: Uri) -> Response {
    let p = uri.path();
    let raw = p.trim_start_matches('/');
    if !raw.is_empty() {
        if let Some(f) = DIST.get_file(raw) {
            return public_response(raw, f.contents());
        }
    }
    let is_api = p.starts_with("/v1/")
        || p.starts_with("/flight")
        || p.starts_with("/mcp")
        || p.starts_with("/git/")
        || p == "/metrics"
        || p == "/health";
    if is_api {
        return (
            StatusCode::NOT_FOUND,
            [(
                header::CONTENT_TYPE,
                HeaderValue::from_static("application/json"),
            )],
            format!(r#"{{"error":"endpoint not available on this server","path":{p:?}}}"#),
        )
            .into_response();
    }
    match DIST.get_file("index.html") {
        Some(f) => html_response(f.contents()),
        None => (StatusCode::NOT_FOUND, "index.html missing").into_response(),
    }
}

fn html_response(body: &'static [u8]) -> Response {
    Response::builder()
        .status(StatusCode::OK)
        .header(
            header::CONTENT_TYPE,
            HeaderValue::from_static("text/html; charset=utf-8"),
        )
        .header(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"))
        .body(Body::from(body))
        .unwrap()
}

fn asset_response(path: &str, body: &'static [u8]) -> Response {
    Response::builder()
        .status(StatusCode::OK)
        .header(
            header::CONTENT_TYPE,
            HeaderValue::from_static(mime_for(path)),
        )
        .header(
            header::CACHE_CONTROL,
            HeaderValue::from_static("public, max-age=31536000, immutable"),
        )
        .body(Body::from(body))
        .unwrap()
}

/// Dist-root files from `web/public/` (logo, brand icons). Stable names —
/// NOT content-hashed — so cache briefly rather than immutably.
fn public_response(path: &str, body: &'static [u8]) -> Response {
    Response::builder()
        .status(StatusCode::OK)
        .header(
            header::CONTENT_TYPE,
            HeaderValue::from_static(mime_for(path)),
        )
        .header(
            header::CACHE_CONTROL,
            HeaderValue::from_static("public, max-age=3600"),
        )
        .body(Body::from(body))
        .unwrap()
}