Struct Kitty 

pub struct Kitty { /* private fields */ }

Implementations

impl Kitty

pub fn builder() -> KittyBuilder

Examples found in repository

examples/test-connectivity.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Find kitty socket
    let socket_path = find_kitty_socket()?;

    println!("Connecting to: {}", socket_path);

    // Test basic connection
    let mut kitty = Kitty::builder()
        .socket_path(&socket_path)
        .connect()
        .await
        .map_err(|e| format!("Connection failed: {}", e))?;

    println!("✓ Connected successfully!");

    // Test sending a simple command
    use kitty_rc::command::CommandBuilder;

    let cmd = CommandBuilder::new("ls")
        .build();

    match kitty.execute(&cmd).await {
        Ok(response) => {
            println!("✓ Command executed successfully!");
            if let Some(data) = response.data {
                println!("Response: {}", data);
            }
        }
        Err(e) => {
            eprintln!("✗ Command failed: {}", e);
        }
    }

    Ok(())
}

examples/test-encrypted.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Find kitty socket
    let socket_path = find_kitty_socket()?;

    println!("Connecting to: {}", socket_path);

    // Test encrypted connection
    let mut kitty = Kitty::builder()
        .socket_path(&socket_path)
        .password(&read_password()?)
        .connect()
        .await
        .map_err(|e| format!("Connection failed: {}", e))?;

    println!("✓ Connected successfully (encrypted)!");

    // Test sending a simple command
    use kitty_rc::command::CommandBuilder;

    let cmd = CommandBuilder::new("ls")
        .build();

    match kitty.execute(&cmd).await {
        Ok(response) => {
            println!("✓ Encrypted command executed successfully!");
            println!("  Response: {:?}", response);
        }
        Err(e) => {
            eprintln!("✗ Encrypted command failed: {}", e);
            if let Some(source) = Error::source(&e) {
                eprintln!("  Error source: {}", source);
            }
        }
    }

    Ok(())
}

pub async fn execute( &mut self, message: &KittyMessage, ) -> Result<KittyResponse, KittyError>

Examples found in repository

examples/test-connectivity.rs (line 25)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Find kitty socket
    let socket_path = find_kitty_socket()?;

    println!("Connecting to: {}", socket_path);

    // Test basic connection
    let mut kitty = Kitty::builder()
        .socket_path(&socket_path)
        .connect()
        .await
        .map_err(|e| format!("Connection failed: {}", e))?;

    println!("✓ Connected successfully!");

    // Test sending a simple command
    use kitty_rc::command::CommandBuilder;

    let cmd = CommandBuilder::new("ls")
        .build();

    match kitty.execute(&cmd).await {
        Ok(response) => {
            println!("✓ Command executed successfully!");
            if let Some(data) = response.data {
                println!("Response: {}", data);
            }
        }
        Err(e) => {
            eprintln!("✗ Command failed: {}", e);
        }
    }

    Ok(())
}

examples/test-encrypted.rs (line 27)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Find kitty socket
    let socket_path = find_kitty_socket()?;

    println!("Connecting to: {}", socket_path);

    // Test encrypted connection
    let mut kitty = Kitty::builder()
        .socket_path(&socket_path)
        .password(&read_password()?)
        .connect()
        .await
        .map_err(|e| format!("Connection failed: {}", e))?;

    println!("✓ Connected successfully (encrypted)!");

    // Test sending a simple command
    use kitty_rc::command::CommandBuilder;

    let cmd = CommandBuilder::new("ls")
        .build();

    match kitty.execute(&cmd).await {
        Ok(response) => {
            println!("✓ Encrypted command executed successfully!");
            println!("  Response: {:?}", response);
        }
        Err(e) => {
            eprintln!("✗ Encrypted command failed: {}", e);
            if let Some(source) = Error::source(&e) {
                eprintln!("  Error source: {}", source);
            }
        }
    }

    Ok(())
}

pub async fn send_all( &mut self, message: &KittyMessage, ) -> Result<(), KittyError>

pub async fn execute_all( &mut self, message: &KittyMessage, ) -> Result<KittyResponse, KittyError>

pub async fn send_command<T: Into<KittyMessage>>( &mut self, command: T, ) -> Result<(), KittyError>

pub async fn reconnect(&mut self) -> Result<(), KittyError>

pub async fn close(&mut self) -> Result<(), KittyError>

Trait Implementations

impl Drop for Kitty

fn drop(&mut self)

Executes the destructor for this type.