Rename setups and add provider reauthentication

server/src/resume.rs

@@ -48,7 +48,7 @@ const AT_LEAST: f64 = 60.0;
 /// How long after the limit was hit to stop waiting.
 ///
 /// Something has to bound it, or a machine that can never be asked -- an
-/// unplugged laptop, a setup somebody edited away -- is retried for ever with
+/// unplugged laptop, a machine somebody edited away -- is retried for ever with
 /// nothing on screen saying so. A day is past the longest window Claude
 /// reports, so reaching this means the wait was never going to end on its own.
 const GIVE_UP: f64 = 24.0 * 60.0 * 60.0;
@@ -123,7 +123,7 @@ async fn sweep(manager: &SessionManager, monitor: &Arc<UsageMonitor>) {
             Step::Send => match manager.resume_now(&owed.session_id) {
                 Ok(message) => tracing::info!(
                     "the limit on {} has lifted; sent \"{message}\" to {}",
-                    owed.setup,
+                    owed.machine,
                     owed.session_id
                 ),
                 Err(err) => {
@@ -144,7 +144,7 @@ async fn sweep(manager: &SessionManager, monitor: &Arc<UsageMonitor>) {
                 // to read on a phone.
                 let why = match snapshot.as_ref().map(|snapshot| &snapshot.state) {
                     Some(UsageState::Ok) => "the limit has not lifted in a day".to_string(),
-                    _ => format!("{} could not be asked for a day", owed.setup),
+                    _ => format!("{} could not be asked for a day", owed.machine),
                 };
                 if let Err(err) = manager.abandon_resume(&owed.session_id, &why) {
                     tracing::error!("couldn't clear {}'s resume: {err:#}", owed.session_id);
@@ -164,18 +164,18 @@ async fn snapshot_for(
     manager: &SessionManager,
     owed: &OwedResume,
 ) -> Option<UsageSnapshot> {
-    let setups: Vec<_> = manager
-        .setups()
+    let machines: Vec<_> = manager
+        .machines()
         .into_iter()
-        .filter(|setup| setup.id == owed.setup)
+        .filter(|machine| machine.id == owed.machine)
         .collect();
-    if setups.is_empty() {
+    if machines.is_empty() {
         return None;
     }
     let provider = owed.provider;
     tokio::task::spawn_blocking(move || {
         monitor
-            .snapshots(&setups)
+            .snapshots(&machines)
             .into_iter()
             .find(|snapshot| snapshot.provider == provider)
     })
@@ -258,7 +258,7 @@ mod tests {
     fn owed(since: f64) -> OwedResume {
         OwedResume {
             session_id: "s1".to_string(),
-            setup: "local".to_string(),
+            machine: "local".to_string(),
             provider: crate::usage::CLAUDE,
             scheduled: ScheduledResume { at: since, since },
         }
@@ -267,8 +267,8 @@ mod tests {
     fn snapshot(state: UsageState, windows: Vec<UsageWindow>) -> UsageSnapshot {
         UsageSnapshot {
             provider: crate::usage::CLAUDE.to_string(),
-            setup: "local".to_string(),
-            setup_name: "this machine".to_string(),
+            machine: "local".to_string(),
+            machine_name: "this machine".to_string(),
             limit_id: None,
             limit_name: None,
             state,