feat: enhance error handling with structured error types

- Add specific error variants for connection timeouts and retry failures
- Replace generic ObsOperationError with contextual error messages
- Eliminate unsafe unwrap() calls in URL parsing
- Improve WebSocket URL parsing with detailed error context
- Add ConnectionTimeout, AllConnectionAttemptsFailed, and WebSocketUrlParseError variants

Author: g

src/cli.rs

@@ -22,7 +22,10 @@ impl FromStr for ObsWebsocket {
                     );
                 }
 
-                let hostname = unvalidated_websocket.host().unwrap().to_string();
+                let hostname = unvalidated_websocket
+                    .host()
+                    .ok_or("Invalid hostname in URL")?
+                    .to_string();
 
                 let port =
                     match unvalidated_websocket.port() {

src/connection.rs

@@ -45,9 +45,9 @@ pub async fn connect_with_retry(
                 last_error = Some(ObsCmdError::ConnectionError(e));
             }
             Err(_) => {
-                last_error = Some(ObsCmdError::ObsOperationError(
-                    "Connection timeout".to_string(),
-                ));
+                last_error = Some(ObsCmdError::ConnectionTimeout {
+                    timeout: config.timeout_duration.as_secs(),
+                });
             }
         }
 
@@ -62,14 +62,16 @@ pub async fn connect_with_retry(
     }
 
     Err(last_error.unwrap_or_else(|| {
-        ObsCmdError::ObsOperationError("All connection attempts failed".to_string())
+        ObsCmdError::AllConnectionAttemptsFailed {
+            attempts: config.max_retries,
+        }
     }))
 }
 
 pub async fn check_connection_health(client: &Client) -> Result<()> {
     timeout(Duration::from_secs(5), client.general().version())
         .await
-        .map_err(|_| ObsCmdError::ObsOperationError("Connection health check timeout".to_string()))?
+        .map_err(|_| ObsCmdError::ConnectionTimeout { timeout: 5 })?
         .map_err(ObsCmdError::ConnectionError)?;
 
     Ok(())

src/error.rs

@@ -40,8 +40,22 @@ pub enum ObsCmdError {
     #[error("No last replay found")]
     NoLastReplay,
 
+    #[allow(dead_code)]
     #[error("OBS operation failed: {0}")]
     ObsOperationError(String),
+
+    #[allow(dead_code)]
+    #[error("Invalid URL format: {0}")]
+    InvalidUrlFormat(String),
+
+    #[error("Connection timeout after {timeout} seconds")]
+    ConnectionTimeout { timeout: u64 },
+
+    #[error("All {attempts} connection attempts failed")]
+    AllConnectionAttemptsFailed { attempts: u32 },
+
+    #[error("WebSocket URL parsing failed: {0}")]
+    WebSocketUrlParseError(String),
 }
 
 pub type Result<T> = std::result::Result<T, ObsCmdError>;

src/main.rs

@@ -6,7 +6,7 @@ mod handler;
 use clap::Parser;
 use cli::{Cli, ObsWebsocket};
 use connection::{connect_with_retry, ConnectionConfig};
-use error::Result;
+use error::{ObsCmdError, Result};
 use handler::handle_commands;
 
 #[tokio::main]
@@ -21,15 +21,27 @@ async fn main() -> Result<()> {
             let parsed_url = url::Url::parse(&url)?;
             let hostname = parsed_url
                 .host_str()
-                .ok_or(url::ParseError::RelativeUrlWithoutBase)?
+                .ok_or_else(|| {
+                    ObsCmdError::WebSocketUrlParseError(
+                        "Missing hostname in WebSocket URL".to_string(),
+                    )
+                })?
                 .to_string();
             let port = parsed_url
                 .port()
-                .ok_or(url::ParseError::RelativeUrlWithoutBase)?;
+                .ok_or_else(|| {
+                    ObsCmdError::WebSocketUrlParseError(
+                        "Missing port in WebSocket URL".to_string(),
+                    )
+                })?;
             let password = parsed_url
                 .path_segments()
                 .and_then(|mut segments| segments.next())
-                .ok_or(url::ParseError::RelativeUrlWithoutBase)?;
+                .ok_or_else(|| {
+                    ObsCmdError::WebSocketUrlParseError(
+                        "Missing password in WebSocket URL path".to_string(),
+                    )
+                })?;
 
             connect_with_retry(hostname, port, Some(password.to_string()), config).await?
         }