We posting

.gitignore

···
 .env
 .idea
 /wasm/dist
-./stitch_counter.sqlite
+stitch_counter.sqlite

Cargo.lock

···
  "async-trait",
  "atproto_api",
  "atrium-api",
+ "bsky-sdk",
  "dotenv",
  "env_logger",
  "log",
···
  "rocketman",
  "serde",
  "serde_json",
+ "slingshot",
  "sqlx",
  "tokio",
 ]
···
 name = "logic"
 version = "0.1.0"
 dependencies = [
- "anyhow",
  "async-trait",
- "atproto_api",
  "atrium-api",
  "atrium-common",
  "atrium-identity",
···
  "reqwest",
  "rocketman",
  "serde",
- "serde_json",
  "thiserror 2.0.12",
  "tokio",
  "tungstenite",
···
 
 [[package]]
 name = "quinn"
-version = "0.11.8"
+version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626214629cda6781b6dc1d316ba307189c85ba657213ce642d9c77670f8202c8"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
 dependencies = [
  "bytes",
  "cfg_aliases",
···
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.12"
+version = "0.11.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49df843a9161c85bb8aae55f101bc0bac8bcafd637a620d9122fd7e0b2f7422e"
+checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
 dependencies = [
  "bytes",
  "getrandom 0.3.3",
···
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.12"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee4e529991f949c5e25755532370b8af5d114acae52326361d68d47af64aa842"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
 dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.223"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "a505d71960adde88e293da5cb5eda57093379f64e61cf77bf0e6a63af07a7bac"
 dependencies = [
+ "serde_core",
  "serde_derive",
 ]
 
···
 ]
 
 [[package]]
+name = "serde_core"
+version = "1.0.223"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20f57cbd357666aa7b3ac84a90b4ea328f1d4ddb6772b430caa5d9e1309bb9e9"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.223"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "3d428d07faf17e306e699ec1e91996e5a165ba5d6bce5b5155173e91a8a01a56"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
  "itoa",
  "memchr",
  "ryu",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
···
 checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
  "autocfg",
+]
+
+[[package]]
+name = "slingshot"
+version = "0.1.0"
+dependencies = [
+ "reqwest",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+ "tokio",
+ "url",
 ]
 
 [[package]]

Cargo.toml

···
 [workspace]
-members = ['atproto_api', "bot", "logic"]
+members = ['atproto_api', "bot", "logic", "slingshot"]
 resolver = "2"
 
 [workspace.dependencies]
···
 atrium-oauth = "0.1.4"
 atrium-xrpc = "0.12.3"
 atrium-xrpc-client = "0.5.14"
-bsky-sdk ="0.1.21"
+bsky-sdk = "0.1.21"
 clap = { version = "4.0", features = ["derive"] }
 log = "0.4.27"
 logic = { path = "logic" }
 serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0.145"
 rocketman = "0.2.5"
 tokio = { version = "1.45.0", features = ["full"] }
 wasm-bindgen = { version = "0.2.100", features = ["default", "serde_json"] }
 web-sys = "0.3.77"
 gloo = "0.11.0"
 gloo-utils = "0.2.0"
+reqwest = { version = "0.12", features = ["json", "charset", "rustls-tls", "gzip"] }
+slingshot = { path = "slingshot" }

README.md

···
 # Come back later
 
+It ain't much, but it's bandiad engineering.
+
 ![](./assets/nothing.gif)

atproto_api/lexicons/repo.json

···
+{
+  "lexicon": 1,
+  "id": "sh.tangled.repo",
+  "needsCbor": true,
+  "needsType": true,
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": [
+          "name",
+          "knot",
+          "owner",
+          "createdAt"
+        ],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "name of the repo"
+          },
+          "owner": {
+            "type": "string",
+            "format": "did"
+          },
+          "knot": {
+            "type": "string",
+            "description": "knot where the repo was created"
+          },
+          "spindle": {
+            "type": "string",
+            "description": "CI runner to send jobs to and receive results from"
+          },
+          "description": {
+            "type": "string",
+            "minGraphemes": 1,
+            "maxGraphemes": 140
+          },
+          "source": {
+            "type": "string",
+            "format": "uri",
+            "description": "source of the repo"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}
+

atproto_api/src/lib.rs

···
 // @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
 pub mod record;
-pub mod xyz;
 pub mod sh;
+pub mod xyz;

atproto_api/src/record.rs

···
 pub enum KnownRecord {
     #[serde(rename = "sh.tangled.feed.star")]
     ShTangledFeedStar(Box<crate::sh::tangled::feed::star::Record>),
+    #[serde(rename = "sh.tangled.repo")]
+    ShTangledRepo(Box<crate::sh::tangled::repo::Record>),
     #[serde(rename = "xyz.statusphere.status")]
     XyzStatusphereStatus(Box<crate::xyz::statusphere::status::Record>),
 }
···
 impl From<crate::sh::tangled::feed::star::RecordData> for KnownRecord {
     fn from(record_data: crate::sh::tangled::feed::star::RecordData) -> Self {
         KnownRecord::ShTangledFeedStar(Box::new(record_data.into()))
+    }
+}
+impl From<crate::sh::tangled::repo::Record> for KnownRecord {
+    fn from(record: crate::sh::tangled::repo::Record) -> Self {
+        KnownRecord::ShTangledRepo(Box::new(record))
+    }
+}
+impl From<crate::sh::tangled::repo::RecordData> for KnownRecord {
+    fn from(record_data: crate::sh::tangled::repo::RecordData) -> Self {
+        KnownRecord::ShTangledRepo(Box::new(record_data.into()))
     }
 }
 impl From<crate::xyz::statusphere::status::Record> for KnownRecord {

atproto_api/src/sh/tangled.rs

···
 // @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
 //!Definitions for the `sh.tangled` namespace.
 pub mod feed;
+pub mod repo;
+#[derive(Debug)]
+pub struct Repo;
+impl atrium_api::types::Collection for Repo {
+    const NSID: &'static str = "sh.tangled.repo";
+    type Record = repo::Record;
+}

atproto_api/src/sh/tangled/repo.rs

···
+// @generated - This file is generated by esquema-codegen (forked from atrium-codegen). DO NOT EDIT.
+//!Definitions for the `sh.tangled.repo` namespace.
+use atrium_api::types::TryFromUnknown;
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct RecordData {
+    pub created_at: atrium_api::types::string::Datetime,
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub description: core::option::Option<String>,
+    ///knot where the repo was created
+    pub knot: String,
+    ///name of the repo
+    pub name: String,
+    pub owner: atrium_api::types::string::Did,
+    ///source of the repo
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub source: core::option::Option<String>,
+    ///CI runner to send jobs to and receive results from
+    #[serde(skip_serializing_if = "core::option::Option::is_none")]
+    pub spindle: core::option::Option<String>,
+}
+pub type Record = atrium_api::types::Object<RecordData>;
+impl From<atrium_api::types::Unknown> for RecordData {
+    fn from(value: atrium_api::types::Unknown) -> Self {
+        Self::try_from_unknown(value).unwrap()
+    }
+}

bot/Cargo.toml

···
 [dependencies]
 anyhow = "1.0.98"
 atproto_api.workspace = true
+bsky-sdk.workspace = true
 rocketman.workspace = true
+reqwest.workspace = true
 atrium-api.workspace = true
 log.workspace = true
 env_logger = "0.11.8"
···
 sqlx = { version = "0.8.2", features = ["runtime-tokio", "macros", "sqlite", "chrono"] }
 async-trait = "0.1.83"
 serde.workspace = true
-serde_json = "1.0.132"
+serde_json.workspace = true
 logic.workspace = true
-reqwest = { version = "0.12", features = ["json", "rustls-tls"] }
-
+slingshot.workspace = true

bot/src/constellation.rs

···
+use atrium_api::types::Collection;
+use reqwest::Url;
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+struct ConstellationCountResponse {
+    total: i64,
+}
+
+pub async fn fetch_constellation_count(target: &str) -> anyhow::Result<i64> {
+    let base = std::env::var("CONSTELLATION_BASE_URL")
+        .unwrap_or_else(|_| "https://constellation.microcosm.blue".to_string());
+    let endpoint = if base.ends_with('/') {
+        format!("{}links/count", base)
+    } else {
+        format!("{}/links/count", base)
+    };
+
+    // Build URL with query params in one go to avoid non-Send lifetimes
+    let url = Url::parse_with_params(
+        &endpoint,
+        &[
+            ("target", target.to_string()),
+            ("collection", atproto_api::sh::tangled::feed::Star::NSID.to_string()),
+            ("path", ".subject".to_string()),
+        ],
+    )?;
+
+    let resp = reqwest::Client::new()
+        .get(url)
+        .send()
+        .await?
+        .error_for_status()?;
+
+    let parsed: ConstellationCountResponse = resp.json().await?;
+    Ok(parsed.total)
+}

bot/src/main.rs

···
+mod constellation;
+
 extern crate dotenv;
 
+use crate::constellation::fetch_constellation_count;
+use atrium_api::types::Collection;
+use atrium_api::types::string::Language;
+use bsky_sdk::rich_text::RichText;
 use dotenv::dotenv;
-use atrium_api::types::Collection;
-use rocketman::{connection::JetstreamConnection, handler, ingestion::LexiconIngestor, options::JetstreamOptions, types::event::Operation};
+use logic::BotApi;
+use reqwest::Url;
+use rocketman::{
+    connection::JetstreamConnection, handler, ingestion::LexiconIngestor,
+    options::JetstreamOptions, types::event::Operation,
+};
+use serde::Deserialize;
+use slingshot::Slingshot;
 use sqlx::sqlite::{SqliteConnectOptions, SqlitePool};
 use std::collections::HashMap;
+use std::fmt::format;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-use logic::BotApi;
-use reqwest::Url;
-use serde::Deserialize;
+
+#[derive(Debug)]
+struct Record {
+    did: String,
+    collection: String,
+    rkey: String,
+}
+
+fn parse_uri(uri: &str) -> anyhow::Result<Record> {
+    let parts: Vec<&str> = uri.trim_start_matches("at://").split('/').collect();
+    if parts.len() != 3 {
+        return Err(anyhow::anyhow!("Invalid URI format"));
+    }
+    Ok(Record {
+        did: parts[0].to_string(),
+        collection: parts[1].to_string(),
+        rkey: parts[2].to_string(),
+    })
+}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
···
     dotenv().ok();
 
     // Initialize DB pool and run migrations
-    let database_url = std::env::var("DATABASE_URL").unwrap_or_else(|_| "./stitch_counter.sqlite".to_string());
+    let database_url =
+        std::env::var("DATABASE_URL").unwrap_or_else(|_| "./stitch_counter.sqlite".to_string());
     let options = SqliteConnectOptions::new()
         .filename(database_url)
         .create_if_missing(true)
···
     let bot_pds_url = std::env::var("BOT_PDS_URL").expect("BOT_PDS_URL must be set");
 
     let bot_api = BotApi::new_logged_in(bot_username, bot_password, bot_pds_url).await?;
-
-
+    let sling_shot = Arc::new(Slingshot::new("https://slingshot.microcosm.blue")?);
     // Ingestor for the star collection
     let mut ingestors: HashMap<String, Box<dyn LexiconIngestor + Send + Sync>> = HashMap::new();
     ingestors.insert(
         atproto_api::sh::tangled::feed::Star::NSID.to_string(),
-        Box::new(StarIngestor { pool: pool.clone(), bot: Arc::new(bot_api), timeframe_hours, star_threshold, post_window_hours }),
+        Box::new(StarIngestor {
+            pool: pool.clone(),
+            bot: Arc::new(bot_api),
+            sling_shot: sling_shot.clone(),
+            timeframe_hours,
+            star_threshold,
+            post_window_hours,
+        }),
     );
     let ingestors = Arc::new(ingestors);
 
···
     let cursor_clone = cursor.clone();
     tokio::spawn(async move {
         while let Ok(message) = msg_rx.recv_async().await {
-            if let Err(e) = handler::handle_message(message, &ingestors_clone, reconnect_tx_clone.clone(), cursor_clone.clone()).await {
+            if let Err(e) = handler::handle_message(
+                message,
+                &ingestors_clone,
+                reconnect_tx_clone.clone(),
+                cursor_clone.clone(),
+            )
+            .await
+            {
                 eprintln!("Error processing message: {}", e);
             }
         }
     });
 
     // Connect to jetstream
-    jetstream.connect(cursor.clone()).await.map_err(|e| anyhow::anyhow!(e.to_string()))
+    jetstream
+        .connect(cursor.clone())
+        .await
+        .map_err(|e| anyhow::anyhow!(e.to_string()))
 }
 
 struct StarIngestor {
     pool: SqlitePool,
     bot: Arc<BotApi>,
+    sling_shot: Arc<Slingshot>,
     timeframe_hours: i64,
     star_threshold: i64,
     post_window_hours: i64,
 }
 
-#[derive(Deserialize, Debug)]
-struct ConstellationCountResponse {
-    total: i64,
-}
-
-async fn fetch_constellation_count(target: &str) -> anyhow::Result<i64> {
-    let base = std::env::var("CONSTELLATION_BASE_URL")
-        .unwrap_or_else(|_| "https://constellation.microcosm.blue".to_string());
-    let endpoint = if base.ends_with('/') {
-        format!("{}links/count", base)
-    } else {
-        format!("{}/links/count", base)
-    };
-
-    // Build URL with query params in one go to avoid non-Send lifetimes
-    let url = Url::parse_with_params(
-        &endpoint,
-        &[
-            ("target", target.to_string()),
-            ("collection", atproto_api::sh::tangled::feed::Star::NSID.to_string()),
-            ("path", ".subject".to_string()),
-        ],
-    )?;
-
-    let resp = reqwest::Client::new()
-        .get(url)
-        .send()
-        .await?
-        .error_for_status()?;
-
-    let parsed: ConstellationCountResponse = resp.json().await?;
-    Ok(parsed.total)
-}
-
 #[async_trait::async_trait]
 impl LexiconIngestor for StarIngestor {
-    async fn ingest(&self, message: rocketman::types::event::Event<serde_json::Value>) -> anyhow::Result<()> {
+    /// Asynchronously processes an incoming event message related to "stars" and performs database operations and other actions based on the event type.
+    ///
+    /// # Parameters:
+    /// - `message`: An [`Event`](rocketman::types::event::Event) containing event data, which includes operations (`Create`, `Update`, or `Delete`) and associated metadata.
+    ///
+    /// # Returns:
+    /// - An [`anyhow::Result<()>`](anyhow::Result), which is `Ok(())` if the operation succeeds, or an error if any step fails.
+    ///
+    /// # Functionality:
+    /// 1. **Create or Update Operations**:
+    ///    - If the
+    async fn ingest(
+        &self,
+        message: rocketman::types::event::Event<serde_json::Value>,
+    ) -> anyhow::Result<()> {
         if let Some(commit) = &message.commit {
             match commit.operation {
                 Operation::Create | Operation::Update => {
                     if let Some(record) = &commit.record {
-                        let rec = serde_json::from_value::<atproto_api::sh::tangled::feed::star::RecordData>(record.clone())?;
+                        let rec = serde_json::from_value::<
+                            atproto_api::sh::tangled::feed::star::RecordData,
+                        >(record.clone())?;
                         // Insert or ignore duplicate per did+rkey
                         let result = sqlx::query(
                             "INSERT OR IGNORE INTO stars(createdAt, did, rkey, subject) VALUES(?, ?, ?, ?)"
···
                             if count_in_window >= self.star_threshold {
                                 log::info!(
                                     "Star threshold met: {} stars in the last {} hour(s) (threshold: {})",
-                                    count_in_window, self.timeframe_hours, self.star_threshold
+                                    count_in_window,
+                                    self.timeframe_hours,
+                                    self.star_threshold
                                 );
 
                                 // Check if a post was made within the last post_window_hours
···
                                     .execute(&self.pool)
                                     .await?;
 
-                                   let starts_count =  fetch_constellation_count(&rec.subject).await?;
+                                    let parsed = parse_uri(&rec.subject)?;
+                                    let cloned_repo_owner = parsed.did.clone();
+                                    let stars = fetch_constellation_count(&rec.subject).await?;
+                                    let repo_record = &self
+                                        .sling_shot
+                                        .get_record::<atproto_api::sh::tangled::repo::RecordData>(
+                                            parsed.did.as_str(),
+                                            parsed.collection.as_str(),
+                                            parsed.rkey.as_str(),
+                                        )
+                                        .await?;
+                                    let repo_name = repo_record.value.name.clone();
+                                    let handle =
+                                        &self.bot.get_handle(cloned_repo_owner.clone()).await?;
+                                    let tangled_sh_url = format!(
+                                        "https://tangled.sh/{cloned_repo_owner}/{repo_name}"
+                                    );
+                                    let description = match repo_record.value.description.clone() {
+                                        None => "".to_string(),
+                                        Some(desc) => format!(" : {desc}"),
+                                    };
 
-                                    log::info!("Threshold met and allowed to be posted, stars: {starts_count}");
+                                    let rt = RichText::new_with_detect_facets(format!(
+                                        "{handle}/{repo_name}{description}\n⭐️ {stars} {tangled_sh_url}"
+                                    ))
+                                    .await?;
+                                    let post = atrium_api::app::bsky::feed::post::RecordData {
+                                        created_at: atrium_api::types::string::Datetime::now(),
+                                        embed: None,
+                                        entities: None,
+                                        facets: rt.facets,
+                                        labels: None,
+                                        //You don't see a thing. No unwraps
+                                        langs: Some(vec![Language::new("en".to_string()).unwrap()]),
+                                        reply: None,
+                                        tags: None,
+                                        text: rt.text,
+                                    };
+
+                                    match self.bot.agent.create_record(post).await {
+                                        Ok(err) => {
+                                            log::info!("NEW POST MADE")
+                                        }
+                                        Err(err) => {
+                                            log::error!("{err}")
+                                        }
+                                    }
+                                    log::info!(
+                                        "Threshold met and allowed to be posted, stars: {stars}"
+                                    );
                                 }
                             }
                         }

logic/Cargo.toml

···
 edition = "2024"
 
 [dependencies]
-atproto_api.workspace = true
 atrium-api.workspace = true
 atrium-common.workspace = true
 atrium-identity.workspace = true
···
 atrium-xrpc-client.workspace = true
 bsky-sdk.workspace = true
 serde.workspace = true
-reqwest = { version = "0.12", default-features = false, features = ["gzip", "json"] }
+reqwest.workspace = true
 thiserror = "2.0.12"
-anyhow = "1.0.98"
-serde_json = "1.0.140"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 flume = "0.11.1"

logic/src/emoji.rs

···
-use serde::Serialize;
-
-#[derive(Clone, Debug, Serialize)]
-#[cfg_attr(feature = "cli", derive(clap::ValueEnum))]
-#[serde(rename_all = "kebab-case")]
-pub enum Emoji {
-    ThumbsUp,
-    ThumbsDown,
-    BlueHeart,
-    PleadingFace,
-    AnguishedFace,
-    AngryFace,
-    UpsideDownFace,
-    WinkingFace,
-    SunglassesFace,
-    GlassesFace,
-    RaisedEyebrowFace,
-    PartyingFace,
-    CryingFace,
-    SteamFromNose,
-    ExplodingHead,
-    Saluting,
-    Skull,
-    RaisedFist,
-    RockOn,
-    Eyes,
-    Brain,
-    WomanTechnologist,
-    PersonTechnologist,
-    Ninja,
-    Troll,
-    Butterfly,
-    Rocket,
-    Potato,
-    Crab,
-}
-
-impl Emoji {
-    pub fn to_emoji(&self) -> &'static str {
-        match self {
-            Emoji::ThumbsUp => "👍",
-            Emoji::ThumbsDown => "👎",
-            Emoji::BlueHeart => "💙",
-            Emoji::PleadingFace => "🥹",
-            Emoji::AnguishedFace => "😧",
-            Emoji::AngryFace => "😤",
-            Emoji::UpsideDownFace => "🙃",
-            Emoji::WinkingFace => "😉",
-            Emoji::SunglassesFace => "😎",
-            Emoji::GlassesFace => "🤓",
-            Emoji::RaisedEyebrowFace => "🤨",
-            Emoji::PartyingFace => "🥳",
-            Emoji::CryingFace => "😭",
-            Emoji::SteamFromNose => "😤",
-            Emoji::ExplodingHead => "🤯",
-            Emoji::Saluting => "🫡",
-            Emoji::Skull => "💀",
-            Emoji::RaisedFist => "✊",
-            Emoji::RockOn => "🤘",
-            Emoji::Eyes => "👀",
-            Emoji::Brain => "🧠",
-            Emoji::WomanTechnologist => "👩‍💻",
-            Emoji::PersonTechnologist => "🧑‍💻",
-            Emoji::Ninja => "🥷",
-            Emoji::Troll => "🧌",
-            Emoji::Butterfly => "🦋",
-            Emoji::Rocket => "🚀",
-            Emoji::Potato => "🥔",
-            Emoji::Crab => "🦀",
-        }
-    }
-}
-
-pub fn emojis() -> Vec<Emoji> {
-    vec![
-        Emoji::ThumbsUp,
-        Emoji::ThumbsDown,
-        Emoji::BlueHeart,
-        Emoji::PleadingFace,
-        Emoji::AnguishedFace,
-        Emoji::AngryFace,
-        Emoji::UpsideDownFace,
-        Emoji::WinkingFace,
-        Emoji::SunglassesFace,
-        Emoji::GlassesFace,
-        Emoji::RaisedEyebrowFace,
-        Emoji::PartyingFace,
-        Emoji::CryingFace,
-        Emoji::SteamFromNose,
-        Emoji::ExplodingHead,
-        Emoji::Saluting,
-        Emoji::Skull,
-        Emoji::RaisedFist,
-        Emoji::RockOn,
-        Emoji::Eyes,
-        Emoji::Brain,
-        Emoji::WomanTechnologist,
-        Emoji::PersonTechnologist,
-        Emoji::Ninja,
-        Emoji::Troll,
-        Emoji::Butterfly,
-        Emoji::Rocket,
-        Emoji::Potato,
-        Emoji::Crab,
-    ]
-}

logic/src/lib.rs

···
-pub mod emoji;
 mod resolver;
-
-use crate::Error::RequestError;
 use crate::resolver::ApiDNSTxtResolver;
-#[cfg(not(target_arch = "wasm32"))]
-use async_trait::async_trait;
-use atproto_api::record::KnownRecord;
 use atrium_api::agent::atp_agent::store::MemorySessionStore;
 use atrium_api::agent::atp_agent::{AtpSession, CredentialSession};
 use atrium_api::agent::{Agent, Configure};
···
 use atrium_identity::handle::{AtprotoHandleResolver, AtprotoHandleResolverConfig};
 use atrium_oauth::DefaultHttpClient;
 use atrium_xrpc_client::reqwest::ReqwestClient;
-#[cfg(not(target_arch = "wasm32"))]
-use rocketman::{
-    connection::JetstreamConnection, handler, ingestion::LexiconIngestor,
-    options::JetstreamOptions, types::event::Operation,
-};
+use bsky_sdk::BskyAgent;
 use serde::{Deserialize, Serialize};
-#[cfg(not(target_arch = "wasm32"))]
-use std::collections::HashMap;
 use std::sync::Arc;
-#[cfg(not(target_arch = "wasm32"))]
-use std::sync::Mutex;
-use bsky_sdk::BskyAgent;
 use thiserror::Error;
-#[cfg(not(target_arch = "wasm32"))]
-use tungstenite::Message;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::{JsCast, closure::Closure};
-#[cfg(target_arch = "wasm32")]
-use web_sys::{ErrorEvent, MessageEvent, WebSocket};
 
 #[derive(Debug, Error)]
 pub enum Error {
···
 
 #[derive(Clone)]
 pub struct BotApi {
-    agent: Arc<BskyAgent>,
+    pub agent: Arc<BskyAgent>,
     handle_resolver: Arc<AtprotoHandleResolver<ApiDNSTxtResolver, DefaultHttpClient>>,
     did_resolver: Arc<CommonDidResolver<DefaultHttpClient>>,
     authenticated: bool,
 }
 
-fn get_new_session(pds_url: String) -> CredentialSession<MemoryStore<(), AtpSession>, ReqwestClient> {
+fn get_new_session(
+    pds_url: String,
+) -> CredentialSession<MemoryStore<(), AtpSession>, ReqwestClient> {
     CredentialSession::new(
         ReqwestClient::new(pds_url.as_str()),
         MemorySessionStore::default(),
···
 }
 
 impl BotApi {
-    /// Creates a new StatusphereApi to make unauthenticated calls to atproto repos
-    // pub fn new() -> Self {
-    //     let session = get_new_session();
-    //     let agent = Agent::new(session);
-    //     let http_client = Arc::new(DefaultHttpClient::default());
-    //     let handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
-    //         dns_txt_resolver: ApiDNSTxtResolver::default(),
-    //         http_client: Arc::new(DefaultHttpClient::default()),
-    //     });
-    //     let did_resolver = CommonDidResolver::new(CommonDidResolverConfig {
-    //         plc_directory_url: DEFAULT_PLC_DIRECTORY_URL.to_string(),
-    //         http_client,
-    //     });
-    //     Self {
-    //         agent: Arc::new(agent),
-    //         handle_resolver: Arc::new(handle_resolver),
-    //         did_resolver: Arc::new(did_resolver),
-    //         authenticated: false,
-    //     }
-    // }
-
-    /// Creates a new StatusphereAPi to make authenticated requests to your atproto repo
-    pub async fn new_logged_in(handle: String, password: String, pds_url: String) -> Result<Self, Error> {
+    pub async fn new_logged_in(
+        handle: String,
+        password: String,
+        pds_url: String,
+    ) -> Result<Self, Error> {
         // let session = get_new_session(pds_url);
         // if let Err(error) = session.login(&handle, &password).await {
         //     return Err(Error::LoginError(error.to_string()));
         // }
 
-        let agent = BskyAgent::builder().build().await.expect("Failed to build agent");
+        let agent = BskyAgent::builder()
+            .build()
+            .await
+            .expect("Failed to build agent");
         agent.configure_endpoint(pds_url);
         // let agent = Agent::new(session);
-        agent.login(handle, password).await.expect("Failed to login");
+        agent
+            .login(handle, password)
+            .await
+            .expect("Failed to login");
         let handle_resolver = AtprotoHandleResolver::new(AtprotoHandleResolverConfig {
             dns_txt_resolver: ApiDNSTxtResolver::default(),
             http_client: Arc::new(DefaultHttpClient::default()),
···
         })
     }
 
-    /// Updates a user's Statusphere status on their atproto repo
-    pub async fn new_status(&self, status: &str) -> Result<(), Error> {
-        if !self.authenticated {
-            return Err(Error::NeedsAuthentication);
-        }
-
-        let status: KnownRecord = atproto_api::xyz::statusphere::status::RecordData {
-            created_at: Datetime::now(),
-            status: status.to_string(),
-        }
-        .into();
-
-        let did = self.agent.did().await.unwrap();
-        match self
-            .agent
-            .api
-            .com
-            .atproto
-            .repo
-            .create_record(
-                atrium_api::com::atproto::repo::create_record::InputData {
-                    collection: atproto_api::xyz::statusphere::Status::NSID.parse().unwrap(),
-                    record: status.into(),
-                    repo: did.clone().parse().unwrap(),
-                    rkey: None,
-                    swap_commit: None,
-                    validate: None,
-                }
-                .into(),
-            )
-            .await
-        {
-            Ok(_) => Ok(()),
-            Err(err) => Err(Error::WriteError(err.to_string())),
-        }
-    }
-
-    /// Gets the users latest Statusphere status if they do not have one returns None
-    pub async fn get_latest_status(
-        &self,
-        handle: String,
-    ) -> Result<Option<atproto_api::xyz::statusphere::status::RecordData>, Error> {
-        let handle = match Handle::new(handle) {
-            Ok(handle) => handle,
-            Err(err) => Err(Error::ParseError(err.to_string()))?,
-        };
-
-        let did = match self.handle_resolver.resolve(&handle).await {
-            Ok(did) => did,
-            Err(err) => {
-                return Err(RequestError(format!(
-                    "Could not resolve the users handle: {:?}",
-                    err.to_string()
-                )))?;
-            }
-        };
-
-        let pds_url = match self.did_resolver.resolve(&did).await {
-            Ok(did_doc) => get_pds_from_doc(did_doc)?,
-            Err(err) => Err(RequestError(err.to_string()))?,
-        };
-
-        //changing the agent to call the users pds
-        self.agent.configure_endpoint(pds_url);
-
-        let result = self
-            .agent
-            .api
-            .com
-            .atproto
-            .repo
-            .list_records(
-                atrium_api::com::atproto::repo::list_records::ParametersData {
-                    collection: atproto_api::xyz::statusphere::Status::NSID.parse().unwrap(),
-                    cursor: None,
-                    limit: Some(LimitedNonZeroU8::<100>::try_from(10_u8).unwrap()),
-                    repo: handle.parse().unwrap(),
-                    reverse: None,
-                }
-                .into(),
-            )
-            .await
-            .map_err(|e| Error::RequestError(e.to_string()))?;
-
-        if let Some(record) = result.records.first() {
-            let status: atproto_api::xyz::statusphere::status::RecordData =
-                atproto_api::xyz::statusphere::status::RecordData::from(record.value.clone());
-            return Ok(Some(status));
-        }
-        Ok(None)
-    }
-
     ///Takes a users handle like @baileytownsend.dev and resolves it ot the did
     pub async fn resolve_handle(&self, handle: String) -> Result<Did, Error> {
         let handle = Handle::new(handle).map_err(|e| Error::ParseError(e.to_string()))?;
···
         }
     }
 }
-
-/// A Jetstream listener using Rocketman
-#[cfg(not(target_arch = "wasm32"))]
-pub struct StatusSphereListener {
-    pub cursor: Arc<Mutex<Option<u64>>>,
-    pub ingestors: Arc<HashMap<String, Box<dyn LexiconIngestor + Send + Sync>>>,
-    jetstream_connection: JetstreamConnection,
-    pub msg_rx: flume::Receiver<Message>,
-    pub reconnect_tx: flume::Sender<()>,
-}
-
-/// The data we get back from handlers of the Jetstream.
-#[derive(Serialize, Deserialize)]
-pub struct HydratedStatus {
-    ///Handle may not always be hydrated depending on the target.
-    pub handle: Option<String>,
-    pub did: String,
-    pub status: atproto_api::xyz::statusphere::status::RecordData,
-}
-
-/// Trait to share some similar types between jetstream implementations
-pub trait StatusphereIngesterTrait: Send + Sync {
-    fn ingest(&self, status: HydratedStatus) -> Result<(), Error>;
-}
-
-/// our non wasm32 Injester
-#[cfg(not(target_arch = "wasm32"))]
-pub struct StatusphereIngester<F>
-where
-    F: StatusphereIngesterTrait,
-{
-    status_sphere_agent: BotApi,
-    handler: F,
-}
-
-// #[cfg(not(target_arch = "wasm32"))]
-// impl StatusSphereListener {
-//     pub fn new<F>(handler: F) -> Self
-//     where
-//         F: StatusphereIngesterTrait + Send + Sync + 'static,
-//     {
-//         // init the builder
-//         let opts = JetstreamOptions::builder()
-//             // your EXACT nsids
-//             .wanted_collections(vec![
-//                 atproto_api::xyz::statusphere::Status::NSID.to_string(),
-//             ])
-//             .build();
-//         // create the jetstream connector
-//         let jetstream = JetstreamConnection::new(opts);
-//
-//         // tracks the last message we've processed
-//         let cursor: Arc<Mutex<Option<u64>>> = Arc::new(Mutex::new(None));
-//
-//         // get channels
-//         let msg_rx = jetstream.get_msg_rx();
-//         let reconnect_tx = jetstream.get_reconnect_tx();
-//
-//         // create your ingestors
-//         let mut injestors: HashMap<String, Box<dyn LexiconIngestor + Send + Sync>> = HashMap::new();
-//
-//         injestors.insert(
-//             atproto_api::xyz::statusphere::Status::NSID.to_string(),
-//             Box::new(StatusphereIngester {
-//                 status_sphere_agent: BotApi::new(),
-//                 handler,
-//             }),
-//         );
-//         Self {
-//             cursor,
-//             ingestors: Arc::new(injestors),
-//             jetstream_connection: jetstream,
-//             msg_rx,
-//             reconnect_tx,
-//         }
-//     }
-//
-//     /// Start listening to the jetstream for new statusphere updates
-//     pub async fn listen(&self) -> Result<(), Error> {
-//         let msg_rx = self.msg_rx.clone();
-//         let ingestors = Arc::clone(&self.ingestors);
-//         let reconnect_tx = self.reconnect_tx.clone();
-//         let cursor = self.cursor.clone();
-//
-//         tokio::spawn(async move {
-//             while let Ok(message) = msg_rx.recv_async().await {
-//                 if let Err(e) = handler::handle_message(
-//                     message,
-//                     &ingestors,
-//                     reconnect_tx.clone(),
-//                     cursor.clone(),
-//                 )
-//                 .await
-//                 {
-//                     //Just error internally since this is a template
-//                     eprintln!("Error processing message: {}", e);
-//                 };
-//             }
-//         });
-//
-//         // connect to jetstream
-//         // retries internally, but may fail if there is an extreme error.
-//         self.jetstream_connection
-//             .connect(self.cursor.clone())
-//             .await
-//             .map_err(|e| Error::GeneralError(e.to_string()))
-//     }
-// }
-//
-// /// Shows a Jestream Listener for desktop or server side
-// #[cfg(not(target_arch = "wasm32"))]
-// #[async_trait]
-// impl<F: StatusphereIngesterTrait + Send + Sync> LexiconIngestor for StatusphereIngester<F> {
-//     async fn ingest(
-//         &self,
-//         message: rocketman::types::event::Event<serde_json::Value>,
-//     ) -> anyhow::Result<()> {
-//         if let Some(commit) = &message.commit {
-//             let handle = self
-//                 .status_sphere_agent
-//                 .get_handle(message.did.clone())
-//                 .await?;
-//
-//             match commit.operation {
-//                 Operation::Create | Operation::Update => {
-//                     if let Some(record) = &commit.record {
-//                         let status_at_proto_record = serde_json::from_value::<
-//                             atproto_api::xyz::statusphere::status::RecordData,
-//                         >(record.clone())?;
-//
-//                         if let Some(ref _cid) = commit.cid {
-//                             self.handler.ingest(HydratedStatus {
-//                                 handle: Some(handle),
-//                                 did: message.did,
-//                                 status: status_at_proto_record.clone(),
-//                             })?;
-//                         }
-//                         Ok::<(), anyhow::Error>(())
-//                     } else {
-//                         Ok::<(), anyhow::Error>(())
-//                     }
-//                 }
-//                 Operation::Delete => Ok::<(), anyhow::Error>(()),
-//             }
-//         } else {
-//             Ok(())
-//         }
-//     }
-// }
-
-#[cfg(target_arch = "wasm32")]
-/// Just a simple jetstream listener with a lot less features than Rocketman but just to show it can happen and sharing code
-pub fn listen<F>(on_messa_handler: F) -> Result<(), Error>
-where
-    F: StatusphereIngesterTrait + 'static,
-{
-    // Connect to an echo server
-    let ws = WebSocket::new(
-        "wss://jetstream1.us-east.bsky.network/subscribe?wantedCollections=xyz.statusphere.status",
-    )
-    //HACK prob dont want that unwrap either, but this is just a template
-    .map_err(|e| Error::GeneralError(String::try_from(e).unwrap()))?;
-    // For small binary messages, like CBOR, Arraybuffer is more efficient than Blob handling
-    ws.set_binary_type(web_sys::BinaryType::Arraybuffer);
-    // create callback
-    let on_message = Closure::<dyn FnMut(_)>::new(move |e: MessageEvent| {
-        //We're just handling txt to make it easy
-        if let Ok(txt) = e.data().dyn_into::<js_sys::JsString>() {
-            //HACK .into_Serde() on jsvalue of e.data() was not working for some reason
-            let txt_str = String::from(txt);
-            let envelope: WasmEvent<atproto_api::xyz::statusphere::status::RecordData> =
-                serde_json::from_str(&txt_str).unwrap();
-            if let Some(commit) = envelope.commit {
-                if let Some(record) = commit.record {
-                    let _ = on_message_handler.ingest(HydratedStatus {
-                        handle: None,
-                        did: envelope.did,
-                        status: record,
-                    });
-                }
-            }
-        }
-    });
-
-    // set message event handler on WebSocket
-    ws.set_onmessage(Some(on_message.as_ref().unchecked_ref()));
-    // forget the callback to keep it alive
-    on_message.forget();
-
-    let onerror_callback = Closure::<dyn FnMut(_)>::new(move |_e: ErrorEvent| {
-        //HACK would put an actual error handler here
-    });
-    ws.set_onerror(Some(onerror_callback.as_ref().unchecked_ref()));
-    onerror_callback.forget();
-    let onopen_callback = Closure::<dyn FnMut()>::new(move || {
-        //HACK
-    });
-    ws.set_onopen(Some(onopen_callback.as_ref().unchecked_ref()));
-    onopen_callback.forget();
-    Ok(())
-}
-
-///Shamelessly taken from rocketman. reimplmenting because Rocketman is not wasm compatible
-/// Ideally you would have the same types between packages but just a proof of concept
-/// https://github.com/espeon/cadet/blob/f034b19b73df4ac97e3ae54162d48883f81ff168/rocketman/src/types/event.rs#L14
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-struct WasmEvent<T> {
-    pub did: String,
-    pub commit: Option<WasmCommit<T>>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct WasmCommit<T> {
-    pub rev: String,
-    pub operation: WasmOperation,
-    pub collection: String,
-    pub rkey: String,
-    pub record: Option<T>,
-    pub cid: Option<String>,
-}
-//
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-enum WasmOperation {
-    Create,
-    Update,
-    Delete,
-}

slingshot/Cargo.toml

···
+[package]
+name = "slingshot"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+serde.workspace = true
+reqwest.workspace = true
+serde_json.workspace = true
+thiserror = "1"
+url = "2"
+
+[dev-dependencies]
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

slingshot/src/lib.rs

···
+use reqwest::Url;
+use serde::de::DeserializeOwned;
+use serde::Deserialize;
+use thiserror::Error;
+
+/// Error type for the slingshot crate
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("invalid base url: {0}")]
+    Url(#[from] url::ParseError),
+    #[error("http error: {0}")]
+    Http(#[from] reqwest::Error),
+    #[error("request failed with status {status}: {body}")]
+    Status { status: u16, body: String },
+    #[error("json error: {0}")]
+    Json(#[from] serde_json::Error),
+}
+
+/// Simple HTTP client for AT Protocol endpoints
+///
+/// Example endpoint implemented: com.atproto.repo.getRecord
+pub struct Slingshot {
+    base: Url,
+    client: reqwest::Client,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct RecordRapper<T> {
+    pub cid: String,
+    pub uri: String,
+    pub value: T,
+}
+
+impl Slingshot {
+    /// Create a new Slingshot client with the given base URL.
+    /// Example base URL: https://slingshot.microcosm.blue/
+    pub fn new(base_url: impl AsRef<str>) -> Result<Self, Error> {
+        let mut base = Url::parse(base_url.as_ref())?;
+        // Ensure trailing slash so join works consistently
+        if !base.as_str().ends_with('/') {
+            base = Url::parse(&(base.as_str().to_owned() + "/"))?;
+        }
+        let client = reqwest::Client::new();
+        Ok(Self { base, client })
+    }
+
+    /// Call com.atproto.repo.getRecord
+    ///
+    /// Maps to:
+    /// GET /xrpc/com.atproto.repo.getRecord?repo=<did>&collection=<collection>&rkey=<recordKey>
+    pub async fn get_record<T: DeserializeOwned>(
+        &self,
+        did: &str,
+        collection: &str,
+        record_key: &str,
+    ) -> Result<RecordRapper<T>, Error> {
+        let mut url = self.base.join("/xrpc/com.atproto.repo.getRecord")?;
+        url.query_pairs_mut()
+            .append_pair("repo", did)
+            .append_pair("collection", collection)
+            .append_pair("rkey", record_key);
+
+        let resp = self.client.get(url).send().await?;
+        let status = resp.status();
+        let bytes = resp.bytes().await?;
+        if !status.is_success() {
+            let body = String::from_utf8_lossy(&bytes).to_string();
+            return Err(Error::Status {
+                status: status.as_u16(),
+                body,
+            });
+        }
+        let value: RecordRapper<T> = serde_json::from_slice(&bytes)?;
+        Ok(value)
+    }
+}