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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::path::PathBuf;

/// systemd service name for TelePi.
pub const SERVICE_NAME: &str = "telepi";

/// Build a systemd user unit file for TelePi.
pub fn build_unit(
    telepi_bin: &str,
    config_path: &str,
    log_dir: &PathBuf,
) -> String {
    let out_log = log_dir.join("telepi.out.log").display().to_string();
    let err_log = log_dir.join("telepi.err.log").display().to_string();

    format!(
        r#"[Unit]
Description=TelePi — Telegram bridge for the Pi coding agent
After=network.target

[Service]
Type=simple
ExecStart={bin} start
Environment=TELEPI_CONFIG={config}
Restart=on-failure
RestartSec=5
StandardOutput=append:{out_log}
StandardError=append:{err_log}

[Install]
WantedBy=default.target
"#,
        bin = telepi_bin,
        config = config_path,
        out_log = out_log,
        err_log = err_log,
    )
}

/// Get the installed unit file path.
pub fn installed_unit_path() -> PathBuf {
    crate::paths::default_systemd_user_dir().join(format!("{SERVICE_NAME}.service"))
}

/// Install the systemd user service: write unit file, enable and start it.
pub fn install(telepi_bin: &str, config_path: &str, log_dir: &PathBuf) -> Result<(), String> {
    let unit_content = build_unit(telepi_bin, config_path, log_dir);
    let unit_path = installed_unit_path();

    if let Some(parent) = unit_path.parent() {
        std::fs::create_dir_all(parent)
            .map_err(|e| format!("failed to create systemd user dir: {e}"))?;
    }

    std::fs::write(&unit_path, unit_content)
        .map_err(|e| format!("failed to write unit file: {e}"))?;

    // Reload, enable, and start
    let _ = std::process::Command::new("systemctl")
        .args(["--user", "daemon-reload"])
        .status();

    let status = std::process::Command::new("systemctl")
        .args(["--user", "enable", "--now", &format!("{SERVICE_NAME}.service")])
        .status()
        .map_err(|e| format!("failed to run systemctl: {e}"))?;

    if !status.success() {
        return Err("systemctl enable --now failed".into());
    }

    Ok(())
}

/// Uninstall the systemd user service: stop, disable, and remove unit file.
pub fn uninstall() -> Result<(), String> {
    let unit_path = installed_unit_path();

    if unit_path.exists() {
        let _ = std::process::Command::new("systemctl")
            .args(["--user", "disable", "--now", &format!("{SERVICE_NAME}.service")])
            .status();

        std::fs::remove_file(&unit_path)
            .map_err(|e| format!("failed to remove unit file: {e}"))?;

        let _ = std::process::Command::new("systemctl")
            .args(["--user", "daemon-reload"])
            .status();
    }

    Ok(())
}

/// Check if the service is currently active.
pub fn is_running() -> bool {
    let output = std::process::Command::new("systemctl")
        .args(["--user", "is-active", &format!("{SERVICE_NAME}.service")])
        .output();

    match output {
        Ok(out) => {
            let status = String::from_utf8_lossy(&out.stdout);
            status.trim() == "active"
        }
        Err(_) => false,
    }
}

/// Stop the service without removing the unit file.
pub fn stop() -> Result<(), String> {
    let unit_path = installed_unit_path();
    if !unit_path.exists() {
        return Err("service not installed".into());
    }

    let status = std::process::Command::new("systemctl")
        .args(["--user", "stop", &format!("{SERVICE_NAME}.service")])
        .status()
        .map_err(|e| format!("failed to run systemctl: {e}"))?;

    if !status.success() {
        return Err("systemctl stop failed".into());
    }

    Ok(())
}

/// Start the service without reinstalling.
pub fn start() -> Result<(), String> {
    let unit_path = installed_unit_path();
    if !unit_path.exists() {
        return Err("service not installed — run `telepi gateway start` first".into());
    }

    let status = std::process::Command::new("systemctl")
        .args(["--user", "start", &format!("{SERVICE_NAME}.service")])
        .status()
        .map_err(|e| format!("failed to run systemctl: {e}"))?;

    if !status.success() {
        return Err("systemctl start failed".into());
    }

    Ok(())
}