pty-mcp 0.2.2

An MCP server for PTY management with SSH connections, remote sessions, file access, and mounts
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

mod context;
mod local_sessions;
mod ssh_connections;
mod ssh_files;
mod ssh_mounts;
mod ssh_sessions;
mod support;
pub mod types;

use std::sync::Arc;

use anyhow::Result;

use context::AppContext;

pub use types::{
    SpawnSessionRequest, SshConnectRequest, SshConnectResult, SshDirectoryEntry,
    SshDirectoryEntryType, SshDisconnectRequest, SshDisconnectResult, SshExecRequest,
    SshListDirectoryResult, SshListResult, SshMkdirResult, SshMountRequest, SshReadFileResult,
    SshRunRequest, SshRunResult, SshSessionSpawnRequest, SshUnmountRequest, SshUnmountResult,
    SshWriteFileResult,
};

use crate::{Config, buffer::BufferReadRequest, session::SessionId, ssh::SshCapabilityView};

#[derive(Debug, Clone)]
pub struct LocalSessionService {
    context: Arc<AppContext>,
}

impl LocalSessionService {
    fn new(context: Arc<AppContext>) -> Self {
        Self { context }
    }
}

#[derive(Debug, Clone)]
pub struct SshService {
    context: Arc<AppContext>,
}

impl SshService {
    fn new(context: Arc<AppContext>) -> Self {
        Self { context }
    }
}

#[derive(Debug, Clone)]
pub struct AppState {
    context: Arc<AppContext>,
    local: LocalSessionService,
    ssh: SshService,
}

impl AppState {
    pub fn new(config: Config) -> Self {
        let context = Arc::new(AppContext::new(config));
        let local = LocalSessionService::new(context.clone());
        let ssh = SshService::new(context.clone());
        Self {
            context,
            local,
            ssh,
        }
    }

    pub fn config(&self) -> &Config {
        &self.context.config
    }

    pub fn ssh_capabilities(&self) -> &SshCapabilityView {
        &self.context.ssh_capabilities
    }

    pub fn ssh_capability_probe(&self) -> &crate::ssh::SshCapabilityProbe {
        &self.context.ssh_capability_probe
    }

    pub fn ssh_mount_feature_available(&self) -> bool {
        self.ssh.mount_feature_available()
    }

    pub fn local(&self) -> &LocalSessionService {
        &self.local
    }

    pub fn ssh(&self) -> &SshService {
        &self.ssh
    }

    pub async fn shutdown(&self) -> Result<()> {
        self.ssh.shutdown().await?;
        self.local.shutdown().await
    }

    pub fn read_session(
        &self,
        session_id: &SessionId,
        request: &BufferReadRequest,
    ) -> Result<crate::buffer::BufferReadPage> {
        self.local.read_session(session_id, request)
    }
}