opencrabs 0.3.13

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Install with: cargo install opencrabs
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

//! Trello Integration
//!
//! Polls Trello board(s) for new card comments, routes them to the AI,
//! and replies by posting comments back on the card.

mod agent;
pub mod client;
pub(crate) mod handler;
pub mod models;

pub use agent::TrelloAgent;
pub use client::TrelloClient;

use tokio::sync::Mutex;

/// Shared Trello state — holds credentials after connect.
/// Read by the `trello_send` tool to perform proactive card operations.
pub struct TrelloState {
    api_key: Mutex<Option<String>>,
    api_token: Mutex<Option<String>>,
    /// Bot's own Trello member ID — set at connect, used to skip own comments.
    bot_member_id: Mutex<Option<String>>,
    connected: Mutex<bool>,
}

impl Default for TrelloState {
    fn default() -> Self {
        Self::new()
    }
}

impl TrelloState {
    pub fn new() -> Self {
        Self {
            api_key: Mutex::new(None),
            api_token: Mutex::new(None),
            bot_member_id: Mutex::new(None),
            connected: Mutex::new(false),
        }
    }

    /// Store credentials once successfully verified.
    pub async fn set_credentials(&self, api_key: String, api_token: String) {
        *self.api_key.lock().await = Some(api_key);
        *self.api_token.lock().await = Some(api_token);
    }

    /// Store the bot's own member ID (set from `GET /members/me`).
    pub async fn set_bot_member_id(&self, id: String) {
        *self.bot_member_id.lock().await = Some(id);
    }

    /// Mark the agent as connected / disconnected.
    pub async fn set_connected(&self, val: bool) {
        *self.connected.lock().await = val;
    }

    /// Return `true` if the agent has successfully authenticated.
    pub async fn is_connected(&self) -> bool {
        *self.connected.lock().await
    }

    /// Return the stored API key + token pair, if available.
    pub async fn credentials(&self) -> Option<(String, String)> {
        let key = self.api_key.lock().await.clone()?;
        let token = self.api_token.lock().await.clone()?;
        Some((key, token))
    }

    /// Return the bot's Trello member ID.
    pub async fn bot_member_id(&self) -> Option<String> {
        self.bot_member_id.lock().await.clone()
    }
}