Improve error handling and fix compilation errors

src/certificate.rs

@@ -32,30 +32,29 @@ impl CertificateIdentity {
         let hash_string = hex::encode(hasher.finalize()).to_lowercase();
         let key_path = configuration_path.join("keys").join(hash_string);
         fs::create_dir_all(&key_path)
-            .map_err(|e| format!("Failed to create key directory: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to create key directory: {}", e)))?;
 
         let key_file = key_path.join("key.pem");
         let cert_file = key_path.join("cert.pem");
-        let teams = dev_session
-            .list_teams()
-            .await
-            .map_err(|e| format!("Failed to list teams: {:?}", e))?;
-        let team = teams.first().ok_or("No teams found")?;
+        let teams = dev_session.list_teams().await?;
+        let team = teams
+            .first()
+            .ok_or(Error::Certificate("No teams found".to_string()))?;
         let private_key = if key_file.exists() {
             let key_data = fs::read_to_string(&key_file)
-                .map_err(|e| format!("Failed to read key file: {}", e))?;
+                .map_err(|e| Error::Certificate(format!("Failed to read key file: {}", e)))?;
             PKey::private_key_from_pem(key_data.as_bytes())
-                .map_err(|e| format!("Failed to load private key: {}", e))?
+                .map_err(|e| Error::Certificate(format!("Failed to load private key: {}", e)))?
         } else {
-            let rsa =
-                Rsa::generate(2048).map_err(|e| format!("Failed to generate RSA key: {}", e))?;
-            let key =
-                PKey::from_rsa(rsa).map_err(|e| format!("Failed to create private key: {}", e))?;
+            let rsa = Rsa::generate(2048)
+                .map_err(|e| Error::Certificate(format!("Failed to generate RSA key: {}", e)))?;
+            let key = PKey::from_rsa(rsa)
+                .map_err(|e| Error::Certificate(format!("Failed to create private key: {}", e)))?;
             let pem_data = key
                 .private_key_to_pem_pkcs8()
-                .map_err(|e| format!("Failed to encode private key: {}", e))?;
+                .map_err(|e| Error::Certificate(format!("Failed to encode private key: {}", e)))?;
             fs::write(&key_file, pem_data)
-                .map_err(|e| format!("Failed to save key file: {}", e))?;
+                .map_err(|e| Error::Certificate(format!("Failed to save key file: {}", e)))?;
             key
         };
 
@@ -72,11 +71,12 @@ impl CertificateIdentity {
         {
             cert_identity.certificate = Some(cert.clone());
 
-            let cert_pem = cert
-                .to_pem()
-                .map_err(|e| format!("Failed to encode certificate to PEM: {}", e))?;
-            fs::write(&cert_identity.cert_file, cert_pem)
-                .map_err(|e| format!("Failed to save certificate file: {}", e))?;
+            let cert_pem = cert.to_pem().map_err(|e| {
+                Error::Certificate(format!("Failed to encode certificate to PEM: {}", e))
+            })?;
+            fs::write(&cert_identity.cert_file, cert_pem).map_err(|e| {
+                Error::Certificate(format!("Failed to save certificate file: {}", e))
+            })?;
 
             return Ok(cert_identity);
         }
@@ -116,7 +116,9 @@ impl CertificateIdentity {
                 }
             }
         }
-        Error::Certificate("No matching certificate found".to_string())
+        Err(Error::Certificate(
+            "No matching certificate found".to_string(),
+        ))
     }
 
     async fn request_new_certificate(
@@ -125,40 +127,40 @@ impl CertificateIdentity {
         team: &DeveloperTeam,
     ) -> Result<(), Error> {
         let mut req_builder = X509ReqBuilder::new()
-            .map_err(|e| format!("Failed to create request builder: {}", e))?;
-        let mut name_builder =
-            X509Name::builder().map_err(|e| format!("Failed to create name builder: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to create request builder: {}", e)))?;
+        let mut name_builder = X509Name::builder()
+            .map_err(|e| Error::Certificate(format!("Failed to create name builder: {}", e)))?;
 
         name_builder
             .append_entry_by_text("C", "US")
-            .map_err(|e| format!("Failed to set country: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set country: {}", e)))?;
         name_builder
             .append_entry_by_text("ST", "STATE")
-            .map_err(|e| format!("Failed to set state: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set state: {}", e)))?;
         name_builder
             .append_entry_by_text("L", "LOCAL")
-            .map_err(|e| format!("Failed to set locality: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set locality: {}", e)))?;
         name_builder
             .append_entry_by_text("O", "ORGNIZATION")
-            .map_err(|e| format!("Failed to set organization: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set organization: {}", e)))?;
         name_builder
             .append_entry_by_text("CN", "CN")
-            .map_err(|e| format!("Failed to set common name: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set common name: {}", e)))?;
 
         req_builder
             .set_subject_name(&name_builder.build())
-            .map_err(|e| format!("Failed to set subject name: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set subject name: {}", e)))?;
         req_builder
             .set_pubkey(&self.private_key)
-            .map_err(|e| format!("Failed to set public key: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to set public key: {}", e)))?;
         req_builder
             .sign(&self.private_key, MessageDigest::sha256())
-            .map_err(|e| format!("Failed to sign request: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to sign request: {}", e)))?;
 
         let csr_pem = req_builder
             .build()
             .to_pem()
-            .map_err(|e| format!("Failed to encode CSR: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to encode CSR: {}", e)))?;
 
         let certificate_id = dev_session
             .submit_development_csr(
@@ -181,23 +183,24 @@ impl CertificateIdentity {
 
         let certificates = dev_session
             .list_all_development_certs(DeveloperDeviceType::Ios, team)
-            .await
-            .map_err(|e| format!("Failed to list certificates: {:?}", e))?;
+            .await?;
 
         let apple_cert = certificates
             .iter()
             .find(|cert| cert.certificate_id == certificate_id)
-            .ok_or("Certificate not found after submission")?;
+            .ok_or(Error::Certificate(
+                "Certificate not found after submission".to_string(),
+            ))?;
 
         let certificate = X509::from_der(&apple_cert.cert_content)
-            .map_err(|e| format!("Failed to parse certificate: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to parse certificate: {}", e)))?;
 
         // Write certificate to disk
-        let cert_pem = certificate
-            .to_pem()
-            .map_err(|e| format!("Failed to encode certificate to PEM: {}", e))?;
+        let cert_pem = certificate.to_pem().map_err(|e| {
+            Error::Certificate(format!("Failed to encode certificate to PEM: {}", e))
+        })?;
         fs::write(&self.cert_file, cert_pem)
-            .map_err(|e| format!("Failed to save certificate file: {}", e))?;
+            .map_err(|e| Error::Certificate(format!("Failed to save certificate file: {}", e)))?;
 
         self.certificate = Some(certificate);
 

src/device.rs

@@ -160,20 +160,3 @@ fn afc_upload_dir<'a>(
         Ok(())
     })
 }
-
-#[tauri::command]
-pub async fn refresh_idevice(window: tauri::Window) {
-    match list_devices().await {
-        Ok(devices) => {
-            window
-                .emit("idevices", devices)
-                .expect("Failed to send devices");
-        }
-        Err(e) => {
-            window
-                .emit("idevices", Vec::<DeviceInfo>::new())
-                .expect("Failed to send error");
-            eprintln!("Failed to list devices: {}", e);
-        }
-    };
-}

src/sideload.rs

@@ -2,10 +2,9 @@
 
 use crate::Error;
 use crate::{
+    certificate::CertificateIdentity,
+    developer_session::DeveloperDeviceType,
     device::{DeviceInfo, install_app},
-    sideloader::{
-        certificate::CertificateIdentity, developer_session::DeveloperDeviceType,
-    },
 };
 use std::{io::Write, path::PathBuf};