mcpr-proxy 0.4.50

Open-source proxy for MCP Apps — fixes CSP, handles auth, observes every tool call.
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

//! Command dispatch — thin handlers that wire logic → render.

mod observe;
mod proxy;
mod relay;
pub mod setup;
mod store;

use crate::config::{ProxyCommand, RelayCommand, StoreCommand};

pub fn handle_proxy_command(cmd: ProxyCommand) {
    let result = match cmd {
        // Lifecycle commands
        ProxyCommand::Run(_) => {
            unreachable!("`mcpr proxy run` is handled before async dispatch");
        }
        ProxyCommand::Setup(_) => {
            unreachable!("`mcpr proxy setup` is handled in async dispatch");
        }
        ProxyCommand::Stop(args) => proxy::stop(args),
        ProxyCommand::Restart(args) => proxy::restart(args),
        ProxyCommand::Start(args) => proxy::start(args),
        ProxyCommand::List(args) => proxy::list(args),

        // Observability commands
        ProxyCommand::Logs(args) => observe::logs(args),
        ProxyCommand::Slow(args) => observe::slow(args),
        ProxyCommand::Sessions(args) => observe::sessions(args),
        ProxyCommand::Clients(args) => observe::clients(args),
        ProxyCommand::Status(args) => observe::status(args),
        ProxyCommand::Session(args) => observe::session(args),
        ProxyCommand::Schema(args) => observe::schema(args),
    };

    if let Err(e) = result {
        eprintln!("error: {e}");
        std::process::exit(1);
    }
}

pub fn handle_relay_command(cmd: RelayCommand) {
    let result = match cmd {
        RelayCommand::Run(_) | RelayCommand::Start(_) => {
            unreachable!("`mcpr relay run/start` is handled before async dispatch");
        }
        RelayCommand::Stop => relay::stop(),
        RelayCommand::Restart(args) => relay::restart(args),
        RelayCommand::Status => relay::status(),
    };

    if let Err(e) = result {
        eprintln!("error: {e}");
        std::process::exit(1);
    }
}

pub fn handle_store_command(cmd: StoreCommand) {
    let result = match cmd {
        StoreCommand::Stats => store::stats(),
        StoreCommand::Vacuum(args) => store::vacuum(args),
    };

    if let Err(e) = result {
        eprintln!("error: {e}");
        std::process::exit(1);
    }
}