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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Manual macOS probe for computer_use native stack.
//!
//! Usage:
//!   computer_use_probe --app Calculator --inspect
//!   computer_use_probe --app Calculator --click-index 3

#[cfg(not(target_os = "macos"))]
fn main() {
    eprintln!("computer_use_probe requires macOS");
    std::process::exit(1);
}

#[cfg(target_os = "macos")]
fn main() {
    use std::env;

    let args: Vec<String> = env::args().collect();
    let mut app = "Calculator".to_string();
    let mut inspect_only = true;
    let mut click_index: Option<u32> = None;
    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--app" => {
                i += 1;
                app = args.get(i).cloned().unwrap_or(app);
            }
            "--inspect" => inspect_only = true,
            "--click-index" => {
                inspect_only = false;
                i += 1;
                click_index = Some(
                    args.get(i)
                        .and_then(|s| s.parse().ok())
                        .expect("--click-index requires a number"),
                );
            }
            _ => {}
        }
        i += 1;
    }

    if let Some(index) = click_index {
        run_click(&app, index);
    } else if inspect_only {
        run_inspect(&app);
    }
}

#[cfg(target_os = "macos")]
fn run_inspect(app: &str) {
    use std::path::PathBuf;

    use aidaemon::computer_use::cache::SnapshotCache;
    use aidaemon::computer_use::harness::{ComputerHarness, HarnessRequestContext};
    use aidaemon::computer_use::macos::MacOsHarness;
    use aidaemon::computer_use::types::format_full_tree;
    use aidaemon::ComputerUseConfig;

    let _ = tracing_subscriber::fmt()
        .with_writer(std::io::stderr)
        .try_init();

    let rt = tokio::runtime::Runtime::new().expect("runtime");
    rt.block_on(async {
        let harness = MacOsHarness::new(ComputerUseConfig {
            enabled: true,
            ..Default::default()
        });
        harness.check_permissions().expect("permissions");
        let ctx = HarnessRequestContext {
            task_id: "probe".into(),
            session_id: "probe".into(),
        };
        let mut cache = SnapshotCache::default();
        let snapshot = harness
            .get_app_state(app, &ctx, &mut cache)
            .await
            .expect("get_app_state");
        println!("{}", format_full_tree(&snapshot));
        let out_path = PathBuf::from("computer_use_probe.png");
        std::fs::write(&out_path, &snapshot.png).expect("write png");
        println!("Wrote screenshot to {}", out_path.display());
    });
}

#[cfg(target_os = "macos")]
fn run_click(app: &str, index: u32) {
    use aidaemon::computer_use::cache::SnapshotCache;
    use aidaemon::computer_use::harness::{ComputerHarness, HarnessRequestContext};
    use aidaemon::computer_use::macos::MacOsHarness;
    use aidaemon::computer_use::types::format_condensed_refresh;
    use aidaemon::ComputerUseConfig;

    let rt = tokio::runtime::Runtime::new().expect("runtime");
    rt.block_on(async {
        let harness = MacOsHarness::new(ComputerUseConfig {
            enabled: true,
            ..Default::default()
        });
        harness.check_permissions().expect("permissions");
        let ctx = HarnessRequestContext {
            task_id: "probe".into(),
            session_id: "probe".into(),
        };
        let mut cache = SnapshotCache::default();
        let snapshot = harness
            .get_app_state(app, &ctx, &mut cache)
            .await
            .expect("get_app_state");
        let generation = snapshot.generation;
        let (after, _, _) = harness
            .click(app, generation, Some(index), None, None, &ctx, &mut cache)
            .await
            .expect("click");
        println!("{}", format_condensed_refresh(&after, Some(index)));
    });
}