little cleanup

basic api stuff

.github/workflows/checks.yml

···
       - name: get nightly toolchain for jetstream fmt
         run: rustup toolchain install nightly --allow-downgrade -c rustfmt
       - name: fmt
-        run: cargo fmt --package links --package constellation --package ufos --package spacedust --package who-am-i --package slingshot -- --check
+        run: cargo fmt --package links --package constellation --package ufos --package spacedust --package who-am-i --package slingshot --package pocket -- --check
       - name: fmt jetstream (nightly)
         run: cargo +nightly fmt --package jetstream -- --check
       - name: clippy

Makefile

···
 	cargo test --all-features
 
 fmt:
-	cargo fmt --package links --package constellation --package ufos --package spacedust --package who-am-i --package slingshot
+	cargo fmt --package links --package constellation --package ufos --package spacedust --package who-am-i --package slingshot --package pocket
 	cargo +nightly fmt --package jetstream
 
 clippy:

pocket/api-description.md

···
+_A pocket dimension to stash a bit of non-public user data._
+
+
+# Pocket: user preference storage
+
+This API leverages atproto service proxying to offer a bit of per-user per-app non-public data storage.
+Perfect for things like application preferences that might be better left out of the public PDS data.
+
+The intent is to use oauth scopes to isolate storage on a per-application basis, and to allow easy data migration from a community hosted instance to your own if you end up needing that.
+
+
+### Current status
+
+> [!important]
+> Pocket is currently in a **v0, pre-release state**. There is one production instance and you can use it! Expect short downtimes for restarts as development progresses and occaisional data loss until it's stable.
+
+ATProto might end up adding a similar feature to [PDSs](https://atproto.com/guides/glossary#pds-personal-data-server). If/when that happens, you should use it instead of this!

pocket/src/lib.rs

···
 mod token;
 
 pub use server::serve;
-pub use token::verify;
+pub use token::TokenVerifier;

pocket/src/main.rs

···
     println!("Hello, world!");
     serve("mac.cinnebar-tet.ts.net").await
 }
-

pocket/src/server.rs

···
+use crate::TokenVerifier;
 use poem::{
-    endpoint::make_sync,
-    Endpoint,
-    Route,
-    Server,
-    EndpointExt,
-    http::{Method, HeaderMap},
+    Endpoint, EndpointExt, Route, Server,
+    endpoint::{StaticFileEndpoint, make_sync},
+    http::Method,
+    listener::TcpListener,
     middleware::{CatchPanic, Cors, Tracing},
-    listener::TcpListener,
 };
 use poem_openapi::{
-    ContactObject,
-    ExternalDocumentObject,
-    OpenApi,
-    OpenApiService,
-    Tags,
-    Object,
-    ApiResponse,
+    ApiResponse, ContactObject, ExternalDocumentObject, Object, OpenApi, OpenApiService,
+    SecurityScheme, Tags,
+    auth::Bearer,
+    payload::{Json, PlainText},
     types::Example,
-    auth::Bearer,
-    payload::Json,
-    SecurityScheme,
 };
-use crate::verify;
 use serde::Serialize;
 use serde_json::{Value, json};
-
 
 #[derive(Debug, SecurityScheme)]
 #[oai(ty = "bearer")]
-struct BlahAuth(Bearer);
-
+struct XrpcAuth(Bearer);
 
 #[derive(Tags)]
 enum ApiTags {
-    /// Bluesky-compatible APIs.
-    #[oai(rename = "app.bsky.* queries")]
-    AppBsky,
+    /// Custom pocket APIs
+    #[oai(rename = "Pocket APIs")]
+    Pocket,
 }
 
 #[derive(Object)]
···
     /// Bad request or no preferences to return
     #[oai(status = 400)]
     BadRequest(XrpcError),
+}
+
+#[derive(ApiResponse)]
+enum PutBskyPrefsResponse {
+    /// Record found
+    #[oai(status = 200)]
+    Ok(PlainText<String>),
+    /// Bad request or no preferences to return
+    #[oai(status = 400)]
+    BadRequest(XrpcError),
     // /// Server errors
     // #[oai(status = 500)]
     // ServerError(XrpcError),
 }
 
 struct Xrpc {
-    domain: String,
+    verifier: TokenVerifier,
 }
 
 #[OpenApi]
 impl Xrpc {
-    /// app.bsky.actor.getPreferences
+    /// com.bad-example.pocket.getPreferences
     ///
     /// get stored bluesky prefs
     #[oai(
-        path = "/app.bsky.actor.getPreferences",
+        path = "/com.bad-example.pocket.getPreferences",
         method = "get",
-        tag = "ApiTags::AppBsky"
+        tag = "ApiTags::Pocket"
     )]
-    async fn app_bsky_get_prefs(
-        &self,
-        BlahAuth(auth): BlahAuth,
-        m: &HeaderMap,
-    ) -> GetBskyPrefsResponse {
-        log::warn!("hm: {m:?}");
-        match verify(
-            &format!("did:web:{}#bsky_appview", self.domain),
-            "app.bsky.actor.getPreferences",
-            &auth.token,
-        ).await {
-            Ok(did) => log::info!("wooo! {did}"),
-            Err(err) => return GetBskyPrefsResponse::BadRequest(xrpc_error("booo", err)),
+    async fn app_bsky_get_prefs(&self, XrpcAuth(auth): XrpcAuth) -> GetBskyPrefsResponse {
+        let did = match self
+            .verifier
+            .verify("app.bsky.actor.getPreferences", &auth.token)
+            .await
+        {
+            Ok(d) => d,
+            Err(e) => return GetBskyPrefsResponse::BadRequest(xrpc_error("boooo", e.to_string())),
         };
-        log::warn!("got bearer: {:?}", auth.token);
+        log::info!("verified did: {did}");
+        // TODO: fetch from storage
         GetBskyPrefsResponse::Ok(Json(GetBskyPrefsResponseObject::example()))
     }
 
-    /// app.bsky.actor.putPreferences
+    /// com.bad-example.pocket.putPreferences
     ///
     /// store bluesky prefs
     #[oai(
-        path = "/app.bsky.actor.putPreferences",
+        path = "/com.bad-example.pocket.putPreferences",
         method = "post",
-        tag = "ApiTags::AppBsky"
+        tag = "ApiTags::Pocket"
     )]
     async fn app_bsky_put_prefs(
         &self,
+        XrpcAuth(auth): XrpcAuth,
         Json(prefs): Json<Value>,
-    ) -> () {
+    ) -> PutBskyPrefsResponse {
+        let did = match self
+            .verifier
+            .verify("app.bsky.actor.getPreferences", &auth.token)
+            .await
+        {
+            Ok(d) => d,
+            Err(e) => return PutBskyPrefsResponse::BadRequest(xrpc_error("boooo", e.to_string())),
+        };
+        log::info!("verified did: {did}");
         log::warn!("received prefs: {prefs:?}");
-        ()
+        // TODO: put prefs into storage
+        PutBskyPrefsResponse::Ok(PlainText("hiiiiii".to_string()))
     }
 }
 
···
     let doc = poem::web::Json(AppViewDoc {
         id: format!("did:web:{domain}"),
         service: [AppViewService {
-            id: "#bsky_appview".to_string(),
-            r#type: "PocketBlueskyPreferences".to_string(),
+            id: "#pocket_prefs".to_string(),
+            r#type: "PocketPreferences".to_string(),
             service_endpoint: format!("https://{domain}"),
         }],
     });
     make_sync(move |_| doc.clone())
 }
 
-pub async fn serve(
-    domain: &str,
-) -> () {
-    let api_service = OpenApiService::new(
-        Xrpc { domain: domain.to_string() },
-        "Pocket",
-        env!("CARGO_PKG_VERSION"),
-    )
-    .server(domain)
-    .url_prefix("/xrpc")
-    .contact(
-        ContactObject::new()
-            .name("@microcosm.blue")
-            .url("https://bsky.app/profile/microcosm.blue"),
-    )
-    // .description(include_str!("../api-description.md"))
-    .external_document(ExternalDocumentObject::new(
-        "https://microcosm.blue/pocket",
-    ));
+pub async fn serve(domain: &str) -> () {
+    let verifier = TokenVerifier::new(domain);
+    let api_service = OpenApiService::new(Xrpc { verifier }, "Pocket", env!("CARGO_PKG_VERSION"))
+        .server(domain)
+        .url_prefix("/xrpc")
+        .contact(
+            ContactObject::new()
+                .name("@microcosm.blue")
+                .url("https://bsky.app/profile/microcosm.blue"),
+        )
+        .description(include_str!("../api-description.md"))
+        .external_document(ExternalDocumentObject::new("https://microcosm.blue/pocket"));
 
     let app = Route::new()
-        .at("/.well-known/did.json", get_did_doc(&domain))
+        .nest("/openapi", api_service.spec_endpoint())
         .nest("/xrpc/", api_service)
-        // .at("/", StaticFileEndpoint::new("./static/index.html"))
-        // .nest("/openapi", api_service.spec_endpoint())
+        .at("/.well-known/did.json", get_did_doc(domain))
+        .at("/", StaticFileEndpoint::new("./static/index.html"))
         .with(
             Cors::new()
                 .allow_method(Method::GET)
-                .allow_method(Method::POST)
+                .allow_method(Method::POST),
         )
         .with(CatchPanic::new())
         .with(Tracing);
 
     let listener = TcpListener::bind("127.0.0.1:3000");
-    Server::new(listener)
-        .name("pocket")
-        .run(app)
-        .await
-        .unwrap();
-
+    Server::new(listener).name("pocket").run(app).await.unwrap();
 }

pocket/src/token.rs

···
-use jwt_compact::{Claims, UntrustedToken};
 use atrium_crypto::did::parse_multikey;
 use atrium_crypto::verify::Verifier;
-use std::collections::HashMap;
+use jwt_compact::UntrustedToken;
 use serde::Deserialize;
+use std::collections::HashMap;
+use std::time::Duration;
+use thiserror::Error;
 
 #[derive(Debug, Deserialize)]
 struct MiniDoc {
     signing_key: String,
+    did: String,
 }
 
-pub async fn verify(
-    expected_aud: &str,
-    expected_lxm: &str,
-    token: &str,
-) -> Result<String, &'static str> {
-    let untrusted = UntrustedToken::new(token).unwrap();
+#[derive(Error, Debug)]
+pub enum VerifyError {
+    #[error("The cross-service authorization token failed verification: {0}")]
+    VerificationFailed(&'static str),
+    #[error("Error trying to resolve the DID to a signing key, retry in a moment: {0}")]
+    ResolutionFailed(&'static str),
+}
+
+pub struct TokenVerifier {
+    domain: String,
+    client: reqwest::Client,
+}
+
+impl TokenVerifier {
+    pub fn new(domain: &str) -> Self {
+        let client = reqwest::Client::builder()
+            .user_agent(format!(
+                "microcosm pocket v{} (dev: @bad-example.com)",
+                env!("CARGO_PKG_VERSION")
+            ))
+            .no_proxy()
+            .timeout(Duration::from_secs(12)) // slingshot timeout is 10s
+            .build()
+            .unwrap();
+        Self {
+            client,
+            domain: domain.to_string(),
+        }
+    }
+
+    pub async fn verify(&self, expected_lxm: &str, token: &str) -> Result<String, VerifyError> {
+        let untrusted = UntrustedToken::new(token).unwrap();
+
+        // danger! unfortunately we need to decode the DID from the jwt body before we have a public key to verify the jwt with
+        let Ok(untrusted_claims) =
+            untrusted.deserialize_claims_unchecked::<HashMap<String, String>>()
+        else {
+            return Err(VerifyError::VerificationFailed(
+                "could not deserialize jtw claims",
+            ));
+        };
 
-    let claims: Claims<HashMap<String, String>> = untrusted.deserialize_claims_unchecked().unwrap();
+        // get the (untrusted!) claimed DID
+        let Some(untrusted_did) = untrusted_claims.custom.get("iss") else {
+            return Err(VerifyError::VerificationFailed(
+                "jwt must include the user's did in `iss`",
+            ));
+        };
 
-    let Some(did) = claims.custom.get("iss") else {
-        return Err("jwt must include the user's did in `iss`");
-    };
+        // bail if it's not even a user-ish did
+        if !untrusted_did.starts_with("did:") {
+            return Err(VerifyError::VerificationFailed("iss should be a did"));
+        }
+        if untrusted_did.contains("#") {
+            return Err(VerifyError::VerificationFailed(
+                "iss should be a user did without a service identifier",
+            ));
+        }
 
-    if !did.starts_with("did:") {
-        return Err("iss should be a did");
-    }
-    if did.contains("#") {
-        return Err("iss should be a user did without a service identifier");
-    }
+        let endpoint =
+            "https://slingshot.microcosm.blue/xrpc/com.bad-example.identity.resolveMiniDoc";
+        let doc: MiniDoc = self
+            .client
+            .get(format!("{endpoint}?identifier={untrusted_did}"))
+            .send()
+            .await
+            .map_err(|_| VerifyError::ResolutionFailed("failed to fetch minidoc"))?
+            .error_for_status()
+            .map_err(|_| VerifyError::ResolutionFailed("non-ok response for minidoc"))?
+            .json()
+            .await
+            .map_err(|_| VerifyError::ResolutionFailed("failed to parse json to minidoc"))?;
 
-    println!("Claims: {claims:#?}");
-    println!("did: {did:#?}");
+        // sanity check before we go ahead with this signing key
+        if doc.did != *untrusted_did {
+            return Err(VerifyError::VerificationFailed(
+                "wtf, resolveMiniDoc returned a doc for a different DID, slingshot bug",
+            ));
+        }
 
-    let endpoint = "https://slingshot.microcosm.blue/xrpc/com.bad-example.identity.resolveMiniDoc";
-    let doc: MiniDoc = reqwest::get(format!("{endpoint}?identifier={did}"))
-        .await
-        .unwrap()
-        .error_for_status()
-        .unwrap()
-        .json()
-        .await
-        .unwrap();
+        let Ok((alg, public_key)) = parse_multikey(&doc.signing_key) else {
+            return Err(VerifyError::VerificationFailed(
+                "could not parse signing key form minidoc",
+            ));
+        };
 
-    log::info!("got minidoc response: {doc:?}");
+        // i _guess_ we've successfully bootstrapped the verification of the jwt unless this fails
+        if let Err(e) = Verifier::default().verify(
+            alg,
+            &public_key,
+            &untrusted.signed_data,
+            untrusted.signature_bytes(),
+        ) {
+            log::warn!("jwt verification failed: {e}");
+            return Err(VerifyError::VerificationFailed(
+                "jwt signature verification failed",
+            ));
+        }
 
-    let (alg, public_key) = parse_multikey(&doc.signing_key).unwrap();
-    log::info!("parsed key: {public_key:?}");
+        // past this point we're should have established trust. crossing ts and dotting is.
+        let did = &untrusted_did;
+        let claims = &untrusted_claims;
 
-    Verifier::default().verify(
-        alg,
-        &public_key,
-        &untrusted.signed_data,
-        untrusted.signature_bytes(),
-    ).unwrap();
-    // if this passes, then our claims were trustworthy after all(??)
+        let Some(aud) = claims.custom.get("aud") else {
+            return Err(VerifyError::VerificationFailed("missing aud"));
+        };
+        if *aud != format!("did:web:{}#bsky_appview", self.domain) {
+            return Err(VerifyError::VerificationFailed("wrong aud"));
+        }
+        let Some(lxm) = claims.custom.get("lxm") else {
+            return Err(VerifyError::VerificationFailed("missing lxm"));
+        };
+        if lxm != expected_lxm {
+            return Err(VerifyError::VerificationFailed("wrong lxm"));
+        }
 
-    let Some(aud) = claims.custom.get("aud") else {
-        return Err("missing aud");
-    };
-    if aud != expected_aud {
-        return Err("wrong aud");
-    }
-    let Some(lxm) = claims.custom.get("lxm") else {
-        return Err("missing lxm");
-    };
-    if lxm != expected_lxm {
-        return Err("wrong lxm");
+        Ok(did.to_string())
     }
-
-    Ok(did.to_string())
 }

pocket/static/index.html

···
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Pocket: atproto user preference storage</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="description" content="API Documentation for Pocket, a simple user-preference storage system for atproto" />
+    <style>
+      :root {
+        --scalar-small: 13px;
+      }
+      .scalar-app .markdown .markdown-alert {
+        font-size: var(--scalar-small);
+      }
+      .sidebar-heading-link-title {
+        line-height: 1.2;
+      }
+      .custom-header {
+        height: 42px;
+        background-color: #221828;
+        box-shadow: inset 0 -1px 0 var(--scalar-border-color);
+        color: var(--scalar-color-1);
+        font-size: var(--scalar-font-size-3);
+        font-family: 'Iowan Old Style', 'Palatino Linotype', 'URW Palladio L', P052, serif;
+        padding: 0 18px;
+        justify-content: space-between;
+      }
+      .custom-header,
+      .custom-header nav {
+        display: flex;
+        align-items: center;
+        gap: 18px;
+      }
+      .custom-header a:hover {
+        color: var(--scalar-color-2);
+      }
+
+      .light-mode .custom-header {
+        background-color: thistle;
+      }
+    </style>
+  </head>
+  <body>
+    <header class="custom-header scalar-app">
+      <p>
+        TODO: thing
+      </p>
+      <nav>
+        <b>a <a href="https://microcosm.blue">microcosm</a> project</b>
+        <a href="https://bsky.app/profile/microcosm.blue">@microcosm.blue</a>
+        <a href="https://github.com/at-microcosm">github</a>
+      </nav>
+    </header>
+
+    <script id="api-reference" type="application/json" data-url="/openapi"></script>
+
+    <script>
+      var configuration = {
+        theme: 'purple',
+        hideModels: true,
+      }
+      document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration)
+    </script>
+
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  </body>
+</html>

quasar/src/lib.rs

···
 mod storage;
+
+pub use storage::Storage;

quasar/src/storage.rs

···
 
-trait Storage {
+pub trait Storage {
     
 }