mod browser;
mod factory;
mod knowledge_base;
mod open_resource;
mod semiont_session;
mod signals;
mod stored;
pub use browser::{
Expected, KbReadVerdict, SemiontBrowser, SemiontBrowserConfig, SignInOutcome, SignedIn,
};
pub use factory::{SessionFactory, SessionFactoryOptions};
pub use knowledge_base::{KbSessionStatus, is_valid_hostname};
pub use open_resource::{OpenResource, TabCheck, apply_tab_checks, sort_open_resources};
pub use semiont_session::{
OnAuthFailed, OnSessionError, OpenedSession, Refresh, SemiontSession, SemiontSessionConfig,
SessionRenewer, Validate,
};
pub use signals::{
KbIdentityConflict, PermissionDenied, SessionEndReason, SessionEnded, SessionSignals,
};
pub(crate) use stored::cache_key;
pub use stored::{
ACTIVE_KEY, KNOWLEDGE_BASES_KEY, LAST_VIEWED_RESOURCE_BY_KB_KEY, OPEN_RESOURCES_BY_KB_KEY,
StoredSession, clear_stored_session, is_token_expired, kb_of_session_key, load_knowledge_bases,
save_knowledge_bases, session_key, store_session, stored_session,
};
include!(concat!(env!("OUT_DIR"), "/oauth_clients.rs"));
use crate::timing::{MIN_REFRESH_DELAY, REFRESH_BEFORE_EXP};
use base64::Engine;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use serde_json::Value;
use std::future::Future;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use tokio::sync::watch;
fn claims(token: &str) -> Option<Value> {
let mut segments = token.split('.');
let (_, payload, _) = (segments.next()?, segments.next()?, segments.next()?);
if segments.next().is_some() {
return None;
}
serde_json::from_slice(&URL_SAFE_NO_PAD.decode(payload).ok()?).ok()
}
fn seconds(claims: &Value, name: &str) -> Option<f64> {
claims[name].as_f64().filter(|s| *s != 0.0)
}
pub fn text_claim(token: &str, name: &str) -> Option<String> {
claims(token)?[name].as_str().map(str::to_owned)
}
pub fn token_expiry(token: &str) -> Option<SystemTime> {
let exp = seconds(&claims(token)?, "exp")?;
UNIX_EPOCH.checked_add(Duration::try_from_secs_f64(exp).ok()?)
}
pub fn renewal_delay(lifetime: Duration, remaining: Duration) -> Duration {
let margin = REFRESH_BEFORE_EXP.min(lifetime / 2);
remaining.saturating_sub(margin).max(MIN_REFRESH_DELAY)
}
pub async fn renew_when_due<Fut: Future<Output = ()>>(
mut token: watch::Receiver<Option<String>>,
mut renew: impl FnMut() -> Fut,
) {
loop {
let due = token
.borrow_and_update()
.as_deref()
.and_then(|token| refresh_delay(token, SystemTime::now()));
match due {
Some(due) => {
tokio::select! {
() = tokio::time::sleep(due) => {}
changed = token.changed() => match changed {
Ok(()) => continue,
Err(_) => return,
},
}
}
None => match token.changed().await {
Ok(()) => continue,
Err(_) => return,
},
}
renew().await;
}
}
pub fn refresh_delay(token: &str, now: SystemTime) -> Option<Duration> {
let claims = claims(token)?;
let exp = seconds(&claims, "exp")?;
let now = now.duration_since(UNIX_EPOCH).ok()?.as_secs_f64();
let remaining = Duration::try_from_secs_f64((exp - now).max(0.0)).ok()?;
let lifetime = match seconds(&claims, "iat") {
Some(iat) => Duration::try_from_secs_f64((exp - iat).max(0.0)).ok()?,
None => remaining,
};
Some(renewal_delay(lifetime, remaining))
}