lifecycle_server/
lifecycle_server.rs

1use mcprotocol_rs::{
2    error_codes,
3    protocol::ServerCapabilities,
4    transport::{ServerTransportFactory, TransportConfig, TransportType},
5    ImplementationInfo, Message, Response, ResponseError, Result, PROTOCOL_VERSION,
6};
7use serde_json::json;
8use std::collections::HashSet;
9use tokio;
10
11#[tokio::main]
12async fn main() -> Result<()> {
13    // 跟踪会话中使用的请求 ID
14    // Track request IDs used in the session
15    let mut session_ids = HashSet::new();
16
17    // 配置 Stdio 服务器
18    // Configure Stdio server
19    let config = TransportConfig {
20        transport_type: TransportType::Stdio {
21            server_path: None,
22            server_args: None,
23        },
24        parameters: None,
25    };
26
27    // 创建服务器实例
28    // Create server instance
29    let factory = ServerTransportFactory;
30    let mut server = factory.create(config)?;
31    let mut initialized = false;
32
33    // 启动服务器
34    // Start server
35    eprintln!("Server starting...");
36    server.initialize().await?;
37
38    // 处理消息循环
39    // Message handling loop
40    loop {
41        match server.receive().await {
42            Ok(message) => {
43                match message {
44                    Message::Request(request) => {
45                        // 验证请求 ID 的唯一性
46                        // Validate request ID uniqueness
47                        if !request.validate_id_uniqueness(&mut session_ids) {
48                            let error = ResponseError {
49                                code: error_codes::INVALID_REQUEST,
50                                message: "Request ID has already been used".to_string(),
51                                data: None,
52                            };
53                            let response = Response::error(error, request.id);
54                            server.send(Message::Response(response)).await?;
55                            continue;
56                        }
57
58                        match request.method.as_str() {
59                            "initialize" => {
60                                // 处理初始化请求
61                                // Handle initialize request
62                                eprintln!("Received initialize request");
63
64                                // 解析客户端能力和版本
65                                // Parse client capabilities and version
66                                if let Some(params) = request.params {
67                                    let client_version = params
68                                        .get("protocolVersion")
69                                        .and_then(|v| v.as_str())
70                                        .unwrap_or("unknown");
71
72                                    // 版本检查
73                                    // Version check
74                                    if client_version != PROTOCOL_VERSION {
75                                        // 发送错误响应
76                                        // Send error response
77                                        let error = ResponseError {
78                                            code: error_codes::INVALID_REQUEST,
79                                            message: "Unsupported protocol version".to_string(),
80                                            data: Some(json!({
81                                                "supported": [PROTOCOL_VERSION],
82                                                "requested": client_version
83                                            })),
84                                        };
85                                        let response = Response::error(error, request.id);
86                                        server.send(Message::Response(response)).await?;
87                                        continue;
88                                    }
89
90                                    // 发送成功响应
91                                    // Send success response
92                                    let response = Response::success(
93                                        json!({
94                                            "protocolVersion": PROTOCOL_VERSION,
95                                            "capabilities": ServerCapabilities {
96                                                prompts: None,
97                                                resources: None,
98                                                tools: None,
99                                                logging: Some(json!({})),
100                                                experimental: None,
101                                            },
102                                            "serverInfo": ImplementationInfo {
103                                                name: "Example Server".to_string(),
104                                                version: "1.0.0".to_string(),
105                                            }
106                                        }),
107                                        request.id,
108                                    );
109                                    server.send(Message::Response(response)).await?;
110                                }
111                            }
112                            "shutdown" => {
113                                if !initialized {
114                                    // 如果未初始化，发送错误
115                                    // If not initialized, send error
116                                    let error = ResponseError {
117                                        code: error_codes::SERVER_NOT_INITIALIZED,
118                                        message: "Server not initialized".to_string(),
119                                        data: None,
120                                    };
121                                    let response = Response::error(error, request.id);
122                                    server.send(Message::Response(response)).await?;
123                                    continue;
124                                }
125
126                                // 发送成功响应
127                                // Send success response
128                                let response = Response::success(json!(null), request.id);
129                                server.send(Message::Response(response)).await?;
130
131                                // 等待退出通知
132                                // Wait for exit notification
133                                eprintln!("Server shutting down...");
134                                break;
135                            }
136                            _ => {
137                                if !initialized {
138                                    // 如果未初始化，拒绝其他请求
139                                    // If not initialized, reject other requests
140                                    let error = ResponseError {
141                                        code: error_codes::SERVER_NOT_INITIALIZED,
142                                        message: "Server not initialized".to_string(),
143                                        data: None,
144                                    };
145                                    let response = Response::error(error, request.id);
146                                    server.send(Message::Response(response)).await?;
147                                }
148                            }
149                        }
150                    }
151                    Message::Notification(notification) => match notification.method.as_str() {
152                        "initialized" => {
153                            eprintln!("Server initialized");
154                            initialized = true;
155                        }
156                        "exit" => {
157                            eprintln!("Received exit notification");
158                            break;
159                        }
160                        _ => {}
161                    },
162                    _ => {}
163                }
164            }
165            Err(e) => {
166                eprintln!("Error receiving message: {}", e);
167                break;
168            }
169        }
170    }
171
172    // 关闭服务器
173    // Close server
174    server.close().await?;
175    eprintln!("Server stopped");
176    Ok(())
177}
lifecycle_server/lifecycle_server.rs

lifecycle_server/
lifecycle_server.rs
