opencrabs 0.5.1

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Recommended: the 40MB prebuilt binary for macOS, Linux and Windows: https://github.com/adolfousier/opencrabs/releases
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

//! Receive-only userbot session persistence tests.

use grammers_session::Session as _;
use grammers_session::types::{DcOption, PeerId, PeerInfo, UpdateState};

use crate::channels::telegram::userbot::session::FileSession;

#[tokio::test]
async fn round_trips_auth_key_peers_and_state() {
    let dir = tempfile::tempdir().expect("tempdir");
    let path = dir.path().join("session.json");
    let session = FileSession::load(&path).expect("fresh load");
    let key = [7u8; 256];
    let dc = DcOption {
        id: 2,
        ipv4: "127.0.0.1:443".parse().expect("ipv4"),
        ipv6: "[::1]:443".parse().expect("ipv6"),
        auth_key: Some(key),
    };

    session.set_dc_option(&dc).await.expect("set dc");
    session
        .cache_peer(&PeerInfo::User {
            id: 42,
            auth: None,
            bot: Some(false),
            is_self: Some(true),
        })
        .await
        .expect("cache peer");
    session
        .set_update_state(UpdateState::Primary {
            pts: 111,
            date: 222,
            seq: 3,
        })
        .await
        .expect("set state");
    session.save().expect("save");

    let reloaded = FileSession::load(&path).expect("reload");
    assert_eq!(
        reloaded
            .dc_option(2)
            .expect("dc read")
            .expect("dc")
            .auth_key,
        Some(key)
    );
    assert!(
        reloaded
            .peer(PeerId::user_unchecked(42))
            .await
            .expect("peer read")
            .is_some()
    );
    let state = reloaded.updates_state().await.expect("state");
    assert_eq!((state.pts, state.date, state.seq), (111, 222, 3));
}

#[cfg(unix)]
#[test]
fn file_is_owner_only() {
    use std::os::unix::fs::PermissionsExt as _;

    let dir = tempfile::tempdir().expect("tempdir");
    let path = dir.path().join("session.json");
    FileSession::load(&path)
        .expect("load")
        .save()
        .expect("save");
    let mode = std::fs::metadata(path)
        .expect("metadata")
        .permissions()
        .mode()
        & 0o777;
    assert_eq!(mode, 0o600);
}

#[test]
fn relative_session_path_is_profile_scoped() {
    let home = crate::config::opencrabs_home();
    let config = crate::config::TelegramUserbotConfig {
        session_path: Some("sessions/userbot.json".to_owned()),
        ..Default::default()
    };
    assert_eq!(
        crate::channels::telegram::userbot::session_file(&config),
        home.join("sessions/userbot.json")
    );
}

#[tokio::test]
async fn failed_dirty_save_is_retried() {
    let dir = tempfile::tempdir().expect("tempdir");
    let blocked_parent = dir.path().join("blocked");
    std::fs::write(&blocked_parent, "not a directory").expect("block parent");
    let path = blocked_parent.join("session.json");
    let session = FileSession::load(&path).expect("load");
    session.set_home_dc_id(4).await.expect("mutate");
    assert!(session.save_if_dirty().is_err());

    std::fs::remove_file(&blocked_parent).expect("remove blocker");
    std::fs::create_dir(&blocked_parent).expect("repair parent");
    session.save_if_dirty().expect("retry dirty save");
    assert_eq!(
        FileSession::load(&path)
            .expect("reload")
            .home_dc_id()
            .expect("home dc"),
        4
    );
}