telepi 0.2.1

Telegram bridge for the Pi coding agent — Rust implementation
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

pub mod launchd;
pub mod platform;
pub mod systemd;

use crate::install::platform::{ExtensionStatus, Platform, ServiceStatus, TelePiStatus};

/// Install and start the gateway service for the current platform.
pub fn gateway_install(telepi_bin: &str, config_path: &str, log_dir: &std::path::PathBuf) -> Result<(), String> {
    let platform = platform::detect_platform()
        .ok_or("unsupported platform — only macOS and Linux are supported")?;

    match platform {
        Platform::MacOs => launchd::install(telepi_bin, config_path, log_dir),
        Platform::Linux => systemd::install(telepi_bin, config_path, log_dir),
    }
}

/// Stop the gateway service.
pub fn gateway_stop() -> Result<(), String> {
    let platform = platform::detect_platform()
        .ok_or("unsupported platform")?;

    match platform {
        Platform::MacOs => launchd::stop(),
        Platform::Linux => systemd::stop(),
    }
}

/// Start the gateway service (without reinstalling).
pub fn gateway_start() -> Result<(), String> {
    let platform = platform::detect_platform()
        .ok_or("unsupported platform")?;

    match platform {
        Platform::MacOs => launchd::start(),
        Platform::Linux => systemd::start(),
    }
}

/// Uninstall the gateway service.
pub fn gateway_uninstall() -> Result<(), String> {
    let platform = platform::detect_platform()
        .ok_or("unsupported platform")?;

    match platform {
        Platform::MacOs => launchd::uninstall(),
        Platform::Linux => systemd::uninstall(),
    }
}

/// Check if the gateway service is currently running.
pub fn gateway_is_running() -> bool {
    let Some(platform) = platform::detect_platform() else {
        return false;
    };

    match platform {
        Platform::MacOs => launchd::is_running(),
        Platform::Linux => systemd::is_running(),
    }
}

/// Get the current TelePi installation status.
pub async fn get_status() -> TelePiStatus {
    let version = env!("CARGO_PKG_VERSION").to_string();
    let config_path = crate::paths::default_config_path();
    let config_path = if config_path.exists() {
        Some(config_path)
    } else {
        None
    };

    let platform = platform::detect_platform();
    let service = platform.map(|p| {
        let (installed, unit_path) = match p {
            Platform::MacOs => {
                let path = launchd::installed_plist_path();
                (path.exists(), Some(path))
            }
            Platform::Linux => {
                let path = systemd::installed_unit_path();
                (path.exists(), Some(path))
            }
        };

        // TODO: Check if service is actually running
        ServiceStatus {
            installed,
            running: false,
            platform: p,
            unit_path,
        }
    });

    // Check extension status
    let extension = check_extension_status();

    TelePiStatus {
        version,
        config_path,
        service,
        extension,
    }
}

/// Check if the Pi handoff extension is installed.
fn check_extension_status() -> Option<ExtensionStatus> {
    // Look for the extension in common locations
    let pi_ext_dir = crate::paths::home_dir()
        .join(".pi")
        .join("agent")
        .join("extensions");

    let ext_file = pi_ext_dir.join("telepi-handoff.ts");

    if ext_file.exists() {
        Some(ExtensionStatus {
            installed: true,
            path: Some(ext_file),
            method: Some("file"),
        })
    } else {
        Some(ExtensionStatus {
            installed: false,
            path: None,
            method: None,
        })
    }
}