Skip to content

Commit 45d41d3

Browse files
committed
fix(auth): preserve sessions across app restarts
1 parent 033a437 commit 45d41d3

13 files changed

Lines changed: 1006 additions & 124 deletions

‎src-tauri/src/device_activation.rs‎

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -66,12 +66,15 @@ pub struct ActivatedResult {
6666
pub device_id: String,
6767
pub limit: u32,
6868
pub used: u32,
69-
/// Device-bound 30-day lease — persisted into the session store.
70-
/// The backend keeps `access_token`-style snake_case for token fields;
71-
/// `refreshToken` is aliased because camelCase responses were observed
72-
/// in the wild and a silent None here is what kills session renewal.
73-
#[serde(rename = "refresh_token", alias = "refreshToken", default)]
69+
/// Accept the API's snake_case token and expose camelCase over IPC.
70+
#[serde(alias = "refresh_token", default)]
7471
pub refresh_token: Option<String>,
72+
#[serde(
73+
alias = "access_token",
74+
default,
75+
skip_serializing_if = "Option::is_none"
76+
)]
77+
pub access_token: Option<String>,
7578
}
7679

7780
fn device_limit_error(info: &DeviceLimitInfo) -> String {
@@ -196,6 +199,7 @@ pub async fn activate_device(
196199
}
197200
let payload = state.payload();
198201

202+
let mut rotated_access = None;
199203
let mut attempt = post_activate(&token, &payload, replace_device_id.as_deref()).await;
200204
if let ActivateAttempt::Unauthorized = attempt {
201205
let lease = refresh_token.as_deref().unwrap_or("").trim();
@@ -206,6 +210,7 @@ pub async fn activate_device(
206210
json!({
207211
"accessToken": refreshed.access_token,
208212
"refreshToken": refreshed.refresh_token,
213+
"previousRefreshToken": refreshed.previous_refresh_token,
209214
}),
210215
);
211216
attempt = post_activate(
@@ -214,14 +219,18 @@ pub async fn activate_device(
214219
replace_device_id.as_deref(),
215220
)
216221
.await;
222+
rotated_access = Some(refreshed.access_token);
217223
}
218224
}
219225
}
220226

221227
match attempt {
222228
// The device-bound lease rides back to the frontend, which persists
223229
// it alongside the rest of the account session.
224-
ActivateAttempt::Ok(result) => Ok(result),
230+
ActivateAttempt::Ok(mut result) => {
231+
result.access_token = rotated_access;
232+
Ok(result)
233+
}
225234
ActivateAttempt::LimitReached(info) => Err(device_limit_error(&info)),
226235
ActivateAttempt::Unauthorized => Err("session expired — please sign in again".to_string()),
227236
ActivateAttempt::Failed(message) => Err(message),
@@ -296,6 +305,9 @@ mod tests {
296305
});
297306
let result: ActivatedResult = serde_json::from_value(raw).expect("result");
298307
assert_eq!(result.refresh_token.as_deref(), Some("opaque-lease"));
308+
let ipc = serde_json::to_value(&result).expect("IPC result");
309+
assert_eq!(ipc["refreshToken"], "opaque-lease");
310+
assert!(ipc.get("refresh_token").is_none());
299311

300312
// camelCase lease responses must land too — a silent None here is
301313
// exactly what broke session renewal in the field.

‎src-tauri/src/entitlement.rs‎

Lines changed: 66 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -181,6 +181,8 @@ pub struct EntitlementView {
181181
/// Session health verdict (`SESSION_PHASE_*`) — see the constant docs.
182182
pub session_phase: &'static str,
183183
pub last_error: Option<String>,
184+
#[serde(skip_serializing_if = "Option::is_none")]
185+
pub refreshed_session: Option<crate::session::RefreshedSession>,
184186
}
185187

186188
/// Pure entitlement decision. Fail-closed: an unparseable release date or
@@ -274,6 +276,7 @@ impl EntitlementState {
274276
fetched_at_ms: binding.as_ref().map(|c| c.fetched_at_ms),
275277
session_phase,
276278
last_error,
279+
refreshed_session: None,
277280
}
278281
}
279282

@@ -478,7 +481,7 @@ pub async fn refresh_entitlement(
478481
identity: State<'_, crate::device_activation::DeviceIdentityState>,
479482
app: AppHandle,
480483
) -> Result<EntitlementView, String> {
481-
let (view, rotated) = refresh_entitlement_core(
484+
let (mut view, rotated) = refresh_entitlement_core(
482485
&token,
483486
refresh_token.as_deref(),
484487
force,
@@ -488,11 +491,13 @@ pub async fn refresh_entitlement(
488491
)
489492
.await?;
490493
if let Some(refreshed) = rotated {
494+
view.refreshed_session = Some(refreshed.clone());
491495
let _ = app.emit(
492496
"session-refreshed",
493497
json!({
494498
"accessToken": refreshed.access_token,
495499
"refreshToken": refreshed.refresh_token,
500+
"previousRefreshToken": refreshed.previous_refresh_token,
496501
}),
497502
);
498503
}
@@ -713,6 +718,66 @@ mod tests {
713718
.respond_with(wiremock::ResponseTemplate::new(status).set_body_json(body))
714719
}
715720

721+
#[tokio::test]
722+
async fn a_transient_rotation_failure_can_retry_the_same_lease() {
723+
let server = console_server().await;
724+
let lease = format!("transient-{}", uuid::Uuid::new_v4().simple());
725+
let state = crate::session::SessionState::default();
726+
let identity = identity_state("transient-rotation").payload();
727+
let failure = mock_refresh_lease(&lease, 503, json!({ "code": 5000 }))
728+
.expect(1)
729+
.mount_as_scoped(server)
730+
.await;
731+
assert!(crate::session::rotate_session(&state, &lease, &identity)
732+
.await
733+
.is_err());
734+
drop(failure);
735+
let success = mock_refresh_lease(
736+
&lease,
737+
200,
738+
json!({
739+
"code": 2000,
740+
"data": { "access_token": "next-access", "refresh_token": "next-lease" }
741+
}),
742+
)
743+
.expect(1)
744+
.mount_as_scoped(server)
745+
.await;
746+
let rotated = crate::session::rotate_session(&state, &lease, &identity)
747+
.await
748+
.expect("retry after transient failure");
749+
assert_eq!(rotated.previous_refresh_token, lease);
750+
drop(success);
751+
}
752+
753+
#[tokio::test]
754+
async fn concurrent_rotations_share_the_successor_without_replaying_the_lease() {
755+
let server = console_server().await;
756+
let lease = format!("concurrent-{}", uuid::Uuid::new_v4().simple());
757+
let response = mock_refresh_lease(
758+
&lease,
759+
200,
760+
json!({
761+
"code": 2000,
762+
"data": { "access_token": "next-access", "refresh_token": "next-lease" }
763+
}),
764+
)
765+
.expect(1)
766+
.mount_as_scoped(server)
767+
.await;
768+
let state = crate::session::SessionState::default();
769+
let identity = identity_state("concurrent-rotation").payload();
770+
let (first, second) = tokio::join!(
771+
crate::session::rotate_session(&state, &lease, &identity),
772+
crate::session::rotate_session(&state, &lease, &identity),
773+
);
774+
let first = first.expect("first rotation");
775+
let second = second.expect("shared rotation");
776+
assert_eq!(first.refresh_token, second.refresh_token);
777+
assert_eq!(second.previous_refresh_token, lease);
778+
drop(response);
779+
}
780+
716781
#[test]
717782
fn views_carry_the_derived_session_phase() {
718783
let state = EntitlementState::load(None);

‎src-tauri/src/session.rs‎

Lines changed: 38 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -6,13 +6,13 @@
66
//! lease + device identity, receive the successor pair, and classify
77
//! rejections so the frontend can drop dead leases.
88
//!
9-
//! Rotations serialize through `SessionState::rotate_lock`: the lease is
10-
//! single-use and the server treats presenting an already-rotated token as a
11-
//! leak that revokes the device scope, so two concurrent rotations must
12-
//! never race.
9+
//! Successful rotations are shared by callers presenting the same lease so
10+
//! concurrent entitlement and activation requests cannot replay a consumed token,
11+
//! including when the app sleeps between queued callers.
1312
1413
use serde::{Deserialize, Serialize};
1514
use serde_json::json;
15+
use std::collections::VecDeque;
1616
use tauri::{AppHandle, Emitter, State};
1717

1818
use crate::common::console;
@@ -22,10 +22,16 @@ pub const SESSION_REJECTED_ERROR_TYPE: &str = "SESSION_REJECTED";
2222

2323
#[derive(Default)]
2424
pub struct SessionState {
25-
/// See module docs — guards the present-then-replace window.
26-
pub rotate_lock: tokio::sync::Mutex<()>,
25+
rotations: tokio::sync::Mutex<VecDeque<CachedRotation>>,
2726
}
2827

28+
struct CachedRotation {
29+
previous: String,
30+
session: RefreshedSession,
31+
}
32+
33+
const ROTATION_CACHE_LIMIT: usize = 64;
34+
2935
pub fn session_rejected_error(message: &str) -> String {
3036
json!({
3137
"error_type": SESSION_REJECTED_ERROR_TYPE,
@@ -40,6 +46,8 @@ pub struct RefreshedSession {
4046
pub access_token: String,
4147
#[serde(rename = "refresh_token")]
4248
pub refresh_token: String,
49+
#[serde(default, skip_deserializing)]
50+
pub previous_refresh_token: String,
4351
}
4452

4553
/// Exchange a lease for the successor pair. The caller must surface the
@@ -60,7 +68,13 @@ pub async fn rotate_session(
6068
return Err("no stored refresh token".to_string());
6169
}
6270

63-
let _guard = state.rotate_lock.lock().await;
71+
let mut rotations = state.rotations.lock().await;
72+
if let Some(cached) = rotations
73+
.iter()
74+
.find(|entry| entry.previous == refresh_token)
75+
{
76+
return Ok(cached.session.clone());
77+
}
6478
let response = console::client()
6579
.post(format!("{}/api/v1/auth/refresh", console::api_base_url()))
6680
.json(&json!({ "refresh_token": refresh_token, "device": device_payload }))
@@ -89,8 +103,19 @@ pub async fn rotate_session(
89103
}
90104

91105
let data = raw.get("data").cloned().unwrap_or(json!({}));
92-
let session: RefreshedSession =
106+
let mut session: RefreshedSession =
93107
serde_json::from_value(data).map_err(|e| format!("invalid refresh result: {e}"))?;
108+
if !status.is_success() {
109+
return Err(format!("refresh endpoint returned HTTP {status}"));
110+
}
111+
session.previous_refresh_token = refresh_token.to_string();
112+
if rotations.len() >= ROTATION_CACHE_LIMIT {
113+
rotations.pop_front();
114+
}
115+
rotations.push_back(CachedRotation {
116+
previous: refresh_token.to_string(),
117+
session: session.clone(),
118+
});
94119
Ok(session)
95120
}
96121

@@ -114,6 +139,7 @@ pub async fn rotate_session_now(
114139
json!({
115140
"accessToken": refreshed.access_token,
116141
"refreshToken": refreshed.refresh_token,
142+
"previousRefreshToken": refreshed.previous_refresh_token,
117143
}),
118144
);
119145
Ok(refreshed)
@@ -134,7 +160,10 @@ pub async fn revoke_session(refresh_token: Option<String>) -> Result<(), String>
134160
.await
135161
.map_err(|e| format!("network error: {e}"))?;
136162
if !response.status().is_success() {
137-
return Err(format!("logout endpoint returned HTTP {}", response.status()));
163+
return Err(format!(
164+
"logout endpoint returned HTTP {}",
165+
response.status()
166+
));
138167
}
139168
Ok(())
140169
}

0 commit comments

Comments
 (0)