claudy 0.2.1

Modern multi-provider launcher for Claude CLI
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
146
147
148
149
150
151
152
153
154
155
156
157

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Platform {
    Telegram,
    Slack,
    Discord,
}

impl Platform {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Telegram => "telegram",
            Self::Slack => "slack",
            Self::Discord => "discord",
        }
    }

    pub fn max_message_length(&self) -> usize {
        match self {
            Self::Telegram => 4096,
            Self::Discord => 2000,
            Self::Slack => 40000,
        }
    }
}

#[derive(Debug, Clone)]
pub struct ChannelIdentity {
    pub platform: Platform,
    pub channel_id: String,
    pub user_id: String,
    pub thread_id: Option<String>,
    /// Discord guild (server) ID, or Slack team/workspace ID.
    pub guild_id: Option<String>,
}

impl ChannelIdentity {
    pub fn new(
        platform: Platform,
        channel_id: impl Into<String>,
        user_id: impl Into<String>,
        thread_id: Option<String>,
        guild_id: Option<String>,
    ) -> Self {
        Self {
            platform,
            channel_id: channel_id.into(),
            user_id: user_id.into(),
            thread_id,
            guild_id,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ConversationId(pub String);

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

impl ConversationId {
    pub fn new() -> Self {
        Self(uuid::Uuid::new_v4().to_string())
    }

    pub fn from_platform(platform: Platform, id: &str) -> Self {
        Self(format!("{}-{}", platform.as_str(), id))
    }
}

#[derive(Debug, Clone)]
pub enum IncomingEvent {
    TextMessage(TextMessage),
    BotCommand {
        command: String,
        args: String,
        channel: ChannelIdentity,
        conversation_id: ConversationId,
    },
    Interaction(InteractionEvent),
    Attachment(AttachmentEvent),
}

#[derive(Debug, Clone)]
pub struct TextMessage {
    pub conversation_id: ConversationId,
    pub channel: ChannelIdentity,
    pub text: String,
    pub reply_to_id: Option<String>,
}

#[derive(Debug, Clone)]
pub struct InteractionEvent {
    pub conversation_id: ConversationId,
    pub channel: ChannelIdentity,
    /// The callback action parsed from data (e.g. "sess", "proj", "model").
    pub action_id: String,
    /// The payload after the action prefix (e.g. session ID prefix, encoded dir, model name).
    pub message_ref: String,
    /// Platform-specific message reference for the message containing the button.
    /// Used to dismiss the keyboard by editing the original message.
    /// - Telegram: message_id as string (e.g. "200")
    /// - Discord: message snowflake (e.g. "123456789012345678")
    /// - Slack: composite "channel:ts" (e.g. "C12345:1234567890.654321")
    pub callback_message_id: Option<String>,
    /// The platform's callback query ID (e.g. Telegram callback_query ID).
    /// Used for answerCallbackQuery to dismiss the loading spinner.
    pub callback_query_id: Option<String>,
    /// Original text of the message that contained the buttons.
    /// Used to preserve the question text when dismissing the keyboard.
    pub original_text: Option<String>,
}

#[derive(Debug, Clone)]
pub struct AttachmentEvent {
    pub conversation_id: ConversationId,
    pub channel: ChannelIdentity,
    pub file_name: String,
    pub mime_type: String,
    pub content: Vec<u8>,
}

#[derive(Debug, Clone)]
pub struct OutboundMessage {
    pub conversation_id: ConversationId,
    pub channel: ChannelIdentity,
    pub text: String,
    pub message_ref: Option<String>,
    pub interaction: Option<InteractionButtons>,
}

#[derive(Debug, Clone)]
pub struct InteractionButtons {
    pub prompt_text: String,
    pub buttons: Vec<Button>,
}

#[derive(Debug, Clone)]
pub struct Button {
    pub id: String,
    pub label: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PermissionDecision {
    Allow,
    Deny,
}

#[derive(Debug, Clone)]
pub struct MessageDelivery {
    pub platform_message_id: String,
}