mcpway 0.2.0

Run MCP stdio servers over SSE, WebSocket, Streamable HTTP, and gRPC transports.
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

use std::fs::File;
use std::io::{BufRead, BufReader};

use serde::Deserialize;
use tokio::sync::mpsc;

use crate::runtime::store::RuntimeArgsUpdate;
use crate::runtime::{RuntimeScope, RuntimeUpdate};

#[derive(Debug, Deserialize)]
struct PromptInput {
    scope: String,
    session_id: Option<String>,
    extra_cli_args: Option<Vec<String>>,
    env: Option<std::collections::HashMap<String, String>>,
    headers: Option<std::collections::HashMap<String, String>>,
}

pub fn spawn_prompt() -> mpsc::Receiver<RuntimeUpdate> {
    let (tx, rx) = mpsc::channel(32);

    std::thread::spawn(move || {
        let Ok(file) = File::open("/dev/tty") else {
            tracing::error!("Runtime prompt disabled: /dev/tty unavailable");
            return;
        };
        let reader = BufReader::new(file);
        tracing::info!("Runtime prompt enabled. Enter JSON per line.");
        tracing::info!(
            "{}",
            "Example: {\"scope\":\"global\",\"extra_cli_args\":[\"--token\",\"abc\"],\"env\":{\"API_KEY\":\"xyz\"},\"headers\":{\"Authorization\":\"Bearer 123\"}}"
        );
        for line in reader.lines() {
            match line {
                Ok(line) => {
                    let trimmed = line.trim();
                    if trimmed.is_empty() {
                        continue;
                    }
                    match serde_json::from_str::<PromptInput>(trimmed) {
                        Ok(input) => {
                            let scope = match input.scope.as_str() {
                                "global" => RuntimeScope::Global,
                                "session" => {
                                    if let Some(id) = input.session_id.clone() {
                                        RuntimeScope::Session(id)
                                    } else {
                                        tracing::error!(
                                            "Prompt input missing session_id for session scope"
                                        );
                                        continue;
                                    }
                                }
                                other => {
                                    tracing::error!("Unknown scope: {other}");
                                    continue;
                                }
                            };
                            let update = RuntimeArgsUpdate {
                                extra_cli_args: input.extra_cli_args,
                                env: input.env,
                                headers: input.headers,
                            };
                            let update_msg = RuntimeUpdate { scope, update };
                            if tx.blocking_send(update_msg).is_err() {
                                tracing::error!("Runtime prompt channel closed");
                                break;
                            }
                        }
                        Err(err) => {
                            tracing::error!("Invalid JSON input: {err}");
                        }
                    }
                }
                Err(err) => {
                    tracing::error!("Runtime prompt read error: {err}");
                    break;
                }
            }
        }
    });

    rx
}