Skip to main content

Kitty

kitty_rc::client

Struct Kitty 

Source 
pub struct Kitty { /* private fields */ }

Implementations§

Source§

impl Kitty

Source

pub fn builder() -> KittyBuilder

Examples found in repository?
examples/test-simple-command.rs (line 5)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    let mut kitty = Kitty::builder()
6        .socket_path("/run/user/1000/kitty-101555.sock")
7        .connect()
8        .await?;
9
10    let cmd = CommandBuilder::new("ls").build();
11    let result = kitty.execute(&cmd).await;
12    println!("LS Result: {:?}", result);
13
14    Ok(())
15}
More examples
Hide additional examples
examples/test-encrypted-simple.rs (line 5)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    let mut kitty = Kitty::builder()
6        .socket_path("/run/user/1000/kitty-101555.sock")
7        .password("0pD4cLsKze84eCYOh7dIlvMFF87rgHEPSkngVpgbtYJ9hAzJ")
8        .connect()
9        .await?;
10
11    let cmd = CommandBuilder::new("ls").build();
12    let result = kitty.execute(&cmd).await;
13    println!("LS Result: {:?}", result);
14
15    Ok(())
16}
examples/test-debug.rs (line 7)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    // Test without password
6    println!("=== Testing without password ===");
7    let mut kitty = Kitty::builder()
8        .socket_path("/run/user/1000/kitty-101555.sock")
9        .connect()
10        .await?;
11
12    let cmd = CommandBuilder::new("ls").build();
13    println!("Command: {:?}", cmd);
14    let result = kitty.execute(&cmd).await;
15    println!("Result: {:?}", result);
16
17    Ok(())
18}
examples/test_font.rs (line 5)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    let mut kitty = Kitty::builder()
6        .socket_path("/run/user/1000/kitty-757336.sock")
7        .password("0pD4cLsKze84eCYOh7dIlvMFF87rgHEPSkngVpgbtYJ9hAzJ")
8        .connect()
9        .await?;
10
11    println!("Testing set-font-size increment command...");
12    
13    // Try increment
14    let cmd = SetFontSizeCommand::builder()
15        .size(0.0)
16        .increment_op("+".to_string())
17        .build()
18        .to_message()?;
19
20    let result = kitty.execute(&cmd).await?;
21    println!("Increment result: ok={}, data={:?}, error={:?}", result.ok, result.data, result.error);
22
23    Ok(())
24}
examples/test-connectivity.rs (line 11)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    // Find kitty socket
6    let socket_path = find_kitty_socket()?;
7
8    println!("Connecting to: {}", socket_path);
9
10    // Test basic connection
11    let mut kitty = Kitty::builder()
12        .socket_path(&socket_path)
13        .connect()
14        .await
15        .map_err(|e| format!("Connection failed: {}", e))?;
16
17    println!("✓ Connected successfully!");
18
19    // Test sending a simple command
20    use kitty_rc::command::CommandBuilder;
21
22    let cmd = CommandBuilder::new("ls")
23        .build();
24
25    match kitty.execute(&cmd).await {
26        Ok(response) => {
27            println!("✓ Command executed successfully!");
28            if let Some(data) = response.data {
29                println!("Response: {}", data);
30            }
31        }
32        Err(e) => {
33            eprintln!("✗ Command failed: {}", e);
34        }
35    }
36
37    Ok(())
38}
examples/test-encrypted.rs (line 12)
5async fn main() -> Result<(), Box<dyn std::error::Error>> {
6    // Find kitty socket
7    let socket_path = find_kitty_socket()?;
8
9    println!("Connecting to: {}", socket_path);
10
11    // Test encrypted connection
12    let mut kitty = Kitty::builder()
13        .socket_path(&socket_path)
14        .password(&read_password()?)
15        .connect()
16        .await
17        .map_err(|e| format!("Connection failed: {}", e))?;
18
19    println!("✓ Connected successfully (encrypted)!");
20
21    // Test sending a simple command
22    use kitty_rc::command::CommandBuilder;
23
24    let cmd = CommandBuilder::new("ls")
25        .build();
26
27    match kitty.execute(&cmd).await {
28        Ok(response) => {
29            println!("✓ Encrypted command executed successfully!");
30            println!("  Response: {:?}", response);
31        }
32        Err(e) => {
33            eprintln!("✗ Encrypted command failed: {}", e);
34            if let Some(source) = Error::source(&e) {
35                eprintln!("  Error source: {}", source);
36            }
37        }
38    }
39
40    Ok(())
41}
Source

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

Examples found in repository?
examples/test-simple-command.rs (line 11)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    let mut kitty = Kitty::builder()
6        .socket_path("/run/user/1000/kitty-101555.sock")
7        .connect()
8        .await?;
9
10    let cmd = CommandBuilder::new("ls").build();
11    let result = kitty.execute(&cmd).await;
12    println!("LS Result: {:?}", result);
13
14    Ok(())
15}
More examples
Hide additional examples
examples/test-encrypted-simple.rs (line 12)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    let mut kitty = Kitty::builder()
6        .socket_path("/run/user/1000/kitty-101555.sock")
7        .password("0pD4cLsKze84eCYOh7dIlvMFF87rgHEPSkngVpgbtYJ9hAzJ")
8        .connect()
9        .await?;
10
11    let cmd = CommandBuilder::new("ls").build();
12    let result = kitty.execute(&cmd).await;
13    println!("LS Result: {:?}", result);
14
15    Ok(())
16}
examples/test-debug.rs (line 14)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    // Test without password
6    println!("=== Testing without password ===");
7    let mut kitty = Kitty::builder()
8        .socket_path("/run/user/1000/kitty-101555.sock")
9        .connect()
10        .await?;
11
12    let cmd = CommandBuilder::new("ls").build();
13    println!("Command: {:?}", cmd);
14    let result = kitty.execute(&cmd).await;
15    println!("Result: {:?}", result);
16
17    Ok(())
18}
examples/test_font.rs (line 20)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    let mut kitty = Kitty::builder()
6        .socket_path("/run/user/1000/kitty-757336.sock")
7        .password("0pD4cLsKze84eCYOh7dIlvMFF87rgHEPSkngVpgbtYJ9hAzJ")
8        .connect()
9        .await?;
10
11    println!("Testing set-font-size increment command...");
12    
13    // Try increment
14    let cmd = SetFontSizeCommand::builder()
15        .size(0.0)
16        .increment_op("+".to_string())
17        .build()
18        .to_message()?;
19
20    let result = kitty.execute(&cmd).await?;
21    println!("Increment result: ok={}, data={:?}, error={:?}", result.ok, result.data, result.error);
22
23    Ok(())
24}
examples/test-connectivity.rs (line 25)
4async fn main() -> Result<(), Box<dyn std::error::Error>> {
5    // Find kitty socket
6    let socket_path = find_kitty_socket()?;
7
8    println!("Connecting to: {}", socket_path);
9
10    // Test basic connection
11    let mut kitty = Kitty::builder()
12        .socket_path(&socket_path)
13        .connect()
14        .await
15        .map_err(|e| format!("Connection failed: {}", e))?;
16
17    println!("✓ Connected successfully!");
18
19    // Test sending a simple command
20    use kitty_rc::command::CommandBuilder;
21
22    let cmd = CommandBuilder::new("ls")
23        .build();
24
25    match kitty.execute(&cmd).await {
26        Ok(response) => {
27            println!("✓ Command executed successfully!");
28            if let Some(data) = response.data {
29                println!("Response: {}", data);
30            }
31        }
32        Err(e) => {
33            eprintln!("✗ Command failed: {}", e);
34        }
35    }
36
37    Ok(())
38}
examples/test-encrypted.rs (line 27)
5async fn main() -> Result<(), Box<dyn std::error::Error>> {
6    // Find kitty socket
7    let socket_path = find_kitty_socket()?;
8
9    println!("Connecting to: {}", socket_path);
10
11    // Test encrypted connection
12    let mut kitty = Kitty::builder()
13        .socket_path(&socket_path)
14        .password(&read_password()?)
15        .connect()
16        .await
17        .map_err(|e| format!("Connection failed: {}", e))?;
18
19    println!("✓ Connected successfully (encrypted)!");
20
21    // Test sending a simple command
22    use kitty_rc::command::CommandBuilder;
23
24    let cmd = CommandBuilder::new("ls")
25        .build();
26
27    match kitty.execute(&cmd).await {
28        Ok(response) => {
29            println!("✓ Encrypted command executed successfully!");
30            println!("  Response: {:?}", response);
31        }
32        Err(e) => {
33            eprintln!("✗ Encrypted command failed: {}", e);
34            if let Some(source) = Error::source(&e) {
35                eprintln!("  Error source: {}", source);
36            }
37        }
38    }
39
40    Ok(())
41}
Source

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

Source

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

Source

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

Source

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

Source

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

Trait Implementations§

Source§

impl Drop for Kitty

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more

Auto Trait Implementations§

§

impl !Freeze for Kitty

§

impl RefUnwindSafe for Kitty

§

impl Send for Kitty

§

impl Sync for Kitty

§

impl Unpin for Kitty

§

impl UnwindSafe for Kitty

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.