slave 0.4.0

Laravel-inspired CLI for Rust MCP servers: scaffold apps whose business operations are MCP tools over Streamable HTTP, with built-in auth, users, roles and Turso migrations
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

//! `slave route:list` and `slave route:match <host>`, like `php artisan route:list`.

use std::net::{TcpStream, ToSocketAddrs};
use std::time::Duration;

use anyhow::{Result, bail};

use crate::apps::{self, Apps, Env};
use crate::project;

/// Loads the project's routing table, failing if it has none.
fn load() -> Result<Apps> {
    let root = project::find_root()?;
    let env = Env::load(&root)?;
    let mcp = mcp_upstream(&env);
    match Apps::load(&root, &env, &mcp)? {
        Some(apps) => Ok(apps),
        None => bail!("{} not found in this project", apps::CONFIG),
    }
}

/// `APP_HOST:APP_PORT` of the MCP backend as seen from this machine.
pub fn mcp_upstream(env: &Env) -> String {
    let host = env.get("APP_HOST").unwrap_or_else(|| "127.0.0.1".into());
    let port = env
        .get("APP_PORT")
        .and_then(|port| port.trim().parse().ok())
        .unwrap_or(3000);
    apps::connect_address(&host, port)
}

pub fn list() -> Result<()> {
    let apps = load()?;
    let rows: Vec<[String; 4]> = apps
        .routes
        .iter()
        .map(|route| {
            let app = if route.is_mcp {
                "mcp (backend)".to_owned()
            } else {
                route.app.clone()
            };
            let status = if is_up(&route.upstream) { "up" } else { "down" };
            [
                route.host.clone(),
                app,
                route.upstream.clone(),
                status.to_owned(),
            ]
        })
        .collect();

    let header = ["HOST", "APP", "UPSTREAM", "STATUS"];
    let widths: Vec<usize> = (0..4)
        .map(|i| {
            rows.iter()
                .map(|row| row[i].len())
                .chain([header[i].len()])
                .max()
                .unwrap_or(0)
        })
        .collect();
    let print = |row: &[&str]| {
        let line: Vec<String> = row
            .iter()
            .zip(&widths)
            .map(|(cell, width)| format!("{cell:<width$}"))
            .collect();
        println!("  {}", line.join("  ").trim_end());
    };
    println!();
    print(&header);
    for row in &rows {
        print(&row.each_ref().map(String::as_str));
    }
    println!(
        "\n  {} route(s), matched top to bottom · gateway: http://{}",
        rows.len(),
        apps.listen
    );
    Ok(())
}

pub fn matches(host: &str) -> Result<()> {
    let apps = load()?;
    let Some(found) = apps.routes.find(host) else {
        bail!("no route matches `{host}`; the gateway answers 404");
    };
    let route = found.route;
    println!(
        "  {host} → {} (route #{}) → {} ({})",
        route.host,
        found.index + 1,
        if route.is_mcp { "mcp" } else { &route.app },
        route.upstream
    );
    for (name, value) in &found.params {
        println!(
            "  header: {}: {value}",
            slave_gateway::routes::param_header(name)
        );
    }
    if route.is_mcp {
        println!(
            "  header: host: {} (rewritten for the MCP backend)",
            route.upstream
        );
    }
    Ok(())
}

/// Whether something accepts connections at `upstream`.
fn is_up(upstream: &str) -> bool {
    upstream
        .to_socket_addrs()
        .ok()
        .and_then(|mut addrs| addrs.next())
        .is_some_and(|addr| TcpStream::connect_timeout(&addr, Duration::from_millis(300)).is_ok())
}