liminal-cli 0.3.33

The liminal command: serve the network, maintain its stores, or serve its discovery MCP over stdio
Documentation 
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

//! The console dist found and written as an embedded table: shared by `build.rs` and its tests.

use std::fmt::Write as _;
use std::path::{Path, PathBuf};

/// Where the console dist is read from (CON-026 R1): a checkout, which has the workspace's
/// `apps/liminal-console`, embeds that console's `dist` and nothing else, so a `console-dist/`
/// left in the crate is never embedded over it; a published crate, which cannot reach the
/// workspace, reads the `console-dist/` its release packaged.
///
/// # Errors
/// The dist the case reads holds no `index.html`: the build fails by name and says how to build it.
pub fn dist(manifest: &Path) -> Result<PathBuf, String> {
    let console = manifest.join("../../apps/liminal-console");
    let (found, other) = if console.is_dir() {
        (console.join("dist"), None)
    } else {
        (manifest.join("console-dist"), Some(console.join("dist")))
    };
    if found.join("index.html").is_file() {
        return Ok(found);
    }
    let also = other.map_or_else(String::new, |other| format!(" nor {}", other.display()));
    Err(format!(
        "missing console dist: {}{also} holds no index.html; build it with: cd apps/liminal-console && bun run build",
        found.display(),
    ))
}

/// The `EMBEDDED` table of every file under `dist`, sorted, with its media type, and the files
/// to watch for a rebuild.
///
/// # Errors
/// A path that cannot be read or is not Unicode.
pub fn table(dist: &Path) -> Result<(String, Vec<PathBuf>), Box<dyn std::error::Error>> {
    let mut files = Vec::new();
    collect(dist, &mut files)?;
    files.sort();
    let mut table = String::from("const EMBEDDED: &[(&str, &str, &[u8])] = &[\n");
    for path in &files {
        let relative = path
            .strip_prefix(dist)?
            .to_str()
            .ok_or("console asset path is not Unicode")?
            .replace('\\', "/");
        let absolute = std::fs::canonicalize(path)?;
        let absolute = absolute
            .to_str()
            .ok_or("console asset path is not Unicode")?;
        writeln!(
            table,
            "({:?}, {:?}, include_bytes!({absolute:?})),",
            format!("/{relative}"),
            mime(path)
        )?;
    }
    table.push_str("];\n");
    Ok((table, files))
}

fn collect(root: &Path, files: &mut Vec<PathBuf>) -> std::io::Result<()> {
    for entry in std::fs::read_dir(root)? {
        let entry = entry?;
        let kind = entry.file_type()?;
        if kind.is_dir() {
            collect(&entry.path(), files)?;
        } else if kind.is_file() {
            files.push(entry.path());
        }
    }
    Ok(())
}

fn mime(path: &Path) -> &'static str {
    match path.extension().and_then(std::ffi::OsStr::to_str) {
        Some("html") => "text/html; charset=utf-8",
        Some("js" | "mjs") => "text/javascript; charset=utf-8",
        Some("css") => "text/css; charset=utf-8",
        Some("json" | "map") => "application/json",
        Some("wasm") => "application/wasm",
        Some("svg") => "image/svg+xml",
        Some("png") => "image/png",
        Some("jpg" | "jpeg") => "image/jpeg",
        Some("ico") => "image/x-icon",
        Some("woff2") => "font/woff2",
        Some("woff") => "font/woff",
        Some("ttf") => "font/ttf",
        Some("txt") => "text/plain; charset=utf-8",
        _ => "application/octet-stream",
    }
}