Struct BeeperClient 

pub struct BeeperClient { /* private fields */ }

Main Beeper API client

Stores the bearer token and base URL for API requests. All requests to the API will include the token in the Authorization header.

Implementations

impl BeeperClient

pub async fn list_chats( &self, cursor: Option<&str>, direction: Option<&str>, ) -> Result<ListChatsOutput>

Lists all chats sorted by last activity

Combines all accounts into a single paginated list.

Examples found in repository

examples/fetch_chats.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_chats");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats
    println!("📋 Fetching chats from Beeper...");
    let chats_response = client.list_chats(None, None).await?;

    // Extract chat names into a vector using the display_name method
    let chat_names: Vec<String> = chats_response
        .items
        .iter()
        .map(|chat| chat.display_name())
        .collect();

    // Display results
    println!("✅ Successfully retrieved {} chats:", chat_names.len());
    println!();

    if chat_names.is_empty() {
        println!("No chats found.");
    } else {
        for (index, name) in chat_names.iter().enumerate() {
            println!("  {}. {}", index + 1, name);
        }
    }

    println!();
    println!("Chat names as array:");
    println!("{:#?}", chat_names);

    Ok(())
}

examples/send_message.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example send_message");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats to find the first non-group chat
    println!("📋 Fetching chats...");
    let chats_response = client.list_chats(None, None).await?;

    if chats_response.items.is_empty() {
        println!("❌ No chats found!");
        return Ok(());
    }

    // Find the first single (non-group) chat
    let single_chat = chats_response
        .items
        .iter()
        .find(|chat| chat.chat_type == "single");

    if let Some(chat) = single_chat {
        let chat_id = &chat.id;
        let chat_title = &chat.title;

        println!("✅ Found {} chats", chats_response.items.len());
        println!();
        println!("💬 Sending message to first single chat: '{}'", chat_title);
        println!("   Chat ID: {}", chat_id);
        println!();

        // Create the message input
        let message_input = SendMessageInput {
            text: "Hello".to_string(),
            reply_to_id: None,
        };

        // Send the message
        let response = client.send_message(chat_id, message_input).await?;

        println!("✅ Message sent successfully!");
        println!();
        println!("Message Details:");
        println!("  Chat ID: {}", response.chat_id);
        println!("  Pending Message ID: {}", response.pending_message_id);
        println!();
        println!("Full response (JSON):");
        println!("{:#?}", response);
    } else {
        println!("❌ No single (non-group) chats found!");
        println!();
        println!("Available chats:");
        for (index, chat) in chats_response.items.iter().enumerate() {
            println!("  {}. {} ({})", index + 1, chat.title, chat.chat_type);
        }
    }

    Ok(())
}

examples/fetch_messages.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_messages");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats to find the first one
    println!("📋 Fetching chats...");
    let chats_response = client.list_chats(None, None).await?;

    if chats_response.items.is_empty() {
        println!("❌ No chats found!");
        return Ok(());
    }

    // Get the first chat
    let first_chat = &chats_response.items[0];
    let chat_id = &first_chat.id;
    let chat_title = &first_chat.title;

    println!("✅ Found {} chats", chats_response.items.len());
    println!();
    println!("📬 Fetching messages from first chat: '{}'", chat_title);
    println!("   Chat ID: {}", chat_id);
    println!();

    // Fetch messages from the first chat
    let messages_response = client.list_messages(chat_id, None, None).await?;

    println!("✅ Successfully retrieved {} messages:", messages_response.items.len());
    println!();

    if messages_response.items.is_empty() {
        println!("No messages found in this chat.");
    } else {
        // Display messages with formatting
        for (index, message) in messages_response.items.iter().enumerate() {
            let sender = message.sender_name.as_deref().unwrap_or("Unknown");
            let text = message.text.as_deref().unwrap_or("[No text content]");
            let timestamp = &message.timestamp;

            // Show attachments count if any
            let attachment_info = if let Some(attachments) = &message.attachments {
                format!(" [+{} attachment(s)]", attachments.len())
            } else {
                String::new()
            };

            // Show reactions count if any
            let reaction_info = if let Some(reactions) = &message.reactions {
                format!(" [+{} reaction(s)]", reactions.len())
            } else {
                String::new()
            };

            // Show reply indicator if replying to another message
            let reply_info = if message.reply_to_id.is_some() {
                " [↩️ Reply]".to_string()
            } else {
                String::new()
            };

            println!("  {}. [{}] {}: {}{}{}{}", 
                index + 1, 
                timestamp, 
                sender, 
                text,
                attachment_info,
                reaction_info,
                reply_info
            );
        }
    }

    println!();
    println!("Message details (JSON):");
    println!("{:#?}", messages_response.items);

    // Show pagination info if available
    if messages_response.has_more {
        println!();
        println!("ℹ️  More messages available. Use pagination to fetch older/newer messages.");
    }

    Ok(())
}

pub async fn get_chat(&self, chat_id: &str) -> Result<Chat>

Retrieves details for a specific chat

Returns chat metadata, participants, and latest message

pub async fn create_chat( &self, input: CreateChatInput, ) -> Result<CreateChatOutput>

Creates a new chat

Creates a single or group chat on a specific account using participant IDs

pub async fn archive_chat(&self, chat_id: &str, archived: bool) -> Result<Chat>

Archives or unarchives a chat

pub async fn set_chat_reminder( &self, chat_id: &str, timestamp: &str, ) -> Result<Chat>

Sets a reminder for a chat

pub async fn clear_chat_reminder(&self, chat_id: &str) -> Result<Chat>

Clears a reminder from a chat

impl BeeperClient

pub async fn list_messages( &self, chat_id: &str, cursor: Option<&str>, direction: Option<&str>, ) -> Result<ListMessagesOutput>

Lists all messages in a chat

Paginated message list sorted by timestamp.

Examples found in repository

examples/fetch_messages.rs (line 45)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_messages");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats to find the first one
    println!("📋 Fetching chats...");
    let chats_response = client.list_chats(None, None).await?;

    if chats_response.items.is_empty() {
        println!("❌ No chats found!");
        return Ok(());
    }

    // Get the first chat
    let first_chat = &chats_response.items[0];
    let chat_id = &first_chat.id;
    let chat_title = &first_chat.title;

    println!("✅ Found {} chats", chats_response.items.len());
    println!();
    println!("📬 Fetching messages from first chat: '{}'", chat_title);
    println!("   Chat ID: {}", chat_id);
    println!();

    // Fetch messages from the first chat
    let messages_response = client.list_messages(chat_id, None, None).await?;

    println!("✅ Successfully retrieved {} messages:", messages_response.items.len());
    println!();

    if messages_response.items.is_empty() {
        println!("No messages found in this chat.");
    } else {
        // Display messages with formatting
        for (index, message) in messages_response.items.iter().enumerate() {
            let sender = message.sender_name.as_deref().unwrap_or("Unknown");
            let text = message.text.as_deref().unwrap_or("[No text content]");
            let timestamp = &message.timestamp;

            // Show attachments count if any
            let attachment_info = if let Some(attachments) = &message.attachments {
                format!(" [+{} attachment(s)]", attachments.len())
            } else {
                String::new()
            };

            // Show reactions count if any
            let reaction_info = if let Some(reactions) = &message.reactions {
                format!(" [+{} reaction(s)]", reactions.len())
            } else {
                String::new()
            };

            // Show reply indicator if replying to another message
            let reply_info = if message.reply_to_id.is_some() {
                " [↩️ Reply]".to_string()
            } else {
                String::new()
            };

            println!("  {}. [{}] {}: {}{}{}{}", 
                index + 1, 
                timestamp, 
                sender, 
                text,
                attachment_info,
                reaction_info,
                reply_info
            );
        }
    }

    println!();
    println!("Message details (JSON):");
    println!("{:#?}", messages_response.items);

    // Show pagination info if available
    if messages_response.has_more {
        println!();
        println!("ℹ️  More messages available. Use pagination to fetch older/newer messages.");
    }

    Ok(())
}

pub async fn send_message( &self, chat_id: &str, input: SendMessageInput, ) -> Result<SendMessageOutput>

Sends a message to a chat

Sends a text message to a specific chat. Supports replying to existing messages. Returns the sent message ID.

Examples found in repository

examples/send_message.rs (line 56)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example send_message");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats to find the first non-group chat
    println!("📋 Fetching chats...");
    let chats_response = client.list_chats(None, None).await?;

    if chats_response.items.is_empty() {
        println!("❌ No chats found!");
        return Ok(());
    }

    // Find the first single (non-group) chat
    let single_chat = chats_response
        .items
        .iter()
        .find(|chat| chat.chat_type == "single");

    if let Some(chat) = single_chat {
        let chat_id = &chat.id;
        let chat_title = &chat.title;

        println!("✅ Found {} chats", chats_response.items.len());
        println!();
        println!("💬 Sending message to first single chat: '{}'", chat_title);
        println!("   Chat ID: {}", chat_id);
        println!();

        // Create the message input
        let message_input = SendMessageInput {
            text: "Hello".to_string(),
            reply_to_id: None,
        };

        // Send the message
        let response = client.send_message(chat_id, message_input).await?;

        println!("✅ Message sent successfully!");
        println!();
        println!("Message Details:");
        println!("  Chat ID: {}", response.chat_id);
        println!("  Pending Message ID: {}", response.pending_message_id);
        println!();
        println!("Full response (JSON):");
        println!("{:#?}", response);
    } else {
        println!("❌ No single (non-group) chats found!");
        println!();
        println!("Available chats:");
        for (index, chat) in chats_response.items.iter().enumerate() {
            println!("  {}. {} ({})", index + 1, chat.title, chat.chat_type);
        }
    }

    Ok(())
}

impl BeeperClient

pub async fn get_accounts(&self) -> Result<GetAccountsOutput>

Lists all connected messaging accounts

Lists chat accounts across networks (WhatsApp, Telegram, Twitter/X, etc.) actively connected to this Beeper Desktop instance

Examples found in repository

examples/fetch_accounts.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_accounts");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all accounts
    println!("👤 Fetching connected accounts...");
    let accounts = client.get_accounts().await?;

    println!("✅ Successfully retrieved {} account(s):", accounts.len());
    println!();

    if accounts.is_empty() {
        println!("No accounts connected.");
    } else {
        // Display accounts with formatting
        for (index, account) in accounts.iter().enumerate() {
            let account_id = &account.account_id;
            let network = &account.network;
            let user = &account.user;

            // Build user identifier
            let user_identifier = if let Some(full_name) = &user.full_name {
                full_name.clone()
            } else if let Some(username) = &user.username {
                format!("@{}", username)
            } else if let Some(phone) = &user.phone_number {
                phone.clone()
            } else {
                user.id.clone()
            };

            println!("  {}. {} Account", index + 1, network);
            println!("     └─ User: {}", user_identifier);
            println!("     └─ Account ID: {}", account_id);
            println!("     └─ User ID: {}", user.id);

            // Show additional user info if available
            if let Some(username) = &user.username {
                println!("     └─ Username: @{}", username);
            }
            if let Some(phone) = &user.phone_number {
                println!("     └─ Phone: {}", phone);
            }
            if let Some(email) = &user.email {
                println!("     └─ Email: {}", email);
            }
            if let Some(cannot_message) = user.cannot_message {
                if cannot_message {
                    println!("     └─ ⚠️  Cannot initiate messages to this user");
                }
            }

            println!();
        }
    }

    println!("Account details (JSON):");
    println!("{:#?}", accounts);

    Ok(())
}

impl BeeperClient

pub async fn search_messages( &self, query: &str, cursor: Option<&str>, direction: Option<&str>, ) -> Result<SearchMessagesOutput>

Searches messages across chats

Uses Beeper’s message index for full-text search.

Examples found in repository

examples/search.rs (line 54)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example search");
            std::process::exit(1);
        });

    // Get search query from command line arguments or use default
    let search_query = env::args()
        .nth(1)
        .unwrap_or_else(|| "hello".to_string());

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!("Searching for: \"{}\"", search_query);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Search for chats
    println!("🔍 Searching chats...");
    let chats_search = client.search_chats(&search_query, None, None).await?;
    
    println!("✅ Found {} matching chat(s):", chats_search.items.len());
    println!();

    if chats_search.items.is_empty() {
        println!("No chats found matching \"{}\"", search_query);
    } else {
        for (index, chat) in chats_search.items.iter().enumerate() {
            println!("  {}. {} ({})", index + 1, chat.title, chat.chat_type);
            println!("     └─ Network: {}", chat.network);
            println!("     └─ Participants: {}", chat.participants.total);
            println!("     └─ Unread: {}", chat.unread_count);
            if let Some(last_activity) = &chat.last_activity {
                println!("     └─ Last Activity: {}", last_activity);
            }
            println!();
        }
    }

    // Search for messages
    println!("📨 Searching messages...");
    let messages_search = client.search_messages(&search_query, None, None).await?;
    
    println!("✅ Found {} matching message(s):", messages_search.items.len());
    println!();

    if messages_search.items.is_empty() {
        println!("No messages found matching \"{}\"", search_query);
    } else {
        // Group messages by chat for better display
        let mut chats_in_results = std::collections::HashMap::new();
        
        for message in &messages_search.items {
            chats_in_results
                .entry(message.chat_id.clone())
                .or_insert_with(Vec::new)
                .push(message);
        }

        for (chat_id, messages) in &chats_in_results {
            // Get chat title from search results if available
            let chat_title = if let Some(chat) = messages_search.chats.as_ref()
                .and_then(|chats| chats.get(chat_id))
            {
                chat.title.clone()
            } else {
                chat_id.clone()
            };

            println!("  Chat: {}", chat_title);
            println!("  └─ {} message(s) found:", messages.len());

            for (msg_index, message) in messages.iter().enumerate() {
                let sender = message.sender_name.as_deref().unwrap_or("Unknown");
                let text = message.text.as_deref().unwrap_or("[No text content]");
                
                // Truncate long messages
                let display_text = if text.len() > 60 {
                    format!("{}...", &text[..60])
                } else {
                    text.to_string()
                };

                println!("     {}. [{}] {}: {}", 
                    msg_index + 1,
                    message.timestamp,
                    sender,
                    display_text
                );
            }
            println!();
        }
    }

    // Show pagination info if available
    if messages_search.has_more {
        println!("ℹ️  More results available. Use pagination with:");
        println!("    - oldestCursor: {:?}", messages_search.oldest_cursor);
        println!("    - newestCursor: {:?}", messages_search.newest_cursor);
    }

    // Display search summary
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📊 Search Summary for \"{}\":", search_query);
    println!("  • Chats: {}", chats_search.items.len());
    println!("  • Messages: {}", messages_search.items.len());
    println!("  • Total Results: {}", chats_search.items.len() + messages_search.items.len());
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    Ok(())
}

pub async fn search_chats( &self, query: &str, cursor: Option<&str>, direction: Option<&str>, ) -> Result<SearchChatsOutput>

Searches chats by title, network, or participants

Uses Beeper Desktop’s renderer algorithm.

Examples found in repository

examples/search.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example search");
            std::process::exit(1);
        });

    // Get search query from command line arguments or use default
    let search_query = env::args()
        .nth(1)
        .unwrap_or_else(|| "hello".to_string());

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!("Searching for: \"{}\"", search_query);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Search for chats
    println!("🔍 Searching chats...");
    let chats_search = client.search_chats(&search_query, None, None).await?;
    
    println!("✅ Found {} matching chat(s):", chats_search.items.len());
    println!();

    if chats_search.items.is_empty() {
        println!("No chats found matching \"{}\"", search_query);
    } else {
        for (index, chat) in chats_search.items.iter().enumerate() {
            println!("  {}. {} ({})", index + 1, chat.title, chat.chat_type);
            println!("     └─ Network: {}", chat.network);
            println!("     └─ Participants: {}", chat.participants.total);
            println!("     └─ Unread: {}", chat.unread_count);
            if let Some(last_activity) = &chat.last_activity {
                println!("     └─ Last Activity: {}", last_activity);
            }
            println!();
        }
    }

    // Search for messages
    println!("📨 Searching messages...");
    let messages_search = client.search_messages(&search_query, None, None).await?;
    
    println!("✅ Found {} matching message(s):", messages_search.items.len());
    println!();

    if messages_search.items.is_empty() {
        println!("No messages found matching \"{}\"", search_query);
    } else {
        // Group messages by chat for better display
        let mut chats_in_results = std::collections::HashMap::new();
        
        for message in &messages_search.items {
            chats_in_results
                .entry(message.chat_id.clone())
                .or_insert_with(Vec::new)
                .push(message);
        }

        for (chat_id, messages) in &chats_in_results {
            // Get chat title from search results if available
            let chat_title = if let Some(chat) = messages_search.chats.as_ref()
                .and_then(|chats| chats.get(chat_id))
            {
                chat.title.clone()
            } else {
                chat_id.clone()
            };

            println!("  Chat: {}", chat_title);
            println!("  └─ {} message(s) found:", messages.len());

            for (msg_index, message) in messages.iter().enumerate() {
                let sender = message.sender_name.as_deref().unwrap_or("Unknown");
                let text = message.text.as_deref().unwrap_or("[No text content]");
                
                // Truncate long messages
                let display_text = if text.len() > 60 {
                    format!("{}...", &text[..60])
                } else {
                    text.to_string()
                };

                println!("     {}. [{}] {}: {}", 
                    msg_index + 1,
                    message.timestamp,
                    sender,
                    display_text
                );
            }
            println!();
        }
    }

    // Show pagination info if available
    if messages_search.has_more {
        println!("ℹ️  More results available. Use pagination with:");
        println!("    - oldestCursor: {:?}", messages_search.oldest_cursor);
        println!("    - newestCursor: {:?}", messages_search.newest_cursor);
    }

    // Display search summary
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📊 Search Summary for \"{}\":", search_query);
    println!("  • Chats: {}", chats_search.items.len());
    println!("  • Messages: {}", messages_search.items.len());
    println!("  • Total Results: {}", chats_search.items.len() + messages_search.items.len());
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    Ok(())
}

impl BeeperClient

pub async fn focus_app( &self, input: Option<FocusAppInput>, ) -> Result<FocusAppOutput>

Focuses Beeper Desktop and optionally navigates to a specific location

Examples found in repository

examples/focus_app.rs (line 60)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example focus_app [chat_id] [message_id] [draft_text]");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Get optional arguments
    let args: Vec<String> = env::args().collect();
    let chat_id = args.get(1).cloned();
    let message_id = args.get(2).cloned();
    let draft_text = args.get(3).cloned();

    // Create focus input based on arguments
    let focus_input = if chat_id.is_some() || message_id.is_some() || draft_text.is_some() {
        Some(FocusAppInput {
            chat_id: chat_id.clone(),
            message_id: message_id.clone(),
            draft: draft_text.clone(),
        })
    } else {
        None
    };

    // Determine what we're doing
    if let Some(ref input) = focus_input {
        println!("🔍 Focusing Beeper with parameters:");
        if let Some(ref cid) = input.chat_id {
            println!("  Chat ID: {}", cid);
        }
        if let Some(ref mid) = input.message_id {
            println!("  Message ID: {}", mid);
        }
        if let Some(ref draft) = input.draft {
            println!("  Draft: {}", draft);
        }
        println!();
    } else {
        println!("🎯 Focusing Beeper Desktop (no parameters)");
        println!();
    }

    // Focus the app
    match client.focus_app(focus_input).await {
        Ok(response) => {
            if response.success {
                println!("✅ Successfully focused Beeper Desktop!");
                println!();
                if draft_text.is_some() {
                    println!("💬 Draft text has been pre-filled in the chat");
                }
                if chat_id.is_some() {
                    println!("📍 Navigated to the specified chat");
                }
                if message_id.is_some() {
                    println!("💭 Navigated to the specified message");
                }
            } else {
                println!("⚠️  Focus operation completed but returned success: false");
            }
            println!();
            println!("Response:");
            println!("{:#?}", response);
        }
        Err(e) => {
            eprintln!("Error: {}", e);
            std::process::exit(1);
        }
    }

    Ok(())
}

pub async fn download_asset(&self, url: &str) -> Result<DownloadAssetOutput>

Downloads an asset from a URL

Downloads a Matrix asset using its mxc:// or localmxc:// URL to the device running Beeper Desktop and returns the local file URL.

impl BeeperClient

pub fn new(token: impl Into<String>, base_url: impl Into<String>) -> Self

Creates a new Beeper API client

Arguments

• token - Bearer token for authentication
• base_url - Base URL of the Beeper Desktop API server

Examples found in repository

examples/fetch_chats.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_chats");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats
    println!("📋 Fetching chats from Beeper...");
    let chats_response = client.list_chats(None, None).await?;

    // Extract chat names into a vector using the display_name method
    let chat_names: Vec<String> = chats_response
        .items
        .iter()
        .map(|chat| chat.display_name())
        .collect();

    // Display results
    println!("✅ Successfully retrieved {} chats:", chat_names.len());
    println!();

    if chat_names.is_empty() {
        println!("No chats found.");
    } else {
        for (index, name) in chat_names.iter().enumerate() {
            println!("  {}. {}", index + 1, name);
        }
    }

    println!();
    println!("Chat names as array:");
    println!("{:#?}", chat_names);

    Ok(())
}

examples/send_message.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example send_message");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats to find the first non-group chat
    println!("📋 Fetching chats...");
    let chats_response = client.list_chats(None, None).await?;

    if chats_response.items.is_empty() {
        println!("❌ No chats found!");
        return Ok(());
    }

    // Find the first single (non-group) chat
    let single_chat = chats_response
        .items
        .iter()
        .find(|chat| chat.chat_type == "single");

    if let Some(chat) = single_chat {
        let chat_id = &chat.id;
        let chat_title = &chat.title;

        println!("✅ Found {} chats", chats_response.items.len());
        println!();
        println!("💬 Sending message to first single chat: '{}'", chat_title);
        println!("   Chat ID: {}", chat_id);
        println!();

        // Create the message input
        let message_input = SendMessageInput {
            text: "Hello".to_string(),
            reply_to_id: None,
        };

        // Send the message
        let response = client.send_message(chat_id, message_input).await?;

        println!("✅ Message sent successfully!");
        println!();
        println!("Message Details:");
        println!("  Chat ID: {}", response.chat_id);
        println!("  Pending Message ID: {}", response.pending_message_id);
        println!();
        println!("Full response (JSON):");
        println!("{:#?}", response);
    } else {
        println!("❌ No single (non-group) chats found!");
        println!();
        println!("Available chats:");
        for (index, chat) in chats_response.items.iter().enumerate() {
            println!("  {}. {} ({})", index + 1, chat.title, chat.chat_type);
        }
    }

    Ok(())
}

examples/fetch_accounts.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_accounts");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all accounts
    println!("👤 Fetching connected accounts...");
    let accounts = client.get_accounts().await?;

    println!("✅ Successfully retrieved {} account(s):", accounts.len());
    println!();

    if accounts.is_empty() {
        println!("No accounts connected.");
    } else {
        // Display accounts with formatting
        for (index, account) in accounts.iter().enumerate() {
            let account_id = &account.account_id;
            let network = &account.network;
            let user = &account.user;

            // Build user identifier
            let user_identifier = if let Some(full_name) = &user.full_name {
                full_name.clone()
            } else if let Some(username) = &user.username {
                format!("@{}", username)
            } else if let Some(phone) = &user.phone_number {
                phone.clone()
            } else {
                user.id.clone()
            };

            println!("  {}. {} Account", index + 1, network);
            println!("     └─ User: {}", user_identifier);
            println!("     └─ Account ID: {}", account_id);
            println!("     └─ User ID: {}", user.id);

            // Show additional user info if available
            if let Some(username) = &user.username {
                println!("     └─ Username: @{}", username);
            }
            if let Some(phone) = &user.phone_number {
                println!("     └─ Phone: {}", phone);
            }
            if let Some(email) = &user.email {
                println!("     └─ Email: {}", email);
            }
            if let Some(cannot_message) = user.cannot_message {
                if cannot_message {
                    println!("     └─ ⚠️  Cannot initiate messages to this user");
                }
            }

            println!();
        }
    }

    println!("Account details (JSON):");
    println!("{:#?}", accounts);

    Ok(())
}

examples/focus_app.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example focus_app [chat_id] [message_id] [draft_text]");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Get optional arguments
    let args: Vec<String> = env::args().collect();
    let chat_id = args.get(1).cloned();
    let message_id = args.get(2).cloned();
    let draft_text = args.get(3).cloned();

    // Create focus input based on arguments
    let focus_input = if chat_id.is_some() || message_id.is_some() || draft_text.is_some() {
        Some(FocusAppInput {
            chat_id: chat_id.clone(),
            message_id: message_id.clone(),
            draft: draft_text.clone(),
        })
    } else {
        None
    };

    // Determine what we're doing
    if let Some(ref input) = focus_input {
        println!("🔍 Focusing Beeper with parameters:");
        if let Some(ref cid) = input.chat_id {
            println!("  Chat ID: {}", cid);
        }
        if let Some(ref mid) = input.message_id {
            println!("  Message ID: {}", mid);
        }
        if let Some(ref draft) = input.draft {
            println!("  Draft: {}", draft);
        }
        println!();
    } else {
        println!("🎯 Focusing Beeper Desktop (no parameters)");
        println!();
    }

    // Focus the app
    match client.focus_app(focus_input).await {
        Ok(response) => {
            if response.success {
                println!("✅ Successfully focused Beeper Desktop!");
                println!();
                if draft_text.is_some() {
                    println!("💬 Draft text has been pre-filled in the chat");
                }
                if chat_id.is_some() {
                    println!("📍 Navigated to the specified chat");
                }
                if message_id.is_some() {
                    println!("💭 Navigated to the specified message");
                }
            } else {
                println!("⚠️  Focus operation completed but returned success: false");
            }
            println!();
            println!("Response:");
            println!("{:#?}", response);
        }
        Err(e) => {
            eprintln!("Error: {}", e);
            std::process::exit(1);
        }
    }

    Ok(())
}

examples/fetch_messages.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example fetch_messages");
            std::process::exit(1);
        });

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Fetch all chats to find the first one
    println!("📋 Fetching chats...");
    let chats_response = client.list_chats(None, None).await?;

    if chats_response.items.is_empty() {
        println!("❌ No chats found!");
        return Ok(());
    }

    // Get the first chat
    let first_chat = &chats_response.items[0];
    let chat_id = &first_chat.id;
    let chat_title = &first_chat.title;

    println!("✅ Found {} chats", chats_response.items.len());
    println!();
    println!("📬 Fetching messages from first chat: '{}'", chat_title);
    println!("   Chat ID: {}", chat_id);
    println!();

    // Fetch messages from the first chat
    let messages_response = client.list_messages(chat_id, None, None).await?;

    println!("✅ Successfully retrieved {} messages:", messages_response.items.len());
    println!();

    if messages_response.items.is_empty() {
        println!("No messages found in this chat.");
    } else {
        // Display messages with formatting
        for (index, message) in messages_response.items.iter().enumerate() {
            let sender = message.sender_name.as_deref().unwrap_or("Unknown");
            let text = message.text.as_deref().unwrap_or("[No text content]");
            let timestamp = &message.timestamp;

            // Show attachments count if any
            let attachment_info = if let Some(attachments) = &message.attachments {
                format!(" [+{} attachment(s)]", attachments.len())
            } else {
                String::new()
            };

            // Show reactions count if any
            let reaction_info = if let Some(reactions) = &message.reactions {
                format!(" [+{} reaction(s)]", reactions.len())
            } else {
                String::new()
            };

            // Show reply indicator if replying to another message
            let reply_info = if message.reply_to_id.is_some() {
                " [↩️ Reply]".to_string()
            } else {
                String::new()
            };

            println!("  {}. [{}] {}: {}{}{}{}", 
                index + 1, 
                timestamp, 
                sender, 
                text,
                attachment_info,
                reaction_info,
                reply_info
            );
        }
    }

    println!();
    println!("Message details (JSON):");
    println!("{:#?}", messages_response.items);

    // Show pagination info if available
    if messages_response.has_more {
        println!();
        println!("ℹ️  More messages available. Use pagination to fetch older/newer messages.");
    }

    Ok(())
}

examples/search.rs (line 28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get authentication token from environment variable
    let token = env::var("BEEPER_TOKEN")
        .unwrap_or_else(|_| {
            eprintln!("Error: BEEPER_TOKEN environment variable not set");
            eprintln!("Usage: BEEPER_TOKEN=your_token cargo run --example search");
            std::process::exit(1);
        });

    // Get search query from command line arguments or use default
    let search_query = env::args()
        .nth(1)
        .unwrap_or_else(|| "hello".to_string());

    // Get API base URL from environment variable or use default
    let base_url = env::var("BEEPER_API_URL")
        .unwrap_or_else(|_| "http://localhost:23373".to_string());

    println!("Connecting to Beeper Desktop API at: {}", base_url);
    println!("Searching for: \"{}\"", search_query);
    println!();

    // Create a client with the provided token
    let client = BeeperClient::new(&token, &base_url);

    // Search for chats
    println!("🔍 Searching chats...");
    let chats_search = client.search_chats(&search_query, None, None).await?;
    
    println!("✅ Found {} matching chat(s):", chats_search.items.len());
    println!();

    if chats_search.items.is_empty() {
        println!("No chats found matching \"{}\"", search_query);
    } else {
        for (index, chat) in chats_search.items.iter().enumerate() {
            println!("  {}. {} ({})", index + 1, chat.title, chat.chat_type);
            println!("     └─ Network: {}", chat.network);
            println!("     └─ Participants: {}", chat.participants.total);
            println!("     └─ Unread: {}", chat.unread_count);
            if let Some(last_activity) = &chat.last_activity {
                println!("     └─ Last Activity: {}", last_activity);
            }
            println!();
        }
    }

    // Search for messages
    println!("📨 Searching messages...");
    let messages_search = client.search_messages(&search_query, None, None).await?;
    
    println!("✅ Found {} matching message(s):", messages_search.items.len());
    println!();

    if messages_search.items.is_empty() {
        println!("No messages found matching \"{}\"", search_query);
    } else {
        // Group messages by chat for better display
        let mut chats_in_results = std::collections::HashMap::new();
        
        for message in &messages_search.items {
            chats_in_results
                .entry(message.chat_id.clone())
                .or_insert_with(Vec::new)
                .push(message);
        }

        for (chat_id, messages) in &chats_in_results {
            // Get chat title from search results if available
            let chat_title = if let Some(chat) = messages_search.chats.as_ref()
                .and_then(|chats| chats.get(chat_id))
            {
                chat.title.clone()
            } else {
                chat_id.clone()
            };

            println!("  Chat: {}", chat_title);
            println!("  └─ {} message(s) found:", messages.len());

            for (msg_index, message) in messages.iter().enumerate() {
                let sender = message.sender_name.as_deref().unwrap_or("Unknown");
                let text = message.text.as_deref().unwrap_or("[No text content]");
                
                // Truncate long messages
                let display_text = if text.len() > 60 {
                    format!("{}...", &text[..60])
                } else {
                    text.to_string()
                };

                println!("     {}. [{}] {}: {}", 
                    msg_index + 1,
                    message.timestamp,
                    sender,
                    display_text
                );
            }
            println!();
        }
    }

    // Show pagination info if available
    if messages_search.has_more {
        println!("ℹ️  More results available. Use pagination with:");
        println!("    - oldestCursor: {:?}", messages_search.oldest_cursor);
        println!("    - newestCursor: {:?}", messages_search.newest_cursor);
    }

    // Display search summary
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📊 Search Summary for \"{}\":", search_query);
    println!("  • Chats: {}", chats_search.items.len());
    println!("  • Messages: {}", messages_search.items.len());
    println!("  • Total Results: {}", chats_search.items.len() + messages_search.items.len());
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    Ok(())
}

pub fn with_token(token: impl Into<String>) -> Self

Creates a new Beeper API client with default base URL

Arguments

• token - Bearer token for authentication

pub fn set_token(&mut self, token: impl Into<String>)

Updates the bearer token

pub fn set_base_url(&mut self, base_url: impl Into<String>)

Updates the base URL

pub fn base_url(&self) -> &str

Gets the current base URL

Trait Implementations

impl Clone for BeeperClient

fn clone(&self) -> BeeperClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.