+2

deno.json

reviewed

··· 11 11 "exclude": ["**/_fresh/*"], 12 12 "imports": { 13 13 "@atcute/atproto": "npm:@atcute/atproto@^3.1.4", 14 14 + "@atcute/bluesky": "npm:@atcute/bluesky@^3.2.16", 14 15 "@atcute/bluesky-richtext-builder": "npm:@atcute/bluesky-richtext-builder@^2.0.4", 15 16 "@atcute/client": "npm:@atcute/client@^4.0.3", 17 17 + "@atcute/identity": "npm:@atcute/identity@^1.1.3", 16 18 "@atcute/identity-resolver": "npm:@atcute/identity-resolver@^1.1.3", 17 19 "@atcute/lexicons": "npm:@atcute/lexicons@^1.1.1", 18 20 "@std/dotenv": "jsr:@std/dotenv@^0.225.5",

+14 -16

deno.lock

reviewed

··· 23 23 "jsr:@std/uuid@^1.0.9": "1.0.9", 24 24 "npm:@atcute/atproto@^3.1.4": "3.1.10", 25 25 "npm:@atcute/bluesky-richtext-builder@^2.0.4": "2.0.4", 26 26 + "npm:@atcute/bluesky@^3.2.16": "3.2.16", 26 27 "npm:@atcute/client@^4.0.3": "4.0.3", 27 27 - "npm:@atcute/identity-resolver@^1.1.3": "1.1.3_@atcute+identity@1.1.0", 28 28 + "npm:@atcute/identity-resolver@^1.1.3": "1.1.3_@atcute+identity@1.1.3", 29 29 + "npm:@atcute/identity@^1.1.3": "1.1.3", 28 30 "npm:@atcute/lexicons@^1.1.1": "1.2.7", 29 31 "npm:@opentelemetry/api@^1.9.0": "1.9.0", 30 32 "npm:@preact/signals@^2.2.1": "2.6.2_preact@10.28.3", ··· 141 143 "@atcute/atproto@3.1.10": { 142 144 "integrity": "sha512-+GKZpOc0PJcdWMQEkTfg/rSNDAAHxmAUGBl60g2az15etqJn5WaUPNGFE2sB7hKpwi5Ue2h/L0OacINcE/JDDQ==", 143 145 "dependencies": [ 144 144 - "@atcute/lexicons@1.2.7" 146 146 + "@atcute/lexicons" 145 147 ] 146 148 }, 147 149 "@atcute/bluesky-richtext-builder@2.0.4": { 148 150 "integrity": "sha512-ydA9VWBPsBE/gbu1vYbmh7AZ8FLfxp+LE4eH5GgOTCOxwhs7Mgy1oHrHY+Er6gu6PfdoUoGso0uI3Wl3ZF/Mxg==", 149 151 "dependencies": [ 150 152 "@atcute/bluesky", 151 151 - "@atcute/lexicons@1.2.7" 153 153 + "@atcute/lexicons" 152 154 ] 153 155 }, 154 156 "@atcute/bluesky@3.2.16": { 155 157 "integrity": "sha512-phFAJNE+SCkIbCcgzjFxntS2KpGvzkLw0JA9qKIXlueF4wNreEt/D5HjnB5eRR9pV1/kcD94II9f7ZAwarf0lQ==", 156 158 "dependencies": [ 157 159 "@atcute/atproto", 158 158 - "@atcute/lexicons@1.2.7" 160 160 + "@atcute/lexicons" 159 161 ] 160 162 }, 161 163 "@atcute/client@4.0.3": { 162 164 "integrity": "sha512-RIOZWFVLca/HiPAAUDqQPOdOreCxTbL5cb+WUf5yqQOKIu5yEAP3eksinmlLmgIrlr5qVOE7brazUUzaskFCfw==", 163 165 "dependencies": [ 164 166 "@atcute/identity", 165 165 - "@atcute/lexicons@1.1.1" 167 167 + "@atcute/lexicons" 166 168 ] 167 169 }, 168 168 - "@atcute/identity-resolver@1.1.3_@atcute+identity@1.1.0": { 170 170 + "@atcute/identity-resolver@1.1.3_@atcute+identity@1.1.3": { 169 171 "integrity": "sha512-KZgGgg99CWaV7Df3+h3X/WMrDzTPQVfsaoIVbTNLx2B56BvCL2EmaxPSVw/7BFUJMZHlVU4rtoEB4lyvNyMswA==", 170 172 "dependencies": [ 171 173 "@atcute/identity", 172 172 - "@atcute/lexicons@1.1.1", 174 174 + "@atcute/lexicons", 173 175 "@atcute/util-fetch", 174 176 "@badrap/valita" 175 177 ] 176 178 }, 177 177 - "@atcute/identity@1.1.0": { 178 178 - "integrity": "sha512-6vRvRqJatDB+JUQsb+UswYmtBGQnSZcqC3a2y6H5DB/v5KcIh+6nFFtc17G0+3W9rxdk7k9M4KkgkdKf/YDNoQ==", 179 179 + "@atcute/identity@1.1.3": { 180 180 + "integrity": "sha512-oIqPoI8TwWeQxvcLmFEZLdN2XdWcaLVtlm8pNk0E72As9HNzzD9pwKPrLr3rmTLRIoULPPFmq9iFNsTeCIU9ng==", 179 181 "dependencies": [ 180 180 - "@atcute/lexicons@1.1.1", 182 182 + "@atcute/lexicons", 181 183 "@badrap/valita" 182 182 - ] 183 183 - }, 184 184 - "@atcute/lexicons@1.1.1": { 185 185 - "integrity": "sha512-k6qy5p3j9fJJ6ekaMPfEfp3ni4TW/XNuH9ZmsuwC0fi0tOjp+Fa8ZQakHwnqOzFt/cVBfGcmYE/lKNAbeTjgUg==", 186 186 - "dependencies": [ 187 187 - "esm-env" 188 184 ] 189 185 }, 190 186 "@atcute/lexicons@1.2.7": { ··· 428 424 "jsr:@std/dotenv@~0.225.5", 429 425 "npm:@atcute/atproto@^3.1.4", 430 426 "npm:@atcute/bluesky-richtext-builder@^2.0.4", 427 427 + "npm:@atcute/bluesky@^3.2.16", 431 428 "npm:@atcute/client@^4.0.3", 432 429 "npm:@atcute/identity-resolver@^1.1.3", 430 430 + "npm:@atcute/identity@^1.1.3", 433 431 "npm:@atcute/lexicons@^1.1.1", 434 432 "npm:@preact/signals@^2.5.0", 435 433 "npm:preact@^10.27.2"

+97 -10

utils/atcuteUtils.ts

reviewed

··· 5 5 ok, 6 6 simpleFetchHandler, 7 7 } from "@atcute/client"; 8 8 - import type {} from "@atcute/atproto"; 8 8 + import { 9 9 + type DidDocument, 10 10 + getAtprotoHandle, 11 11 + getPdsEndpoint, 12 12 + isAtprotoDid, 13 13 + } from "@atcute/identity"; 9 14 import { 15 15 + AtprotoWebDidDocumentResolver, 16 16 + CompositeDidDocumentResolver, 10 17 CompositeHandleResolver, 11 18 DohJsonHandleResolver, 19 19 + PlcDidDocumentResolver, 12 20 WellKnownHandleResolver, 13 21 } from "@atcute/identity-resolver"; 14 22 import { Handle } from "@atcute/lexicons"; 15 23 import { isHandle } from "@atcute/lexicons/syntax"; 16 24 17 25 // Configuration for initializing a Streamplace client 18 18 - export interface StreamplaceClientConfig { 26 26 + export interface AtprotoClientConfig { 19 27 username: string; 20 28 password: string; 21 29 pdsHostUrl: string; 22 30 } 23 31 24 32 // Wrapper class for managing a single bot's credentials and RPC client 25 25 - export class StreamplaceClient { 33 33 + export class AtprotoClient { 26 34 private credentialManager: CredentialManager; 27 35 private rpcClient: Client; 28 28 - private config: StreamplaceClientConfig; 36 36 + private config: AtprotoClientConfig; 29 37 private initialized: boolean = false; 30 38 31 31 - constructor(config: StreamplaceClientConfig) { 39 39 + constructor(config: AtprotoClientConfig) { 32 40 this.config = config; 33 41 this.credentialManager = new CredentialManager({ 34 42 service: config.pdsHostUrl, ··· 62 70 async createMessage( 63 71 text: string, 64 72 streamerDid: string, 65 65 - facets?: any, 73 73 + facets?: Facet[], 66 74 replyTo?: { 67 75 rootUri: string; 68 76 rootCid: string; 69 77 parentUri: string; 70 78 parentCid: string; 71 79 }, 72 72 - ): Promise<any> { 80 80 + ) { 73 81 await this.ensureInitialized(); 74 82 75 83 // Create the message record according to the lexicon ··· 114 122 } 115 123 116 124 // Get shoutouts from a specific DID's repository 117 117 - async getShoutouts(did: Did, pdsFallback?: string): Promise<any> { 118 118 - await this.ensureInitialized(); 119 119 - 125 125 + async getShoutouts(did: Did, pdsFallback?: string) { 120 126 const rpc = new Client({ 121 127 // TODO: get dynamic PDS - for now using fallback or configured PDS 122 128 handler: simpleFetchHandler({ ··· 159 165 160 166 return await handleResolver.resolve(handle); 161 167 } 168 168 + 169 169 + // Get DID document 170 170 + export async function getDidDocument(did: Did): Promise<DidDocument> { 171 171 + if (!isAtprotoDid(did)) { 172 172 + throw new Error("Not a valid DID identifier"); 173 173 + } 174 174 + 175 175 + let doc: DidDocument; 176 176 + const resolver = new CompositeDidDocumentResolver({ 177 177 + methods: { 178 178 + plc: new PlcDidDocumentResolver({ 179 179 + apiUrl: "https://plc.directory", 180 180 + }), 181 181 + web: new AtprotoWebDidDocumentResolver(), 182 182 + }, 183 183 + }); 184 184 + 185 185 + try { 186 186 + // TODO: did:web 187 187 + doc = await resolver.resolve(did); 188 188 + } catch (e) { 189 189 + console.error(e); 190 190 + throw new Error("Error during did document resolution"); 191 191 + } 192 192 + 193 193 + return doc; 194 194 + } 195 195 + 196 196 + // Get PDS host 197 197 + export function getPDS(doc: DidDocument) { 198 198 + const pds = getPdsEndpoint(doc); 199 199 + return pds; 200 200 + } 201 201 + 202 202 + // Get handle 203 203 + export function getHandle(doc: DidDocument) { 204 204 + const handle = getAtprotoHandle(doc); 205 205 + return handle; 206 206 + } 207 207 + 208 208 + // Get app.bsky.actor.profile 209 209 + export async function getActorProfile(did: Did, pdsHostUrl: string) { 210 210 + const rpc = new Client({ 211 211 + handler: simpleFetchHandler({ 212 212 + service: pdsHostUrl, 213 213 + }), 214 214 + }); 215 215 + 216 216 + const actorProfile = await ok( 217 217 + rpc.get("com.atproto.repo.getRecord", { 218 218 + params: { 219 219 + repo: did, 220 220 + collection: "app.bsky.actor.profile", 221 221 + rkey: "self", 222 222 + }, 223 223 + }), 224 224 + ); 225 225 + 226 226 + return actorProfile; 227 227 + } 228 228 + 229 229 + // Get place.stream.chat.profile 230 230 + export async function getChatProfile(did: Did, pdsHostUrl: string) { 231 231 + const rpc = new Client({ 232 232 + handler: simpleFetchHandler({ 233 233 + service: pdsHostUrl, 234 234 + }), 235 235 + }); 236 236 + 237 237 + const actorProfile = await ok( 238 238 + rpc.get("com.atproto.repo.getRecord", { 239 239 + params: { 240 240 + repo: did, 241 241 + collection: "place.stream.chat.profile", 242 242 + rkey: "self", 243 243 + }, 244 244 + }), 245 245 + ); 246 246 + 247 247 + return actorProfile; 248 248 + }

+97 -99

utils/didResolver.ts

reviewed

··· 1 1 - interface PlcDirectoryResponse { 2 2 - "@context": string[]; 3 3 - id: Did; 4 4 - alsoKnownAs?: string[]; 5 5 - verificationMethod: unknown[]; 6 6 - service: Array<{ 7 7 - id: string; 8 8 - type: string; 9 9 - serviceEndpoint: string; 10 10 - }>; 11 11 - } 12 12 - 13 13 - interface ChatProfileResponse { 14 14 - uri: string; 15 15 - cid: string; 16 16 - value: { 17 17 - $type: "place.stream.chat.profile"; 18 18 - color: { 19 19 - red: number; 20 20 - green: number; 21 21 - blue: number; 22 22 - }; 23 23 - }; 24 24 - } 25 25 - 26 26 - interface UserProfile { 27 27 - handle: Handle; 28 28 - pdsEndpoint: string; 29 29 - color?: { 30 30 - red: number; 31 31 - green: number; 32 32 - blue: number; 33 33 - }; 34 34 - } 35 35 - 36 36 - const DEFAULT_COLOR = { 37 37 - red: 128, 38 38 - green: 128, 39 39 - blue: 128, 40 40 - }; 1 1 + import { 2 2 + getActorProfile, 3 3 + getChatProfile, 4 4 + getDidDocument, 5 5 + getHandle, 6 6 + getPDS, 7 7 + } from "./atcuteUtils.ts"; 8 8 + import { fetchPronouns } from "./labelUtils.ts"; 9 9 + declare type ActorProfile = import("@atcute/bluesky").AppBskyActorProfile.Main; 41 10 42 42 - class DidToHandleResolver { 11 11 + class DidResolver { 43 12 private cache = new Map<Did, UserProfile>(); 44 13 private pendingRequests = new Map<Did, Promise<UserProfile>>(); 45 45 - private readonly plcDirectoryUrl = "https://plc.directory"; 46 14 47 15 async resolve(did: Did): Promise<UserProfile> { 48 16 // Check cache first ··· 71 39 } 72 40 73 41 private async fetchProfile(did: Did): Promise<UserProfile> { 74 74 - // First, get the DID document from PLC directory 75 75 - const plcResponse = await fetch( 76 76 - `${this.plcDirectoryUrl}/${encodeURIComponent(did)}`, 77 77 - ); 42 42 + try { 43 43 + const didDocument = await getDidDocument(did); 44 44 + const pdsHostUrl = getPDS(didDocument); 45 45 + const handle = getHandle(didDocument); 78 46 79 79 - if (!plcResponse.ok) { 80 80 - throw new Error( 81 81 - `Failed to resolve DID ${did}: ${plcResponse.statusText}`, 82 82 - ); 83 83 - } 47 47 + if (!pdsHostUrl || !handle) { 48 48 + throw new Error(`Error fetching PDS host or handle for ${did}`); 49 49 + } 84 50 85 85 - const plcData: PlcDirectoryResponse = await plcResponse.json(); 51 51 + const [actorProfileResult, chatProfileResult, pronounLabelsResult] = 52 52 + await Promise.allSettled([ 53 53 + getActorProfile(did, pdsHostUrl), 54 54 + getChatProfile(did, pdsHostUrl), 55 55 + fetchPronouns([did]), 56 56 + ]); 86 57 87 87 - // Extract handle from alsoKnownAs 88 88 - if (!plcData.alsoKnownAs || plcData.alsoKnownAs.length === 0) { 89 89 - throw new Error(`No handle found for DID ${did}`); 90 90 - } 91 91 - 92 92 - const handle = plcData.alsoKnownAs[0].replace(/^at:\/\//, "") as Handle; 93 93 - 94 94 - // Find the PDS endpoint 95 95 - const pdsService = plcData.service.find((s) => 96 96 - s.type === "AtprotoPersonalDataServer" 97 97 - ); 98 98 - 99 99 - if (!pdsService) { 100 100 - throw new Error(`No PDS service found for DID ${did}`); 101 101 - } 102 102 - 103 103 - const pdsEndpoint = pdsService.serviceEndpoint; 104 104 - 105 105 - // Now fetch the chat profile 106 106 - let color = DEFAULT_COLOR; 58 58 + // Extract values from results, handling failures gracefully 59 59 + const actorProfile = actorProfileResult.status === "fulfilled" 60 60 + ? actorProfileResult.value 61 61 + : null; 62 62 + const chatProfile = chatProfileResult.status === "fulfilled" 63 63 + ? chatProfileResult.value 64 64 + : null; 65 65 + const pronounLabels = pronounLabelsResult.status === "fulfilled" 66 66 + ? pronounLabelsResult.value.get(did) 67 67 + : []; 107 68 108 108 - try { 109 109 - const profileUrl = new URL( 110 110 - `${pdsEndpoint}/xrpc/com.atproto.repo.getRecord`, 111 111 - ); 112 112 - profileUrl.searchParams.set("repo", did); 113 113 - profileUrl.searchParams.set( 114 114 - "collection", 115 115 - "place.stream.chat.profile", 116 116 - ); 117 117 - profileUrl.searchParams.set("rkey", "self"); 69 69 + const userProfile: UserProfile = { 70 70 + handle: handle as Handle, 71 71 + pdsEndpoint: pdsHostUrl, 72 72 + website: undefined, 73 73 + pronouns: [], 74 74 + description: undefined, 75 75 + displayName: undefined, 76 76 + color: undefined, 77 77 + }; 118 78 119 119 - const profileResponse = await fetch(profileUrl.toString()); 79 79 + // Safely extract values from actorProfile & chatProfile 80 80 + if (actorProfile?.value) { 81 81 + const actor = actorProfile.value as ActorProfile; 82 82 + interface BlobWithRef { 83 83 + $type: string; 84 84 + ref: { 85 85 + $link: string; 86 86 + }; 87 87 + mimeType?: string; 88 88 + size?: number; 89 89 + } 90 90 + const avatar = actor.avatar 91 91 + ? actor.avatar as BlobWithRef 92 92 + : undefined; 93 93 + const banner = actor.banner 94 94 + ? actor.banner as BlobWithRef 95 95 + : undefined; 120 96 121 121 - if (profileResponse.ok) { 122 122 - const profileData: ChatProfileResponse = await profileResponse 123 123 - .json(); 124 124 - if (profileData.value?.color) { 125 125 - color = profileData.value.color; 97 97 + userProfile.website = actor.website || undefined; 98 98 + userProfile.description = actor.description || 99 99 + undefined; 100 100 + userProfile.displayName = actor.displayName || 101 101 + undefined; 102 102 + userProfile.avatarUrl = avatar?.ref.$link 103 103 + ? `${pdsHostUrl}/xrpc/com.atproto.sync.getBlob?did=${did}&cid=${avatar.ref.$link}` 104 104 + : undefined; 105 105 + userProfile.bannerUrl = banner?.ref.$link 106 106 + ? `${pdsHostUrl}/xrpc/com.atproto.sync.getBlob?did=${did}&cid=${banner.ref.$link}` 107 107 + : undefined; 108 108 + if (actor.pronouns) { 109 109 + userProfile.pronouns = [ 110 110 + actor.pronouns, 111 111 + ]; 112 112 + } else if (pronounLabels && pronounLabels.length > 0) { 113 113 + userProfile.pronouns = pronounLabels; 114 114 + } else { 115 115 + userProfile.pronouns = []; 126 116 } 127 117 } 128 128 - // If profile doesn't exist or fetch fails, we'll use the default color 118 118 + if (chatProfile?.value?.color) { 119 119 + userProfile.color = chatProfile.value.color as { 120 120 + red: number; 121 121 + green: number; 122 122 + blue: number; 123 123 + }; 124 124 + } 125 125 + 126 126 + return userProfile; 129 127 } catch (error) { 130 130 - console.warn(`Failed to fetch chat profile for ${did}:`, error); 131 131 - // Continue with default color 128 128 + console.error(`Error fetching profile for ${did}:`, error); 129 129 + throw new Error( 130 130 + `Failed to fetch profile for ${did}: ${ 131 131 + error instanceof Error ? error.message : "Unknown error" 132 132 + }`, 133 133 + ); 132 134 } 135 135 + } 133 136 134 134 - return { 135 135 - handle, 136 136 - pdsEndpoint, 137 137 - color, 138 138 - }; 137 137 + clearUserFromCache(did: Did) { 138 138 + this.cache.delete(did); 139 139 } 140 140 141 141 - // Optional: Clear cache if needed 142 141 clearCache() { 143 142 this.cache.clear(); 144 143 } 145 144 146 146 - // Optional: Get cache size for monitoring 147 145 getCacheSize(): number { 148 146 return this.cache.size; 149 147 } 150 148 } 151 149 152 150 // Export singleton instance 153 153 - export const didResolver = new DidToHandleResolver(); 151 151 + export const didResolver = new DidResolver();

+19

utils/globals.d.ts

reviewed

··· 1 1 declare type Did = import("@atcute/lexicons").Did; 2 2 declare type Handle = import("@atcute/lexicons").Handle; 3 3 + declare type Facet = import("@atcute/bluesky").AppBskyRichtextFacet.Main; 3 4 4 5 // Raw chat message as received from stream.place WebSocket 5 6 interface RawChatMessage { ··· 67 68 }; 68 69 cid: string; 69 70 }; 71 71 + } 72 72 + 73 73 + // Handle + app.bsky.actor.profile + place.stream.chat.profile 74 74 + // + pronouns from labeler for maximum info about chatter 75 75 + interface UserProfile { 76 76 + handle: Handle; 77 77 + pdsEndpoint: string; 78 78 + color?: { 79 79 + red: number; 80 80 + green: number; 81 81 + blue: number; 82 82 + }; 83 83 + avatarUrl?: string, 84 84 + bannerUrl?: string, 85 85 + website?: string, 86 86 + pronouns?: string[], 87 87 + description?: string, 88 88 + displayName?: string, 70 89 } 71 90 72 91 // Label for display (pronouns, roles, etc.)

+106 -286

utils/labelUtils.ts

reviewed

··· 35 35 }; 36 36 } 37 37 38 38 - // Configuration for labeling service 39 39 - interface LabelingServiceConfig { 40 40 - apiBase: string; 41 41 - labelerDid: string; 42 42 - definitionsEndpoint: string; 43 43 - longCacheTtl?: number; // For users with labels (default 24 hours) 44 44 - shortCacheTtl?: number; // For users without labels (default 5 minutes) 45 45 - } 38 38 + // Generic label fetching 39 39 + export async function fetchLabels( 40 40 + apiBase: string, 41 41 + _definitionsEndpoint: string, 42 42 + dids: string[], 43 43 + ): Promise<Map<string, Label[]>> { 44 44 + const results = new Map<string, Label[]>(); 46 45 47 47 - export class GenericLabelingService { 48 48 - private labelDefinitions: Map<string, LabelDefinition> = new Map(); 49 49 - private cache: Map<string, MessageLabel[]> = new Map(); 50 50 - private cacheExpiry: Map<string, number> = new Map(); 51 51 - private readonly config: LabelingServiceConfig; 52 52 - private readonly longCacheTtl: number; // For users with labels 53 53 - private readonly shortCacheTtl: number; // For users without labels 54 54 - 55 55 - constructor(config: LabelingServiceConfig) { 56 56 - this.config = config; 57 57 - this.longCacheTtl = config.longCacheTtl ?? 24 * 60 * 60 * 1000; // Default 24 hours 58 58 - this.shortCacheTtl = config.shortCacheTtl ?? 5 * 60 * 1000; // Default 5 minutes 59 59 - this.loadLabelDefinitions(); 60 60 - } 61 61 - 62 62 - private async loadLabelDefinitions(): Promise<void> { 63 63 - try { 64 64 - const response = await fetch(this.config.definitionsEndpoint); 65 65 - 66 66 - if (!response.ok) { 67 67 - console.error("Failed to load label definitions"); 68 68 - return; 69 69 - } 70 70 - 71 71 - const data = await response.json() as { 72 72 - value: LabelServiceDefinition; 73 73 - }; 74 74 - const definitions = data.value.policies.labelValueDefinitions; 75 75 - 76 76 - for (const def of definitions) { 77 77 - this.labelDefinitions.set(def.identifier, def); 78 78 - } 79 79 - 80 80 - console.log( 81 81 - `Loaded ${definitions.length} label definitions from ${this.config.labelerDid}`, 82 82 - ); 83 83 - } catch (error) { 84 84 - console.error("Error loading label definitions:", error); 85 85 - } 46 46 + if (dids.length === 0) { 47 47 + return results; 86 48 } 87 49 88 88 - async fetchLabelsForUsers( 89 89 - dids: string[], 90 90 - labelConverter?: ( 91 91 - labels: Label[], 92 92 - definitions: Map<string, LabelDefinition>, 93 93 - ) => MessageLabel[], 94 94 - ): Promise<Map<string, MessageLabel[]>> { 95 95 - const results = new Map<string, MessageLabel[]>(); 96 96 - const uncachedDids: string[] = []; 50 50 + try { 51 51 + // Batch request for labels 52 52 + const uriPatterns = dids.join(","); 53 53 + const labelsResponse = await fetch( 54 54 + `${apiBase}/com.atproto.label.queryLabels?uriPatterns=${ 55 55 + encodeURIComponent(uriPatterns) 56 56 + }`, 57 57 + ); 97 58 98 98 - // Separate cached from uncached 99 99 - for (const did of dids) { 100 100 - const cached = this.getCachedLabels(did); 101 101 - if (cached !== null) { 102 102 - results.set(did, cached); 103 103 - } else { 104 104 - uncachedDids.push(did); 105 105 - } 106 106 - } 107 107 - 108 108 - if (uncachedDids.length === 0) { 59 59 + if (!labelsResponse.ok) { 60 60 + console.warn("Failed to batch fetch labels"); 109 61 return results; 110 62 } 111 63 112 112 - try { 113 113 - // Batch request for uncached DIDs 114 114 - const uriPatterns = uncachedDids.join(","); 115 115 - const response = await fetch( 116 116 - `${this.config.apiBase}/com.atproto.label.queryLabels?uriPatterns=${ 117 117 - encodeURIComponent(uriPatterns) 118 118 - }`, 119 119 - ); 120 120 - 121 121 - if (!response.ok) { 122 122 - console.warn("Failed to batch fetch labels"); 123 123 - // Return empty arrays for uncached DIDs 124 124 - for (const did of uncachedDids) { 125 125 - results.set(did, []); 126 126 - } 127 127 - return results; 128 128 - } 64 64 + const data = await labelsResponse.json() as LabelApiResponse; 129 65 130 130 - const data = await response.json() as LabelApiResponse; 131 131 - 132 132 - // Group labels by DID 133 133 - const labelsByDid = new Map<string, Label[]>(); 134 134 - for (const label of data.labels) { 135 135 - if (!labelsByDid.has(label.uri)) { 136 136 - labelsByDid.set(label.uri, []); 137 137 - } 138 138 - labelsByDid.get(label.uri)!.push(label); 66 66 + // Group labels by DID 67 67 + for (const label of data.labels) { 68 68 + if (!results.has(label.uri)) { 69 69 + results.set(label.uri, []); 139 70 } 71 71 + results.get(label.uri)!.push(label); 72 72 + } 140 73 141 141 - // Convert and cache results 142 142 - for (const did of uncachedDids) { 143 143 - const rawLabels = labelsByDid.get(did) || []; 144 144 - const messageLabels = labelConverter 145 145 - ? labelConverter(rawLabels, this.labelDefinitions) 146 146 - : this.defaultLabelConverter(rawLabels); 147 147 - 148 148 - results.set(did, messageLabels); 149 149 - this.cache.set(did, messageLabels); 150 150 - 151 151 - // Use different cache TTL based on whether user has labels 152 152 - const cacheTtl = messageLabels.length > 0 153 153 - ? this.longCacheTtl 154 154 - : this.shortCacheTtl; 155 155 - this.cacheExpiry.set(did, Date.now() + cacheTtl); 156 156 - } 157 157 - } catch (error) { 158 158 - console.error("Error in batch label fetch:", error); 159 159 - // Return empty arrays for failed requests 160 160 - for (const did of uncachedDids) { 74 74 + // Ensure all requested DIDs have an entry 75 75 + for (const did of dids) { 76 76 + if (!results.has(did)) { 161 77 results.set(did, []); 162 78 } 163 79 } 164 164 - 165 165 - return results; 166 166 - } 167 167 - 168 168 - // Convenience method for single user 169 169 - async fetchLabelsForUser( 170 170 - did: string, 171 171 - labelConverter?: ( 172 172 - labels: Label[], 173 173 - definitions: Map<string, LabelDefinition>, 174 174 - ) => MessageLabel[], 175 175 - ): Promise<MessageLabel[]> { 176 176 - const results = await this.fetchLabelsForUsers([did], labelConverter); 177 177 - return results.get(did) || []; 80 80 + } catch (error) { 81 81 + console.error("Error in batch label fetch:", error); 178 82 } 179 83 180 180 - private getCachedLabels(did: string): MessageLabel[] | null { 181 181 - const expiry = this.cacheExpiry.get(did); 182 182 - if (!expiry || Date.now() > expiry) { 183 183 - // Cache expired or doesn't exist 184 184 - this.cache.delete(did); 185 185 - this.cacheExpiry.delete(did); 186 186 - return null; 187 187 - } 188 188 - return this.cache.get(did) || null; 189 189 - } 84 84 + return results; 85 85 + } 190 86 191 191 - private defaultLabelConverter(labels: Label[]): MessageLabel[] { 192 192 - const messageLabels: MessageLabel[] = []; 193 193 - 194 194 - for (const label of labels) { 195 195 - if (label.neg) continue; // Skip negative labels 196 196 - 197 197 - const definition = this.labelDefinitions.get(label.val); 198 198 - if (!definition) { 199 199 - // Fallback for unknown labels 200 200 - messageLabels.push({ 201 201 - text: label.val, 202 202 - type: "custom", 203 203 - color: "#6b7280", // Default gray 204 204 - }); 205 205 - continue; 206 206 - } 207 207 - 208 208 - const englishLocale = definition.locales.find((l) => 209 209 - l.lang === "en" 210 210 - ); 211 211 - if (!englishLocale) continue; 212 212 - 213 213 - messageLabels.push({ 214 214 - text: englishLocale.name, 215 215 - type: "custom", 216 216 - color: "#6b7280", // Default gray 217 217 - }); 218 218 - } 87 87 + // Pronoun-specific fetching 88 88 + const PRONOUN_API_BASE = "https://api.pronouns.diy/xrpc"; 89 89 + const PRONOUN_DEFINITIONS_ENDPOINT = 90 90 + "https://pds.juli.ee/xrpc/com.atproto.repo.getRecord?repo=did:plc:wkoofae5uytcm7bjncmev6n6&collection=app.bsky.labeler.service&rkey=self"; 219 91 220 220 - return messageLabels; 221 221 - } 92 92 + async function loadPronounDefinitions(): Promise< 93 93 + Map<string, LabelDefinition> 94 94 + > { 95 95 + const definitions = new Map<string, LabelDefinition>(); 222 96 223 223 - // Force refresh specific users (useful for "user just set pronouns" scenario) 224 224 - forceRefreshUsers( 225 225 - dids: string[], 226 226 - labelConverter?: ( 227 227 - labels: Label[], 228 228 - definitions: Map<string, LabelDefinition>, 229 229 - ) => MessageLabel[], 230 230 - ): Promise<Map<string, MessageLabel[]>> { 231 231 - // Remove from cache first 232 232 - for (const did of dids) { 233 233 - this.cache.delete(did); 234 234 - this.cacheExpiry.delete(did); 97 97 + try { 98 98 + const response = await fetch(PRONOUN_DEFINITIONS_ENDPOINT); 99 99 + if (!response.ok) { 100 100 + console.error("Failed to load pronoun definitions"); 101 101 + return definitions; 235 102 } 236 103 237 237 - // Fetch fresh data 238 238 - return this.fetchLabelsForUsers(dids, labelConverter); 239 239 - } 104 104 + const data = await response.json() as { 105 105 + value: LabelServiceDefinition; 106 106 + }; 240 107 241 241 - // Clear expired cache entries periodically 242 242 - cleanupCache(): void { 243 243 - const now = Date.now(); 244 244 - for (const [did, expiry] of this.cacheExpiry.entries()) { 245 245 - if (now > expiry) { 246 246 - this.cache.delete(did); 247 247 - this.cacheExpiry.delete(did); 248 248 - } 108 108 + for (const def of data.value.policies.labelValueDefinitions) { 109 109 + definitions.set(def.identifier, def); 249 110 } 250 250 - } 251 251 - 252 252 - // Clear all cache (useful for new sessions) 253 253 - clearCache(): void { 254 254 - this.cache.clear(); 255 255 - this.cacheExpiry.clear(); 111 111 + } catch (error) { 112 112 + console.error("Error loading pronoun definitions:", error); 256 113 } 257 114 258 258 - // Get cache statistics 259 259 - getCacheStats(): { size: number; hitRate?: number } { 260 260 - return { 261 261 - size: this.cache.size, 262 262 - // You could track hit rate if needed by adding counters 263 263 - }; 264 264 - } 115 115 + return definitions; 265 116 } 266 117 267 267 - // Pronoun-specific service wrapper 268 268 - export class PronounService { 269 269 - private labelingService: GenericLabelingService; 118 118 + export async function fetchPronouns( 119 119 + dids: Did[], 120 120 + ): Promise<Map<Did, string[]>> { 121 121 + const results = new Map<Did, string[]>(); 270 122 271 271 - constructor() { 272 272 - const config: LabelingServiceConfig = { 273 273 - apiBase: "https://api.pronouns.diy/xrpc", 274 274 - labelerDid: "did:plc:wkoofae5uytcm7bjncmev6n6", 275 275 - definitionsEndpoint: 276 276 - "https://pds.juli.ee/xrpc/com.atproto.repo.getRecord?repo=did:plc:wkoofae5uytcm7bjncmev6n6&collection=app.bsky.labeler.service&rkey=self", 277 277 - longCacheTtl: 24 * 60 * 60 * 1000, // 24 hours for users with pronouns 278 278 - shortCacheTtl: 5 * 60 * 1000, // 5 minutes for users without pronouns 279 279 - }; 280 280 - 281 281 - this.labelingService = new GenericLabelingService(config); 123 123 + if (dids.length === 0) { 124 124 + return results; 282 125 } 283 126 284 284 - // Pronoun-specific label converter 285 285 - private pronounLabelConverter = ( 286 286 - labels: Label[], 287 287 - definitions: Map<string, LabelDefinition>, 288 288 - ): MessageLabel[] => { 289 289 - const messageLabels: MessageLabel[] = []; 290 290 - 291 291 - for (const label of labels) { 292 292 - if (label.neg) continue; // Skip negative labels 127 127 + try { 128 128 + // Load definitions and labels in parallel 129 129 + const [definitions, labelsResponse] = await Promise.all([ 130 130 + loadPronounDefinitions(), 131 131 + fetch( 132 132 + `${PRONOUN_API_BASE}/com.atproto.label.queryLabels?uriPatterns=${ 133 133 + encodeURIComponent(dids.join(",")) 134 134 + }`, 135 135 + ), 136 136 + ]); 293 137 294 294 - const definition = definitions.get(label.val); 295 295 - if (!definition) { 296 296 - // Fallback for unknown pronoun labels 297 297 - messageLabels.push({ 298 298 - text: label.val, 299 299 - type: "pronoun", 300 300 - color: "#6b7280", // Gray for pronouns 301 301 - }); 302 302 - continue; 303 303 - } 138 138 + if (!labelsResponse.ok) { 139 139 + console.warn("Failed to fetch pronouns"); 140 140 + return results; 141 141 + } 304 142 305 305 - const englishLocale = definition.locales.find((l) => 306 306 - l.lang === "en" 307 307 - ); 308 308 - if (!englishLocale) continue; 143 143 + const data = await labelsResponse.json() as LabelApiResponse; 309 144 310 310 - messageLabels.push({ 311 311 - text: englishLocale.name, 312 312 - type: "pronoun", 313 313 - color: "#6b7280", // Gray for pronouns 314 314 - }); 145 145 + // Group labels by DID 146 146 + const labelsByDid = new Map<string, Label[]>(); 147 147 + for (const label of data.labels) { 148 148 + if (!labelsByDid.has(label.uri)) { 149 149 + labelsByDid.set(label.uri, []); 150 150 + } 151 151 + labelsByDid.get(label.uri)!.push(label); 315 152 } 316 153 317 317 - return messageLabels; 318 318 - }; 319 319 - 320 320 - fetchPronounsForUsers( 321 321 - dids: string[], 322 322 - ): Promise<Map<string, MessageLabel[]>> { 323 323 - return this.labelingService.fetchLabelsForUsers( 324 324 - dids, 325 325 - this.pronounLabelConverter, 326 326 - ); 327 327 - } 154 154 + // Convert labels to pronoun strings 155 155 + for (const did of dids) { 156 156 + const labels = labelsByDid.get(did) || []; 157 157 + const pronouns: string[] = []; 328 158 329 329 - fetchPronounsForUser(did: string): Promise<MessageLabel[]> { 330 330 - return this.labelingService.fetchLabelsForUser( 331 331 - did, 332 332 - this.pronounLabelConverter, 333 333 - ); 334 334 - } 159 159 + for (const label of labels) { 160 160 + if (label.neg) continue; // Skip negative labels 335 161 336 336 - forceRefreshPronounsForUsers( 337 337 - dids: string[], 338 338 - ): Promise<Map<string, MessageLabel[]>> { 339 339 - return this.labelingService.forceRefreshUsers( 340 340 - dids, 341 341 - this.pronounLabelConverter, 342 342 - ); 343 343 - } 162 162 + const definition = definitions.get(label.val); 163 163 + if (!definition) { 164 164 + // Fallback for unknown labels 165 165 + pronouns.push(label.val); 166 166 + continue; 167 167 + } 344 168 345 345 - // Expose cache management methods 346 346 - cleanupCache(): void { 347 347 - this.labelingService.cleanupCache(); 348 348 - } 169 169 + const englishLocale = definition.locales.find((l) => 170 170 + l.lang === "en" 171 171 + ); 172 172 + if (englishLocale) { 173 173 + pronouns.push(englishLocale.name); 174 174 + } 175 175 + } 349 176 350 350 - clearCache(): void { 351 351 - this.labelingService.clearCache(); 177 177 + results.set(did, pronouns); 178 178 + } 179 179 + } catch (error) { 180 180 + console.error("Error fetching pronouns:", error); 352 181 } 353 182 354 354 - getCacheStats(): { size: number; hitRate?: number } { 355 355 - return this.labelingService.getCacheStats(); 356 356 - } 183 183 + return results; 357 184 } 358 358 - 359 359 - // testing 360 360 - const pronounService = new PronounService(); 361 361 - const pronouns = await pronounService.fetchPronounsForUser( 362 362 - "did:plc:o6xucog6fghiyrvp7pyqxcs3", 363 363 - ); 364 364 - console.log(pronouns);

+34 -119

utils/streamplaceBot.ts

reviewed

··· 1 1 import RichtextBuilder from "@atcute/bluesky-richtext-builder"; 2 2 - import { StreamplaceClient, StreamplaceClientConfig } from "./atcuteUtils.ts"; 2 2 + import { AtprotoClient, AtprotoClientConfig } from "./atcuteUtils.ts"; 3 3 import { didResolver } from "./didResolver.ts"; 4 4 5 5 export interface CommandHandler { 6 6 (message: JetstreamMessage, args: string[]): Promise<void> | void; 7 7 - } 8 8 - 9 9 - // Cached information about a chatter 10 10 - export interface Chatter { 11 11 - did: Did; 12 12 - handle: Handle; 13 13 - hasShoutout: boolean; 14 14 - hasBeenGreeted: boolean; 15 7 } 16 8 17 9 // Shoutout record from the repository 18 10 interface ShoutoutRecord { 19 11 user: Did; 20 12 text: string; 21 21 - facets?: any; 13 13 + facets?: Facet[]; 22 14 } 23 15 24 16 class StreamplaceBot { ··· 26 18 private commandPrefix: string; 27 19 private commands: Map<string, CommandHandler>; 28 20 private enabled: boolean; 29 29 - private client: StreamplaceClient; 21 21 + private client: AtprotoClient; 30 22 31 23 // Caching 32 32 - private chatters: Map<Did, Chatter> = new Map(); 33 24 private shoutouts: Map<Did, ShoutoutRecord> = new Map(); 25 25 + private hasBeenGreeted: Map<Did, boolean> = new Map(); 34 26 private shoutoutsLoaded: boolean = false; 35 27 36 28 /** ··· 41 33 */ 42 34 constructor( 43 35 streamerDid: Did, 44 44 - clientConfig: StreamplaceClientConfig, 36 36 + clientConfig: AtprotoClientConfig, 45 37 commandPrefix = "!", 46 38 ) { 47 39 this.streamerDid = streamerDid; 48 40 this.commandPrefix = commandPrefix; 49 41 this.commands = new Map(); 50 42 this.enabled = true; 51 51 - this.client = new StreamplaceClient(clientConfig); 43 43 + this.client = new AtprotoClient(clientConfig); 52 44 } 53 45 54 46 // Initialize the bot - must be called before use ··· 60 52 await this.loadShoutouts(); 61 53 62 54 // Register default commands 63 63 - await this.registerDefaultCommands(); 55 55 + this.registerDefaultCommands(); 64 56 65 57 console.log( 66 58 `StreamplaceBot initialized for streamer: ${this.streamerDid}`, ··· 71 63 private async loadShoutouts(): Promise<void> { 72 64 if (this.shoutoutsLoaded) return; 73 65 66 66 + const streamer = await this.getUserProfile(this.streamerDid); 74 67 try { 75 68 const shoutoutsData = await this.client.getShoutouts( 76 69 this.streamerDid, 77 77 - "https://pds.timtinkers.online", 70 70 + streamer.pdsEndpoint, 78 71 ); 79 72 80 73 // Cache all shoutouts ··· 82 75 const userDid = record.value.user as Did; 83 76 this.shoutouts.set(userDid, { 84 77 user: userDid, 85 85 - text: record.value.text, 86 86 - facets: record.value.facets, 78 78 + text: record.value.text as string, 79 79 + facets: record.value.facets as Facet[], 87 80 }); 88 81 89 89 - // Also resolve and cache the handle for users with shoutouts 90 90 - await this.getOrCacheChatter(userDid, true); 82 82 + // Also resolve and cache shoutoutees 83 83 + await this.getUserProfile(userDid); 91 84 } 92 85 93 86 this.shoutoutsLoaded = true; ··· 97 90 } 98 91 } 99 92 100 100 - // Get a chatter from cache or fetch and cache their information 101 101 - private async getOrCacheChatter( 102 102 - did: Did, 103 103 - hasShoutout: boolean = false, 104 104 - ): Promise<Chatter> { 105 105 - // Check if already cached 106 106 - let chatter = this.chatters.get(did); 107 107 - 108 108 - if (!chatter) { 109 109 - // Resolve handle and create new chatter entry 110 110 - try { 111 111 - const resolved = await didResolver.resolve(did); 112 112 - chatter = { 113 113 - did: did, 114 114 - handle: resolved.handle as Handle, 115 115 - hasShoutout: hasShoutout || this.shoutouts.has(did), 116 116 - hasBeenGreeted: false, 117 117 - }; 118 118 - this.chatters.set(did, chatter); 119 119 - console.log(`Cached new chatter: ${chatter.handle}`); 120 120 - } catch (error) { 121 121 - console.error(`Error resolving handle for DID ${did}:`, error); 122 122 - // Create minimal chatter entry even if resolution fails 123 123 - chatter = { 124 124 - did: did, 125 125 - handle: did as Handle, // Fallback to DID 126 126 - hasShoutout: hasShoutout || this.shoutouts.has(did), 127 127 - hasBeenGreeted: false, 128 128 - }; 129 129 - this.chatters.set(did, chatter); 130 130 - } 131 131 - } else if (hasShoutout && !chatter.hasShoutout) { 132 132 - // Update shoutout status if needed 133 133 - chatter.hasShoutout = true; 134 134 - } 135 135 - 93 93 + // Get a user profile from didResolver cache 94 94 + private async getUserProfile(did: Did) { 95 95 + const chatter = await didResolver.resolve(did); 136 96 return chatter; 137 97 } 138 98 139 139 - /** 140 140 - * Process an incoming chat message and respond if it's a command 141 141 - * @param message The chat message to process 142 142 - */ 99 99 + // Process an incoming chat message and respond if it's a command 143 100 async processMessage(message: JetstreamMessage): Promise<void> { 144 101 if (!this.enabled) return; 145 102 ··· 147 104 const text = record.text.trim(); 148 105 149 106 // Get or cache chatter information 150 150 - const chatter = await this.getOrCacheChatter(message.did); 107 107 + const chatter = await this.getUserProfile(message.did); 151 108 152 109 // Auto-greet first-time chatters with shoutout if they have one 153 153 - if (!chatter.hasBeenGreeted) { 154 154 - chatter.hasBeenGreeted = true; 110 110 + if (!this.hasBeenGreeted.get(message.did)) { 111 111 + this.hasBeenGreeted.set(message.did, true); 155 112 156 156 - if (chatter.hasShoutout) { 113 113 + if (this.shoutouts.get(message.did)) { 157 114 const shoutout = this.shoutouts.get(message.did); 158 115 if (shoutout) { 159 116 await this.sendMessage(shoutout.text, shoutout.facets); ··· 183 140 } 184 141 } 185 142 186 186 - /** 187 187 - * Register a new command 188 188 - * @param commandName Name of the command (without prefix) 189 189 - * @param handler Function to handle the command 190 190 - */ 143 143 + // @param commandName Name of the command (without prefix) 191 144 registerCommand(commandName: string, handler: CommandHandler): void { 192 145 this.commands.set(commandName.toLowerCase(), handler); 193 146 } 194 147 195 195 - /** 196 196 - * Remove a command 197 197 - * @param commandName Name of the command to remove 198 198 - */ 148 148 + // Remove a command 199 149 unregisterCommand(commandName: string): boolean { 200 150 return this.commands.delete(commandName.toLowerCase()); 201 151 } 202 152 203 203 - /** 204 204 - * Enable or disable the bot 205 205 - */ 153 153 + // Enable or disable the bot 206 154 setEnabled(enabled: boolean): void { 207 155 this.enabled = enabled; 208 156 } 209 157 210 210 - /** 211 211 - * Send a message to the chat 212 212 - * @param text Message text 213 213 - * @param facets Optional facets for mentions, links, etc. 214 214 - */ 215 215 - async sendMessage(text: string, facets?: any): Promise<void> { 158 158 + // Send a message to the chat 159 159 + async sendMessage(text: string, facets?: Facet[]): Promise<void> { 216 160 try { 217 217 - const result = await this.client.createMessage( 161 161 + await this.client.createMessage( 218 162 text, 219 163 this.streamerDid, 220 164 facets, 221 165 ); 222 222 - console.log(`Bot sent message: ${text}`); 223 166 } catch (error) { 224 167 console.error("Error sending bot message:", error); 225 168 } 226 169 } 227 170 228 228 - /** 229 229 - * Get the bot's DID 230 230 - */ 171 171 + // Get the bot's DID 231 172 getBotDid(): string | undefined { 232 173 return this.client.getDid(); 233 174 } 234 175 235 235 - /** 236 236 - * Get the streamer's DID 237 237 - */ 176 176 + // Get the streamer's DID 238 177 getStreamerDid(): string { 239 178 return this.streamerDid; 240 179 } 241 180 242 242 - /** 243 243 - * Get cached chatter information 244 244 - */ 245 245 - getChatter(did: Did): Chatter | undefined { 246 246 - return this.chatters.get(did); 247 247 - } 248 248 - 249 249 - /** 250 250 - * Get all cached chatters 251 251 - */ 252 252 - getAllChatters(): Map<Did, Chatter> { 253 253 - return new Map(this.chatters); 254 254 - } 255 255 - 256 256 - /** 257 257 - * Clear the chatter cache 258 258 - */ 259 259 - clearChatterCache(): void { 260 260 - this.chatters.clear(); 261 261 - console.log("Chatter cache cleared"); 262 262 - } 263 263 - 264 264 - /** 265 265 - * Reload shoutouts from the repository 266 266 - */ 181 181 + // Reload shoutouts from the repository 267 182 async reloadShoutouts(): Promise<void> { 268 183 this.shoutoutsLoaded = false; 269 184 this.shoutouts.clear(); ··· 290 205 return; 291 206 } 292 207 293 293 - const senderChatter = await this.getOrCacheChatter(message.did); 208 208 + const senderChatter = await this.getUserProfile(message.did); 294 209 const shoutouteeDid = message.commit.record.facets[0].features[0] 295 210 .did as Did; 296 296 - const shoutouteeChatter = await this.getOrCacheChatter( 211 211 + const shoutouteeChatter = await this.getUserProfile( 297 212 shoutouteeDid, 298 213 ); 299 214 ··· 326 241 return; 327 242 } 328 243 329 329 - const senderChatter = await this.getOrCacheChatter(message.did); 244 244 + const senderChatter = await this.getUserProfile(message.did); 330 245 const huggeeDid = message.commit.record.facets[0].features[0] 331 246 .did as Did; 332 332 - const huggeeChatter = await this.getOrCacheChatter(huggeeDid); 247 247 + const huggeeChatter = await this.getUserProfile(huggeeDid); 333 248 334 249 const { text, facets } = new RichtextBuilder() 335 250 .addMention(`@${senderChatter.handle}`, message.did)