mullama 0.3.0

Comprehensive Rust bindings for llama.cpp with memory-safe API and advanced features
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

//! Embedded Web UI
//!
//! This module embeds and serves the Vue.js web UI for Mullama.
//! The UI is built separately and embedded at compile time when the `embedded-ui` feature is enabled.

use axum::{
    body::Body,
    http::{header, Response, StatusCode, Uri},
    response::IntoResponse,
};

#[cfg(feature = "embedded-ui")]
use include_dir::{include_dir, Dir};

/// Embedded UI assets directory (only available with embedded-ui feature)
#[cfg(feature = "embedded-ui")]
static UI_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/ui/dist");

/// Serve embedded UI assets
pub async fn serve_ui(uri: Uri) -> impl IntoResponse {
    #[cfg(feature = "embedded-ui")]
    {
        let path = uri.path().trim_start_matches("/ui/");
        let path = if path.is_empty() { "index.html" } else { path };

        // Try to find the file in the embedded directory
        match UI_DIR.get_file(path) {
            Some(file) => {
                let mime_type = mime_guess::from_path(path)
                    .first_or_octet_stream()
                    .to_string();

                Response::builder()
                    .status(StatusCode::OK)
                    .header(header::CONTENT_TYPE, mime_type)
                    .header(header::CACHE_CONTROL, "public, max-age=31536000")
                    .body(Body::from(file.contents().to_vec()))
                    .expect("static response builder")
            }
            None => {
                // For SPA routing, serve index.html for non-asset paths
                if !path.contains('.') {
                    if let Some(index) = UI_DIR.get_file("index.html") {
                        return Response::builder()
                            .status(StatusCode::OK)
                            .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
                            .body(Body::from(index.contents().to_vec()))
                            .expect("static response builder");
                    }
                }

                // Return 404 for missing files
                Response::builder()
                    .status(StatusCode::NOT_FOUND)
                    .header(header::CONTENT_TYPE, "text/plain")
                    .body(Body::from("Not Found"))
                    .expect("static response builder")
            }
        }
    }

    #[cfg(not(feature = "embedded-ui"))]
    {
        let _ = uri; // Suppress unused warning
                     // Return a helpful message when UI is not embedded
        Response::builder()
            .status(StatusCode::NOT_FOUND)
            .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
            .body(Body::from(
                r#"<!DOCTYPE html>
<html>
<head>
    <title>Mullama - Web UI Not Available</title>
    <style>
        body { font-family: system-ui, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px; }
        h1 { color: #333; }
        code { background: #f0f0f0; padding: 2px 6px; border-radius: 4px; }
        pre { background: #f0f0f0; padding: 15px; border-radius: 8px; overflow-x: auto; }
    </style>
</head>
<body>
    <h1>Web UI Not Available</h1>
    <p>The Mullama web UI was not embedded in this build.</p>
    <p>To build with the embedded web UI:</p>
    <pre>cd ui && npm install && npm run build
cargo build --release --features daemon,embedded-ui</pre>
    <p>You can still use the CLI and API:</p>
    <ul>
        <li><code>mullama run llama3.2:1b "Hello"</code> - Run a model</li>
        <li><code>mullama chat</code> - Interactive TUI chat</li>
        <li><code>curl http://localhost:8080/v1/models</code> - List models via API</li>
    </ul>
</body>
</html>"#,
            ))
            .expect("static response builder")
    }
}

/// Check if embedded UI is available
pub fn ui_available() -> bool {
    #[cfg(feature = "embedded-ui")]
    {
        UI_DIR.get_file("index.html").is_some()
    }
    #[cfg(not(feature = "embedded-ui"))]
    {
        false
    }
}

/// Get UI index HTML (for serving at root if desired)
#[allow(dead_code)]
pub fn get_index_html() -> Option<&'static [u8]> {
    #[cfg(feature = "embedded-ui")]
    {
        UI_DIR.get_file("index.html").map(|f| f.contents())
    }
    #[cfg(not(feature = "embedded-ui"))]
    {
        None
    }
}