Struct KittyBuilder 

pub struct KittyBuilder { /* private fields */ }

Implementations

impl KittyBuilder

pub fn new() -> Self

pub fn socket_path<P: AsRef<Path>>(self, path: P) -> Self

Examples found in repository

examples/test-connectivity.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 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 13)

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 fn timeout(self, duration: Duration) -> Self

pub fn password(self, password: impl Into<String>) -> Self

Examples found in repository

examples/test-encrypted.rs (line 14)

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 fn public_key(self, public_key: impl Into<String>) -> Self

Set kitty’s public key explicitly.

Format: 1:<base85_encoded_key> where 1 is protocol version.

When set, this key is used instead of querying KITTY_PUBLIC_KEY env var or kitty-pubkey-db database.

Example:

use kitty_rc::Kitty;
let kitty = Kitty::builder()
    .socket_path("/run/user/1000/kitty-12345.sock")
    .password("your-password")
    .public_key("1:z3;{}!NzNzgiXreB&ywA!8y1H8hq^$cMG!OE$QNa")
    .connect()
    .await?;

pub async fn connect(self) -> Result<Kitty, KittyError>

Connect to kitty instance with configured authentication.

Public key resolution order (when password is set):

1. Explicit key set via .public_key() method
2. Query kitty-pubkey-db database (extracts PID from socket path)
3. KITTY_PUBLIC_KEY environment variable (set by kitty when launching subprocesses)

When no password is set, no encryption is used.

Examples found in repository

examples/test-connectivity.rs (line 13)

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 15)

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(())
}