iwec 0.4.0

IWE MCP server
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::net::TcpListener;
use std::process::{Child, Command, Stdio};
use std::time::Duration;

use rmcp::model::{
    CallToolRequestParams, ClientCapabilities, ClientInfo, Implementation, RawContent,
};
use rmcp::transport::StreamableHttpClientTransport;
use rmcp::ServiceExt;

struct ServerProcess {
    child: Child,
}

impl Drop for ServerProcess {
    fn drop(&mut self) {
        let _ = self.child.kill();
        let _ = self.child.wait();
    }
}

fn free_port() -> u16 {
    TcpListener::bind("127.0.0.1:0")
        .expect("bind ephemeral port")
        .local_addr()
        .expect("local addr")
        .port()
}

async fn wait_until_listening(addr: &str) {
    for _ in 0..100 {
        if tokio::net::TcpStream::connect(addr).await.is_ok() {
            return;
        }
        tokio::time::sleep(Duration::from_millis(50)).await;
    }
    panic!("server did not start listening on {addr}");
}

#[tokio::test]
async fn http_transport_serves_the_graph() {
    let dir = tempfile::tempdir().expect("temp dir");
    std::fs::write(
        dir.path().join("welcome.md"),
        "# Welcome\n\nFirst document.\n",
    )
    .expect("write document");

    let port = free_port();
    let _server = ServerProcess {
        child: Command::new(env!("CARGO_BIN_EXE_iwec"))
            .arg("--transport")
            .arg("http")
            .arg("--port")
            .arg(port.to_string())
            .current_dir(dir.path())
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .spawn()
            .expect("spawn iwec"),
    };

    let addr = format!("127.0.0.1:{port}");
    wait_until_listening(&addr).await;

    let transport = StreamableHttpClientTransport::from_uri(format!("http://{addr}/mcp"));
    let client_info = ClientInfo::new(
        ClientCapabilities::default(),
        Implementation::new("iwec-test-client", "0.0.1"),
    );
    let client = client_info
        .serve(transport)
        .await
        .expect("client to connect");

    let result = client
        .call_tool(
            CallToolRequestParams::new("iwe_find").with_arguments(
                serde_json::json!({ "query": "welcome" })
                    .as_object()
                    .cloned()
                    .unwrap(),
            ),
        )
        .await
        .expect("tool call to succeed");

    let text = result
        .content
        .iter()
        .filter_map(|c| match &c.raw {
            RawContent::Text(t) => Some(t.text.clone()),
            _ => None,
        })
        .collect::<String>();
    let json: serde_json::Value = serde_json::from_str(&text).expect("result to be valid JSON");

    assert_eq!(
        json,
        serde_json::json!([
            {
                "key": "welcome",
                "title": "Welcome",
                "references": [],
                "includes": [],
                "referencedBy": [],
                "includedBy": []
            }
        ])
    );

    client.cancel().await.expect("client to disconnect");
}