aidaemon 0.11.10

A personal AI agent that runs as a background daemon, accessible via Telegram, Slack, or Discord, with tool use, MCP integration, and persistent memory
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

use async_trait::async_trait;
use serde_json::{json, Value};

use crate::traits::{Tool, ToolCapabilities, ToolRole};

pub struct SystemInfoTool;

#[async_trait]
impl Tool for SystemInfoTool {
    fn name(&self) -> &str {
        "system_info"
    }

    fn description(&self) -> &str {
        "Get system information including CPU and memory usage"
    }

    fn schema(&self) -> Value {
        json!({
            "name": "system_info",
            "description": "Get system information including CPU and memory usage",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
                "additionalProperties": false
            }
        })
    }

    fn tool_role(&self) -> ToolRole {
        ToolRole::Universal
    }

    fn capabilities(&self) -> ToolCapabilities {
        ToolCapabilities {
            read_only: true,
            external_side_effect: false,
            needs_approval: false,
            idempotent: true,
            high_impact_write: false,
        }
    }

    async fn call(&self, _arguments: &str) -> anyhow::Result<String> {
        let mut info = String::new();

        // Current date and time
        if let Ok(output) = tokio::process::Command::new("date").output().await {
            let date = String::from_utf8_lossy(&output.stdout).trim().to_string();
            info.push_str(&format!("Date: {}\n", date));
        }

        // Hostname
        if let Ok(output) = tokio::process::Command::new("hostname").output().await {
            let hostname = String::from_utf8_lossy(&output.stdout).trim().to_string();
            info.push_str(&format!("Hostname: {}\n", hostname));
        }

        // OS info
        if let Ok(output) = tokio::process::Command::new("uname")
            .arg("-a")
            .output()
            .await
        {
            let uname = String::from_utf8_lossy(&output.stdout).trim().to_string();
            info.push_str(&format!("OS: {}\n", uname));
        }

        // Uptime
        if let Ok(output) = tokio::process::Command::new("uptime").output().await {
            let uptime = String::from_utf8_lossy(&output.stdout).trim().to_string();
            info.push_str(&format!("Uptime: {}\n", uptime));
        }

        // Memory (works on both Linux and macOS)
        #[cfg(target_os = "linux")]
        {
            if let Ok(output) = tokio::process::Command::new("free")
                .arg("-h")
                .output()
                .await
            {
                let mem = String::from_utf8_lossy(&output.stdout).trim().to_string();
                info.push_str(&format!("Memory:\n{}\n", mem));
            }
        }

        #[cfg(target_os = "macos")]
        {
            if let Ok(output) = tokio::process::Command::new("vm_stat").output().await {
                let mem = String::from_utf8_lossy(&output.stdout).trim().to_string();
                info.push_str(&format!("Memory:\n{}\n", mem));
            }
        }

        if info.is_empty() {
            info.push_str("Could not retrieve system information.");
        }

        Ok(info)
    }
}