ssh-mcp 0.1.3

SSH Model Context Protocol Server Integration
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

use std::sync::atomic::Ordering;
use poem_mcpserver::{content::{Json, Text}, Tools};
use serde_json::json;

use crate::shared::state::{LAST_COMMAND, SSH_CONNECTIONS, SSH_CLIENTS, get_uptime};
use crate::mcp::commands::broadcast_to_clients;

// MCP Tools implementation
pub struct McpTools {}

#[Tools]
impl McpTools {
    /// Get server status information
    pub async fn get_status(&self) -> Json<serde_json::Value> {
        let status = json!({
            "status": "online",
            "ssh_connections": SSH_CONNECTIONS.load(Ordering::SeqCst),
            "uptime": get_uptime(),
            "server_time": chrono::Utc::now().to_rfc3339()
        });
        Json(status)
    }

    /// Get the last command executed through SSH
    pub async fn get_last_command(&self) -> Text<String> {
        let cmd = LAST_COMMAND.lock().await.clone();
        Text(cmd)
    }
    
    /// List available tools
    pub async fn get_tools(&self) -> Json<serde_json::Value> {
        let tools = json!({
            "tools": [
                {
                    "name": "get_status",
                    "description": "Server status information"
                },
                {
                    "name": "get_tools",
                    "description": "List available AI tools"
                },
                {
                    "name": "get_last_command",
                    "description": "Last SSH command executed"
                },
                {
                    "name": "broadcast_message",
                    "description": "Send a message to SSH clients"
                },
                {
                    "name": "get_clients",
                    "description": "Get information about connected SSH clients"
                }
            ]
        });
        Json(tools)
    }
    
    /// Broadcast a message to all SSH clients
    pub async fn broadcast_message(&self, message: String) -> Json<serde_json::Value> {
        broadcast_to_clients(&message);
        
        let result = json!({
            "success": true,
            "message": message,
            "timestamp": chrono::Utc::now().to_rfc3339()
        });
        Json(result)
    }
    
    /// Get connected clients information
    pub async fn get_clients(&self) -> Json<serde_json::Value> {
        let mut clients_data = Vec::new();
        
        if let Ok(clients) = SSH_CLIENTS.lock() {
            for client in clients.iter() {
                clients_data.push(json!({
                    "name": client.name,
                    "uuid": client.uuid.to_string(),
                    "connected_at": client.connected_at.to_rfc3339(),
                    "last_activity": client.last_activity.to_rfc3339()
                }));
            }
        }
        
        let result = json!({
            "count": clients_data.len(),
            "clients": clients_data
        });
        Json(result)
    }
}