Add typed SSH remote endpoints

crates/storage/src/mobile_authentication.rs

@@ -593,15 +593,7 @@ impl MobileAuthentication {
         drop(status);
         let repository_title = remote.map_or_else(
             || "Local Password Store".to_owned(),
-            |remote| {
-                remote
-                    .url()
-                    .path_segments()
-                    .and_then(Iterator::last)
-                    .unwrap_or("Password Store")
-                    .trim_end_matches(".git")
-                    .to_owned()
-            },
+            remote_repository_title,
         );
         Ok(MobilePreferences {
             sync_configured: remote.is_some(),
@@ -611,12 +603,23 @@ impl MobileAuthentication {
                 |remote| remote.url().to_string(),
             ),
             server_title: remote
-                .and_then(|remote| remote.url().host_str())
+                .and_then(|remote| {
+                    remote
+                        .endpoint()
+                        .as_https()
+                        .and_then(url::Url::host_str)
+                        .or_else(|| remote.endpoint().as_ssh().map(|ssh| ssh.host()))
+                })
                 .unwrap_or("Git Sync Not Configured")
                 .to_owned(),
             server_identity: remote.map_or_else(
                 || "Add an HTTPS remote when you want to sync".to_owned(),
-                |remote| remote.server_id().as_str().to_owned(),
+                |remote| {
+                    remote.https_credentials().map_or_else(
+                        || "SSH identity and host trust".to_owned(),
+                        |(server_id, _)| server_id.as_str().to_owned(),
+                    )
+                },
             ),
             application_account: remote.map(application_account).transpose()?.flatten(),
             default_key_title: key
@@ -673,7 +676,10 @@ impl MobileAuthentication {
             .ok_or_else(|| config_detail("No HTTPS Git remote is configured."))?;
         let store = preference_secret_store()?;
         store.unlock().map_err(preference_secret_error)?;
-        let result = store.delete_https_git_credential(remote.server_id(), remote.application_id());
+        let (server_id, application_id) = remote.https_credentials().ok_or_else(|| {
+            config_detail("The configured Git remote does not use HTTPS credentials.")
+        })?;
+        let result = store.delete_https_git_credential(server_id, application_id);
         let lock_result = store.lock();
         if !matches!(result, Ok(()) | Err(SecretStoreError::Missing)) {
             return Err(preference_secret_error(result.expect_err("checked error")));
@@ -1558,9 +1564,12 @@ fn preference_secret_store() -> Result<NativeSecretStore, MobileAuthenticationEr
 }
 
 fn application_account(remote: &GitRemote) -> Result<Option<String>, MobileAuthenticationError> {
+    let Some((server_id, application_id)) = remote.https_credentials() else {
+        return Ok(None);
+    };
     let store = preference_secret_store()?;
     store.unlock().map_err(preference_secret_error)?;
-    let result = store.https_git_credential_account(remote.server_id(), remote.application_id());
+    let result = store.https_git_credential_account(server_id, application_id);
     let lock_result = store.lock();
     let account = match result {
         Ok(account) => Some(account),
@@ -1572,6 +1581,26 @@ fn application_account(remote: &GitRemote) -> Result<Option<String>, MobileAuthe
         .map(|()| account)
 }
 
+fn remote_repository_title(remote: &GitRemote) -> String {
+    let path = remote.endpoint().as_https().map_or_else(
+        || {
+            remote
+                .endpoint()
+                .as_ssh()
+                .map(|ssh| ssh.path().as_str())
+                .unwrap_or_default()
+        },
+        |url| url.path(),
+    );
+    path.trim_end_matches('/')
+        .rsplit('/')
+        .next()
+        .filter(|name| !name.is_empty())
+        .unwrap_or("Password Store")
+        .trim_end_matches(".git")
+        .to_owned()
+}
+
 fn preference_secret_error(error: SecretStoreError) -> MobileAuthenticationError {
     MobileAuthenticationError::new(
         MobileAuthenticationErrorKind::SecureStorage,