Skip to main content

atomic_integration_proxy/device/
mod.rs

1//! Additional Local Thought client authentication (RFC 8628), independent
2//! of provider OAuth and of the retired provider connection codes.
3pub(crate) mod store;
4#[cfg(test)]
5mod tests;
6
7use crate::{api_error::ApiError, AppState};
8use axum::{
9    body::Bytes,
10    extract::{ConnectInfo, DefaultBodyLimit, OriginalUri, Path, Query, State},
11    http::{header, HeaderMap, Method, StatusCode},
12    response::{Html, IntoResponse, Response},
13    routing::{delete, get, post},
14    Json, Router,
15};
16use serde::Deserialize;
17use serde_json::json;
18use std::{collections::BTreeMap, net::SocketAddr, time::Duration};
19
20pub const DISCOVERY_SCOPE: &str = "connections:read";
21pub const READ_SCOPE: &str = "proxy:read";
22pub const WRITE_SCOPE: &str = "proxy:write";
23pub const CONNECTION_MANAGE_SCOPE: &str = "connections:manage";
24pub const SESSION_MANAGE_SCOPE: &str = "sessions:manage";
25pub const NOTIFICATION_SCOPE: &str = "notifications:consume";
26const DEVICE_GRANT: &str = "urn:ietf:params:oauth:grant-type:device_code";
27
28/// Public clients have display names fixed by the operator, never provided
29/// by the device. The approval URL is a trusted owner hub using the browser
30/// module; registering clients requires an explicit approval integration.
31#[derive(Clone, Debug, Default)]
32pub struct DeviceConfig {
33    pub clients: BTreeMap<String, String>,
34    pub approval_url: Option<String>,
35}
36impl DeviceConfig {
37    pub(crate) fn from_env() -> Result<Self, String> {
38        let clients = match std::env::var("DEVICE_CLIENTS")
39            .ok()
40            .filter(|s| !s.trim().is_empty())
41        {
42            Some(value) => serde_json::from_str(&value).map_err(|_| {
43                "DEVICE_CLIENTS must be a JSON object mapping public client ids to display names"
44            })?,
45            None => BTreeMap::new(),
46        };
47        let config = Self {
48            clients,
49            approval_url: std::env::var("DEVICE_APPROVAL_URL")
50                .ok()
51                .filter(|s| !s.trim().is_empty()),
52        };
53        config.validate()?;
54        Ok(config)
55    }
56    pub(crate) fn validate(&self) -> Result<(), String> {
57        if self.clients.len() > 20
58            || self.clients.iter().any(|(id, name)| {
59                id.is_empty()
60                    || id.len() > 80
61                    || !id
62                        .bytes()
63                        .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
64                    || name.is_empty()
65                    || name.chars().count() > 100
66                    || name.chars().any(char::is_control)
67            })
68        {
69            return Err("DEVICE_CLIENTS allows at most 20 clients, with 1..80 ASCII id characters and 1..100 display name characters".into());
70        }
71        if !self.clients.is_empty() {
72            let url = self
73                .approval_url
74                .as_ref()
75                .ok_or("DEVICE_APPROVAL_URL is required when device clients are registered")?;
76            let parsed = url::Url::parse(url).map_err(|_| {
77                "DEVICE_APPROVAL_URL must be an absolute HTTPS URL (loopback HTTP for development)"
78            })?;
79            let loopback = matches!(parsed.host_str(), Some("localhost" | "127.0.0.1" | "[::1]"));
80            if !(parsed.scheme() == "https" || parsed.scheme() == "http" && loopback)
81                || !parsed.username().is_empty()
82                || parsed.password().is_some()
83                || parsed.query().is_some()
84                || parsed.fragment().is_some()
85            {
86                return Err("DEVICE_APPROVAL_URL must be an absolute HTTPS URL without credentials, query or fragment (loopback HTTP for development)".into());
87            }
88        }
89        Ok(())
90    }
91}
92
93#[derive(Debug)]
94pub(crate) struct Error {
95    code: &'static str,
96    status: StatusCode,
97}
98impl Error {
99    fn oauth(code: &'static str) -> Self {
100        Self {
101            code,
102            status: StatusCode::BAD_REQUEST,
103        }
104    }
105    fn invalid_token() -> Self {
106        Self {
107            code: "invalid_token",
108            status: StatusCode::UNAUTHORIZED,
109        }
110    }
111    fn limited() -> Self {
112        Self {
113            code: "temporarily_unavailable",
114            status: StatusCode::TOO_MANY_REQUESTS,
115        }
116    }
117}
118impl From<tokio_postgres::Error> for Error {
119    fn from(_: tokio_postgres::Error) -> Self {
120        Self {
121            code: "temporarily_unavailable",
122            status: StatusCode::SERVICE_UNAVAILABLE,
123        }
124    }
125}
126impl From<String> for Error {
127    fn from(_: String) -> Self {
128        Self {
129            code: "temporarily_unavailable",
130            status: StatusCode::SERVICE_UNAVAILABLE,
131        }
132    }
133}
134impl IntoResponse for Error {
135    fn into_response(self) -> Response {
136        let mut response = protected((self.status, Json(json!({"error":self.code}))));
137        if self.status == StatusCode::TOO_MANY_REQUESTS {
138            response
139                .headers_mut()
140                .insert(header::RETRY_AFTER, "60".parse().unwrap());
141        }
142        response
143    }
144}
145fn protected(value: impl IntoResponse) -> Response {
146    let mut response = value.into_response();
147    response
148        .headers_mut()
149        .insert(header::CACHE_CONTROL, "no-store".parse().unwrap());
150    response
151        .headers_mut()
152        .insert(header::PRAGMA, "no-cache".parse().unwrap());
153    response
154        .headers_mut()
155        .insert(header::REFERRER_POLICY, "no-referrer".parse().unwrap());
156    response
157}
158fn enabled(state: &AppState) -> Result<&crate::security::Security, Error> {
159    if state.device.clients.is_empty() {
160        return Err(Error {
161            code: "device_auth_disabled",
162            status: StatusCode::NOT_FOUND,
163        });
164    }
165    state.security.as_ref().ok_or(Error {
166        code: "temporarily_unavailable",
167        status: StatusCode::SERVICE_UNAVAILABLE,
168    })
169}
170fn client<'a>(state: &'a AppState, id: &str) -> Result<&'a str, Error> {
171    state
172        .device
173        .clients
174        .get(id)
175        .map(String::as_str)
176        .ok_or(Error::oauth("invalid_client"))
177}
178pub(crate) fn secret(prefix: &str) -> String {
179    format!("{prefix}{}", crate::connect::random())
180}
181pub(crate) fn hash(value: &str) -> String {
182    crate::signature::sha256_hex(value.as_bytes())
183}
184pub(crate) fn valid_secret(value: &str, prefix: &str) -> bool {
185    value.strip_prefix(prefix).is_some_and(|s| {
186        s.len() == 43
187            && s.bytes()
188                .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
189    })
190}
191fn user_code(value: &str) -> Result<String, Error> {
192    if value.len() > 11 {
193        return Err(Error::oauth("invalid_grant"));
194    }
195    let normalized = value.replace('-', "").to_ascii_uppercase();
196    if normalized.len() != 10
197        || !normalized
198            .bytes()
199            .all(|b| b"ABCDEFGHJKLMNPQRSTUVWXYZ23456789".contains(&b))
200    {
201        return Err(Error::oauth("invalid_grant"));
202    }
203    Ok(normalized)
204}
205fn scopes(value: Option<&str>) -> Result<String, Error> {
206    let mut scopes: Vec<&str> = value
207        .unwrap_or("connections:read proxy:read")
208        .split_ascii_whitespace()
209        .collect();
210    if scopes.is_empty()
211        || scopes.iter().any(|s| {
212            ![
213                DISCOVERY_SCOPE,
214                READ_SCOPE,
215                WRITE_SCOPE,
216                CONNECTION_MANAGE_SCOPE,
217                SESSION_MANAGE_SCOPE,
218                NOTIFICATION_SCOPE,
219            ]
220            .contains(s)
221        })
222    {
223        return Err(Error::oauth("invalid_scope"));
224    }
225    scopes.sort_unstable();
226    scopes.dedup();
227    Ok(scopes.join(" "))
228}
229fn form(headers: &HeaderMap, body: &[u8]) -> Result<BTreeMap<String, String>, Error> {
230    if body.len() > 8192
231        || !headers
232            .get(header::CONTENT_TYPE)
233            .and_then(|v| v.to_str().ok())
234            .is_some_and(|s| s.split(';').next() == Some("application/x-www-form-urlencoded"))
235    {
236        return Err(Error::oauth("invalid_request"));
237    }
238    let mut fields = BTreeMap::new();
239    for (k, v) in url::form_urlencoded::parse(body) {
240        if fields.insert(k.into_owned(), v.into_owned()).is_some() {
241            return Err(Error::oauth("invalid_request"));
242        }
243    }
244    Ok(fields)
245}
246fn field<'a>(fields: &'a BTreeMap<String, String>, name: &str) -> Result<&'a str, Error> {
247    fields
248        .get(name)
249        .map(String::as_str)
250        .ok_or(Error::oauth("invalid_request"))
251}
252async fn limit(
253    state: &AppState,
254    security: &crate::security::Security,
255    headers: &HeaderMap,
256    peer: Option<SocketAddr>,
257    action: &str,
258    count: u32,
259) -> Result<(), Error> {
260    let network = crate::client_addr::client_network(state.trust_forwarded_for, headers, peer);
261    let bucket = security.key_check_bucket(&format!("device:{action}"), &network);
262    if security
263        .take_key_check_allowance(&bucket, count, Duration::from_secs(60))
264        .await?
265        .is_some()
266    {
267        return Err(Error::limited());
268    }
269    Ok(())
270}
271
272pub(crate) fn router() -> Router<AppState> {
273    Router::new()
274        .route("/.well-known/oauth-authorization-server", get(discovery))
275        .route("/oauth/device/code", post(authorize))
276        .route("/oauth/device/token", post(token))
277        .route("/oauth/device/revoke", post(revoke))
278        .route("/device", get(page))
279        .route("/device/approval.mjs", get(approval_module))
280        .route("/device/challenge", post(challenge))
281        .route("/device/approve", post(approve))
282        .route("/device/sessions", get(sessions))
283        .route("/device/sessions/:session_id", delete(revoke_session))
284        .layer(DefaultBodyLimit::max(8192))
285}
286async fn discovery(State(state): State<AppState>) -> Response {
287    if let Err(e) = enabled(&state) {
288        return e.into_response();
289    }
290    let base = &state.base_url;
291    protected(Json(
292        json!({"issuer":base,"device_authorization_endpoint":format!("{base}/oauth/device/code"),"token_endpoint":format!("{base}/oauth/device/token"),"revocation_endpoint":format!("{base}/oauth/device/revoke"),"grant_types_supported":[DEVICE_GRANT,"refresh_token"],"token_endpoint_auth_methods_supported":["none"],"revocation_endpoint_auth_methods_supported":["none"],"scopes_supported":[DISCOVERY_SCOPE,READ_SCOPE,WRITE_SCOPE,CONNECTION_MANAGE_SCOPE,SESSION_MANAGE_SCOPE,NOTIFICATION_SCOPE],"device_approval_challenge_endpoint":format!("{base}/device/challenge"),"device_approval_endpoint":format!("{base}/device/approve")}),
293    ))
294}
295async fn authorize(
296    State(state): State<AppState>,
297    peer: Option<ConnectInfo<SocketAddr>>,
298    headers: HeaderMap,
299    body: Bytes,
300) -> Response {
301    let result = async {
302        let security=enabled(&state)?;
303        limit(&state,security,&headers,peer.map(|p|p.0),"code",20).await?;
304        let fields=form(&headers,&body)?;
305        let id=field(&fields,"client_id")?;client(&state,id)?;
306        let scope=scopes(fields.get("scope").map(String::as_str))?;
307        let (device,code)=store::create(security,id,&state.base_url,&scope).await?;
308        let verification=format!("{}/device",state.base_url);
309        let mut complete=url::Url::parse(&verification).map_err(|_|Error::oauth("invalid_request"))?;
310        complete.query_pairs_mut().append_pair("user_code",&code);
311        Ok::<_,Error>(protected(Json(json!({"device_code":device,"user_code":code,"verification_uri":verification,"verification_uri_complete":complete.as_str(),"expires_in":600,"interval":5}))))
312    }.await;
313    result.unwrap_or_else(IntoResponse::into_response)
314}
315async fn token(
316    State(state): State<AppState>,
317    peer: Option<ConnectInfo<SocketAddr>>,
318    headers: HeaderMap,
319    body: Bytes,
320) -> Response {
321    let result = async {
322        let security = enabled(&state)?;
323        limit(&state, security, &headers, peer.map(|p| p.0), "token", 120).await?;
324        let fields = form(&headers, &body)?;
325        let id = field(&fields, "client_id")?;
326        client(&state, id)?;
327        if fields.contains_key("client_secret") {
328            return Err(Error::oauth("invalid_client"));
329        }
330        let value = match field(&fields, "grant_type")? {
331            DEVICE_GRANT => {
332                let code = field(&fields, "device_code")?;
333                if !valid_secret(code, "lt_device_") {
334                    return Err(Error::oauth("invalid_grant"));
335                }
336                store::poll(security, code, id, &state.base_url).await?
337            }
338            "refresh_token" => {
339                if fields.contains_key("scope") {
340                    return Err(Error::oauth("invalid_scope"));
341                }
342                let refresh = field(&fields, "refresh_token")?;
343                if !valid_secret(refresh, "lt_refresh_") {
344                    return Err(Error::oauth("invalid_grant"));
345                }
346                store::refresh(security, refresh, id, &state.base_url).await?
347            }
348            _ => return Err(Error::oauth("unsupported_grant_type")),
349        };
350        Ok::<_, Error>(protected(Json(value)))
351    }
352    .await;
353    result.unwrap_or_else(IntoResponse::into_response)
354}
355async fn revoke(
356    State(state): State<AppState>,
357    peer: Option<ConnectInfo<SocketAddr>>,
358    headers: HeaderMap,
359    body: Bytes,
360) -> Response {
361    let result = async {
362        let security = enabled(&state)?;
363        limit(&state, security, &headers, peer.map(|p| p.0), "revoke", 60).await?;
364        let fields = form(&headers, &body)?;
365        let id = field(&fields, "client_id")?;
366        client(&state, id)?;
367        let token = field(&fields, "token")?;
368        if valid_secret(token, "lt_access_") || valid_secret(token, "lt_refresh_") {
369            store::revoke(security, token, id, &state.base_url).await?;
370        }
371        Ok::<_, Error>(protected(StatusCode::OK))
372    }
373    .await;
374    result.unwrap_or_else(IntoResponse::into_response)
375}
376
377#[derive(Deserialize)]
378#[serde(deny_unknown_fields)]
379struct Code {
380    user_code: String,
381}
382#[derive(Deserialize)]
383#[serde(deny_unknown_fields)]
384struct Approval {
385    challenge: String,
386    approve: bool,
387    connections: Vec<String>,
388}
389async fn owner(
390    state: &AppState,
391    method: &Method,
392    uri: &axum::http::Uri,
393    headers: &HeaderMap,
394    body: &[u8],
395) -> Result<crate::AgentId, ApiError> {
396    if headers.contains_key(header::AUTHORIZATION) {
397        return Err(ApiError::UnsupportedAuthorization);
398    }
399    let security = state.security.as_ref().ok_or(ApiError::Unavailable)?;
400    let owner = crate::signature::authenticate(state, security, method, uri, headers, body).await?;
401    crate::check_access(state, &owner).await?;
402    Ok(owner)
403}
404async fn owner_limit(state: &AppState, owner: &crate::AgentId) -> Result<(), Error> {
405    let security = enabled(state)?;
406    let bucket = security.key_check_bucket("device:owner", owner.as_str());
407    if security
408        .take_key_check_allowance(&bucket, 20, Duration::from_secs(60))
409        .await?
410        .is_some()
411    {
412        return Err(Error::limited());
413    }
414    Ok(())
415}
416async fn challenge(
417    State(state): State<AppState>,
418    peer: Option<ConnectInfo<SocketAddr>>,
419    method: Method,
420    OriginalUri(uri): OriginalUri,
421    headers: HeaderMap,
422    body: Bytes,
423) -> Response {
424    let result = async {
425        let security = enabled(&state).map_err(IntoResponse::into_response)?;
426        limit(
427            &state,
428            security,
429            &headers,
430            peer.map(|p| p.0),
431            "approval",
432            30,
433        )
434        .await
435        .map_err(IntoResponse::into_response)?;
436        let owner = owner(&state, &method, &uri, &headers, &body)
437            .await
438            .map_err(IntoResponse::into_response)?;
439        owner_limit(&state, &owner)
440            .await
441            .map_err(IntoResponse::into_response)?;
442        let request: Code = serde_json::from_slice(&body)
443            .map_err(|_| Error::oauth("invalid_request").into_response())?;
444        let code = user_code(&request.user_code).map_err(IntoResponse::into_response)?;
445        let mut value = store::challenge(security, &code, owner.as_str(), &state.base_url)
446            .await
447            .map_err(IntoResponse::into_response)?;
448        let (connections, _) = security
449            .list_for_owner(owner.as_str())
450            .await
451            .map_err(|_| ApiError::Unavailable.into_response())?;
452        value["client_name"] = json!(client(
453            &state,
454            value["client_id"].as_str().unwrap_or_default()
455        )
456        .map_err(IntoResponse::into_response)?);
457        value["owner"] = json!(owner.as_str());
458        value["connections"] = json!(connections
459            .into_iter()
460            .map(|c| json!({"connection_id":c.connection_id,"platform":c.platform,"label":c.label}))
461            .collect::<Vec<_>>());
462        Ok::<_, Response>(protected(Json(value)))
463    }
464    .await;
465    result.unwrap_or_else(|r| r)
466}
467async fn approve(
468    State(state): State<AppState>,
469    method: Method,
470    OriginalUri(uri): OriginalUri,
471    headers: HeaderMap,
472    body: Bytes,
473) -> Response {
474    let result = async {
475        let security = enabled(&state).map_err(IntoResponse::into_response)?;
476        let owner = owner(&state, &method, &uri, &headers, &body)
477            .await
478            .map_err(IntoResponse::into_response)?;
479        owner_limit(&state, &owner)
480            .await
481            .map_err(IntoResponse::into_response)?;
482        let request: Approval = serde_json::from_slice(&body)
483            .map_err(|_| Error::oauth("invalid_request").into_response())?;
484        if !valid_secret(&request.challenge, "lt_approval_")
485            || request.connections.len() > 20
486            || request.connections.iter().any(|c| c.len() != 43)
487        {
488            return Err(Error::oauth("invalid_request").into_response());
489        }
490        store::approve(
491            security,
492            &request.challenge,
493            owner.as_str(),
494            &state.base_url,
495            &request.connections,
496            request.approve,
497        )
498        .await
499        .map_err(IntoResponse::into_response)?;
500        Ok::<_, Response>(protected(Json(json!({"approved":request.approve}))))
501    }
502    .await;
503    result.unwrap_or_else(|r| r)
504}
505/// Management is a separate, explicit device permission. It never authorizes
506/// owner approval, creating provider connections or registering runtimes.
507async fn management_owner(
508    state: &AppState,
509    method: &Method,
510    uri: &axum::http::Uri,
511    headers: &HeaderMap,
512    body: &[u8],
513) -> Result<crate::agent_id::AgentId, ApiError> {
514    if let Some(token) = bearer(headers)? {
515        let principal = principal(state, token).await?;
516        if !principal
517            .scope
518            .split_ascii_whitespace()
519            .any(|s| s == SESSION_MANAGE_SCOPE)
520        {
521            return Err(ApiError::TokenScope);
522        }
523        return Ok(principal.owner);
524    }
525    owner(state, method, uri, headers, body).await
526}
527
528async fn sessions(
529    State(state): State<AppState>,
530    method: Method,
531    OriginalUri(uri): OriginalUri,
532    headers: HeaderMap,
533    body: Bytes,
534) -> Response {
535    let result = async {
536        let security = enabled(&state).map_err(IntoResponse::into_response)?;
537        let owner = management_owner(&state, &method, &uri, &headers, &body)
538            .await
539            .map_err(IntoResponse::into_response)?;
540        Ok::<_, Response>(protected(Json(
541            store::sessions(security, owner.as_str(), &state.base_url)
542                .await
543                .map_err(IntoResponse::into_response)?,
544        )))
545    }
546    .await;
547    result.unwrap_or_else(|r| r)
548}
549async fn revoke_session(
550    State(state): State<AppState>,
551    Path(session): Path<String>,
552    method: Method,
553    OriginalUri(uri): OriginalUri,
554    headers: HeaderMap,
555    body: Bytes,
556) -> Response {
557    let result = async {
558        let security = enabled(&state).map_err(IntoResponse::into_response)?;
559        let owner = management_owner(&state, &method, &uri, &headers, &body)
560            .await
561            .map_err(IntoResponse::into_response)?;
562        store::revoke_owned(security, owner.as_str(), &session, &state.base_url)
563            .await
564            .map_err(IntoResponse::into_response)?;
565        Ok::<_, Response>(protected(StatusCode::NO_CONTENT))
566    }
567    .await;
568    result.unwrap_or_else(|r| r)
569}
570async fn page(
571    State(state): State<AppState>,
572    Query(query): Query<BTreeMap<String, String>>,
573) -> Response {
574    if let Err(e) = enabled(&state) {
575        return e.into_response();
576    }
577    let code = query
578        .get("user_code")
579        .and_then(|v| user_code(v).ok())
580        .unwrap_or_default();
581    let mut url =
582        url::Url::parse(state.device.approval_url.as_deref().unwrap_or_default()).unwrap();
583    if !code.is_empty() {
584        url.query_pairs_mut().append_pair("user_code", &code);
585    }
586    // URL comes from validated operator configuration; encode HTML context.
587    let escaped = url
588        .as_str()
589        .replace('&', "&amp;")
590        .replace('"', "&quot;")
591        .replace('<', "&lt;");
592    let mut response=protected(Html(format!("<!doctype html><meta charset=utf-8><title>Approve a CLI connection</title><h1>Approve a CLI connection</h1><p>Continue in your owner hub to authenticate as your existing Atomic owner, review the client, and select connections. Compare the code with the CLI you started. Approve only a login you initiated.</p><p>User code: <strong>{code}</strong></p><a href=\"{escaped}\">Continue to owner approval</a>")));
593    response.headers_mut().insert(
594        header::CONTENT_SECURITY_POLICY,
595        "default-src 'none'; base-uri 'none'; frame-ancestors 'none'"
596            .parse()
597            .unwrap(),
598    );
599    response
600}
601async fn approval_module() -> Response {
602    (
603        [
604            (header::CONTENT_TYPE, "text/javascript; charset=utf-8"),
605            (header::CACHE_CONTROL, "no-store"),
606        ],
607        include_str!("../../static/device-approval.mjs"),
608    )
609        .into_response()
610}
611
612/// Recognizes only new, namespaced Local Thought access tokens. A retired
613/// Bearer connection code stays unsupported and never falls back to signing.
614pub(crate) fn bearer(headers: &HeaderMap) -> Result<Option<&str>, ApiError> {
615    if headers.get_all(header::AUTHORIZATION).iter().count() > 1 {
616        return Err(ApiError::UnsupportedAuthorization);
617    }
618    let Some(value) = headers.get(header::AUTHORIZATION) else {
619        return Ok(None);
620    };
621    let value = value
622        .to_str()
623        .map_err(|_| ApiError::UnsupportedAuthorization)?;
624    let Some((scheme, token)) = value.split_once(' ') else {
625        return Err(ApiError::UnsupportedAuthorization);
626    };
627    if !scheme.eq_ignore_ascii_case("bearer") {
628        return Ok(None);
629    }
630    if !valid_secret(token, "lt_access_") {
631        return Err(ApiError::UnsupportedAuthorization);
632    }
633    Ok(Some(token))
634}
635pub(crate) async fn principal(state: &AppState, token: &str) -> Result<store::Principal, ApiError> {
636    let security = enabled(state).map_err(|e| {
637        if e.status == StatusCode::SERVICE_UNAVAILABLE {
638            ApiError::Unavailable
639        } else {
640            ApiError::InvalidToken
641        }
642    })?;
643    let principal = store::authenticate(security, token, &state.base_url)
644        .await
645        .map_err(|e| {
646            if e.status == StatusCode::SERVICE_UNAVAILABLE {
647                ApiError::Unavailable
648            } else {
649                ApiError::InvalidToken
650            }
651        })?;
652    if !state.device.clients.contains_key(&principal.client_id) {
653        return Err(ApiError::InvalidToken);
654    }
655    crate::check_access(state, &principal.owner).await?;
656    Ok(principal)
657}
658
659pub(crate) async fn connections(state: &AppState, token: &str) -> Result<Response, ApiError> {
660    let principal = principal(state, token).await?;
661    if !principal
662        .scope
663        .split_ascii_whitespace()
664        .any(|s| s == DISCOVERY_SCOPE || s == CONNECTION_MANAGE_SCOPE)
665    {
666        return Err(ApiError::TokenScope);
667    }
668    let security = state.security.as_ref().ok_or(ApiError::Unavailable)?;
669    let (connections, _) = security
670        .list_for_owner(principal.owner.as_str())
671        .await
672        .map_err(|_| ApiError::Unavailable)?;
673    let manages = principal
674        .scope
675        .split_ascii_whitespace()
676        .any(|s| s == CONNECTION_MANAGE_SCOPE);
677    let connections:Vec<_>=connections.into_iter().filter(|c|principal.connections.contains(&c.connection_id)).map(|c| if manages { json!(c) } else { json!({"connection_id":c.connection_id,"platform":c.platform,"owner":c.owner,"label":c.label}) }).collect();
678    Ok(protected(Json(
679        json!({"owner":principal.owner.as_str(),"client_id":principal.client_id,"session_id":principal.session_id,"scope":principal.scope,"connections":connections}),
680    )))
681}