Improve TUI OTP readability

crates/storage/src/otp.rs

@@ -433,17 +433,18 @@ pub struct OtpCodeOutcome {
 ///
 /// Frontends use this value instead of deriving TOTP periods or inferring HOTP
 /// behavior from display strings. A timed code carries its exclusive Unix-time
-/// boundary, while a counter-based code identifies the committed HOTP counter.
+/// boundary and complete period for progress presentation, while a
+/// counter-based code identifies the committed HOTP counter.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum OtpCodeValidity {
-    Timed { valid_until: u64 },
+    Timed { valid_until: u64, period: u64 },
     CounterBased { counter: u64 },
 }
 
 impl OtpCodeValidity {
     pub fn valid_until(self) -> Option<u64> {
         match self {
-            Self::Timed { valid_until } => Some(valid_until),
+            Self::Timed { valid_until, .. } => Some(valid_until),
             Self::CounterBased { .. } => None,
         }
     }
@@ -455,6 +456,13 @@ impl OtpCodeValidity {
         }
     }
 
+    pub fn period(self) -> Option<u64> {
+        match self {
+            Self::Timed { period, .. } => Some(period),
+            Self::CounterBased { .. } => None,
+        }
+    }
+
     pub fn remaining_at(self, unix_seconds: u64) -> Option<u64> {
         self.valid_until()
             .map(|valid_until| valid_until.saturating_sub(unix_seconds))
@@ -695,6 +703,7 @@ impl<'a> OtpService<'a> {
                         .checked_add(1)
                         .and_then(|counter| counter.checked_mul(period))
                         .ok_or(OtpError::CounterOverflow)?,
+                    period,
                 },
             });
         }
@@ -743,18 +752,21 @@ impl<'a> OtpService<'a> {
         committer: &mut impl EntryCommitter,
     ) -> Result<OtpCodeOutcome, OtpError> {
         match uri.kind() {
-            OtpKind::Totp => Ok(OtpCodeOutcome {
-                code: uri.code_at(unix_seconds)?,
-                validity: OtpCodeValidity::Timed {
-                    valid_until: {
-                        let period = uri.period().ok_or(OtpError::NotTotp)?;
-                        (unix_seconds / period)
-                            .checked_add(1)
-                            .and_then(|counter| counter.checked_mul(period))
-                            .ok_or(OtpError::CounterOverflow)?
+            OtpKind::Totp => {
+                let period = uri.period().ok_or(OtpError::NotTotp)?;
+                Ok(OtpCodeOutcome {
+                    code: uri.code_at(unix_seconds)?,
+                    validity: OtpCodeValidity::Timed {
+                        valid_until: {
+                            (unix_seconds / period)
+                                .checked_add(1)
+                                .and_then(|counter| counter.checked_mul(period))
+                                .ok_or(OtpError::CounterOverflow)?
+                        },
+                        period,
                     },
-                },
-            }),
+                })
+            }
             OtpKind::Hotp => {
                 let (counter, incremented) = uri.incremented_hotp()?;
                 let code = incremented.code_for_counter(counter)?;

crates/storage/tests/otp.rs

@@ -478,7 +478,14 @@ fn automatic_code_supports_pass_diff_config_and_opens_git_only_for_hotp() -> Tes
     let totp = service.code_automatic("otp/totp", 59, None, &mut provider)?;
     assert_eq!(totp.counter(), None);
     assert_eq!(totp.valid_until(), Some(60));
-    assert_eq!(totp.validity(), OtpCodeValidity::Timed { valid_until: 60 });
+    assert_eq!(
+        totp.validity(),
+        OtpCodeValidity::Timed {
+            valid_until: 60,
+            period: 30,
+        }
+    );
+    assert_eq!(totp.validity().period(), Some(30));
     assert_eq!(totp.remaining_at(59), Some(1));
     assert_eq!(totp.remaining_at(60), Some(0));
     assert_eq!(repository.read_entry(&totp_path)?, totp_before);
@@ -494,6 +501,7 @@ fn automatic_code_supports_pass_diff_config_and_opens_git_only_for_hotp() -> Tes
         OtpCodeValidity::CounterBased { counter: 1 }
     );
     assert_eq!(hotp.remaining_at(0), None);
+    assert_eq!(hotp.validity().period(), None);
     assert_eq!(service.uri("otp/hotp", &mut provider)?.counter(), Some(1));
     let git = GitRepository::open(&repository, identity)?;
     assert_eq!(git.log(None)?.len(), initial_commits + 1);