@ewanc26/atproto 0.1.0 → 0.2.1

package/dist/agents.js

@@ -0,0 +1,102 @@
+import { AtpAgent } from '@atproto/api';
+import { cache } from './cache.js';
+export function createAgent(service, fetchFn) {
+    const wrappedFetch = fetchFn
+        ? async (url, init) => {
+            const urlStr = url instanceof URL ? url.toString() : url;
+            const response = await fetchFn(urlStr, init);
+            const headers = new Headers(response.headers);
+            if (!headers.has('content-type')) {
+                headers.set('content-type', 'application/json');
+            }
+            return new Response(response.body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers
+            });
+        }
+        : undefined;
+    return new AtpAgent({
+        service,
+        ...(wrappedFetch && { fetch: wrappedFetch })
+    });
+}
+export const constellationAgent = createAgent('https://constellation.microcosm.blue');
+export const defaultAgent = createAgent('https://public.api.bsky.app');
+let resolvedAgent = null;
+let pdsAgent = null;
+export async function resolveIdentity(did, fetchFn) {
+    const cacheKey = `identity:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const _fetch = fetchFn ?? globalThis.fetch;
+    const response = await _fetch(`https://slingshot.microcosm.blue/xrpc/com.bad-example.identity.resolveMiniDoc?identifier=${encodeURIComponent(did)}`);
+    if (!response.ok) {
+        throw new Error(`Failed to resolve identifier via Slingshot: ${response.status} ${response.statusText}`);
+    }
+    const rawText = await response.text();
+    let data;
+    try {
+        data = JSON.parse(rawText);
+    }
+    catch (err) {
+        throw new Error('Failed to parse identity resolver response');
+    }
+    if (!data.did || !data.pds) {
+        throw new Error('Invalid response from identity resolver');
+    }
+    cache.set(cacheKey, data);
+    return data;
+}
+export async function getPublicAgent(did, fetchFn) {
+    if (resolvedAgent)
+        return resolvedAgent;
+    try {
+        try {
+            const response = await constellationAgent.getProfile({ actor: did });
+            if (response.success) {
+                resolvedAgent = constellationAgent;
+                return resolvedAgent;
+            }
+        }
+        catch {
+            // fall through
+        }
+        const resolved = await resolveIdentity(did, fetchFn);
+        resolvedAgent = createAgent(resolved.pds, fetchFn);
+        return resolvedAgent;
+    }
+    catch {
+        resolvedAgent = defaultAgent;
+        return resolvedAgent;
+    }
+}
+export async function getPDSAgent(did, fetchFn) {
+    if (pdsAgent)
+        return pdsAgent;
+    const resolved = await resolveIdentity(did, fetchFn);
+    pdsAgent = createAgent(resolved.pds, fetchFn);
+    return pdsAgent;
+}
+export async function withFallback(did, operation, usePDSFirst = false, fetchFn) {
+    const defaultAgentFn = () => fetchFn ? createAgent('https://public.api.bsky.app', fetchFn) : Promise.resolve(defaultAgent);
+    const agents = usePDSFirst
+        ? [() => getPDSAgent(did, fetchFn), defaultAgentFn]
+        : [defaultAgentFn, () => getPDSAgent(did, fetchFn)];
+    let lastError;
+    for (const getAgent of agents) {
+        try {
+            const agent = await getAgent();
+            return await operation(agent);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError;
+}
+export function resetAgents() {
+    resolvedAgent = null;
+    pdsAgent = null;
+}

package/dist/cache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Cache TTL values in milliseconds (production defaults).
+ * All functions that previously read PUBLIC_ATPROTO_DID from the environment
+ * now accept `did: string` as their first argument.
+ */
+export declare const CACHE_TTL: {
+    readonly PROFILE: number;
+    readonly SITE_INFO: number;
+    readonly LINKS: number;
+    readonly MUSIC_STATUS: number;
+    readonly KIBUN_STATUS: number;
+    readonly TANGLED_REPOS: number;
+    readonly BLOG_POSTS: number;
+    readonly PUBLICATIONS: number;
+    readonly INDIVIDUAL_POST: number;
+    readonly IDENTITY: number;
+};
+export declare class ATProtoCache {
+    private cache;
+    private getTTL;
+    get<T>(key: string): T | null;
+    set<T>(key: string, data: T): void;
+    delete(key: string): void;
+    clear(): void;
+}
+export declare const cache: ATProtoCache;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;CAWZ,CAAC;AAEX,qBAAa,YAAY;IACxB,OAAO,CAAC,KAAK,CAAsC;IAEnD,OAAO,CAAC,MAAM;IAed,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAW7B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI;IAIlC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,KAAK,IAAI,IAAI;CAGb;AAED,eAAO,MAAM,KAAK,cAAqB,CAAC"}

package/dist/cache.js

@@ -0,0 +1,64 @@
+/**
+ * Cache TTL values in milliseconds (production defaults).
+ * All functions that previously read PUBLIC_ATPROTO_DID from the environment
+ * now accept `did: string` as their first argument.
+ */
+export const CACHE_TTL = {
+    PROFILE: 60 * 60 * 1000,
+    SITE_INFO: 120 * 60 * 1000,
+    LINKS: 60 * 60 * 1000,
+    MUSIC_STATUS: 10 * 60 * 1000,
+    KIBUN_STATUS: 15 * 60 * 1000,
+    TANGLED_REPOS: 60 * 60 * 1000,
+    BLOG_POSTS: 30 * 60 * 1000,
+    PUBLICATIONS: 60 * 60 * 1000,
+    INDIVIDUAL_POST: 60 * 60 * 1000,
+    IDENTITY: 24 * 60 * 60 * 1000
+};
+export class ATProtoCache {
+    cache = new Map();
+    getTTL(key) {
+        if (key.startsWith('profile:'))
+            return CACHE_TTL.PROFILE;
+        if (key.startsWith('siteinfo:'))
+            return CACHE_TTL.SITE_INFO;
+        if (key.startsWith('links:'))
+            return CACHE_TTL.LINKS;
+        if (key.startsWith('music-status:'))
+            return CACHE_TTL.MUSIC_STATUS;
+        if (key.startsWith('kibun-status:'))
+            return CACHE_TTL.KIBUN_STATUS;
+        if (key.startsWith('tangled:'))
+            return CACHE_TTL.TANGLED_REPOS;
+        if (key.startsWith('blog-posts:') || key.startsWith('blogposts:'))
+            return CACHE_TTL.BLOG_POSTS;
+        if (key.startsWith('publications:') || key.startsWith('standard-site:publications:'))
+            return CACHE_TTL.PUBLICATIONS;
+        if (key.startsWith('post:') || key.startsWith('blueskypost:'))
+            return CACHE_TTL.INDIVIDUAL_POST;
+        if (key.startsWith('identity:'))
+            return CACHE_TTL.IDENTITY;
+        return 30 * 60 * 1000;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        const ttl = this.getTTL(key);
+        if (Date.now() - entry.timestamp > ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.data;
+    }
+    set(key, data) {
+        this.cache.set(key, { data, timestamp: Date.now() });
+    }
+    delete(key) {
+        this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+export const cache = new ATProtoCache();

package/dist/documents.d.ts

@@ -0,0 +1,8 @@
+import type { StandardSitePublicationsData, StandardSiteDocument, StandardSiteDocumentsData, BlogPost } from './types.js';
+export declare function fetchPublications(did: string, fetchFn?: typeof fetch): Promise<StandardSitePublicationsData>;
+export declare function fetchDocuments(did: string, fetchFn?: typeof fetch): Promise<StandardSiteDocumentsData>;
+export declare function fetchRecentDocuments(did: string, limit?: number, fetchFn?: typeof fetch): Promise<StandardSiteDocument[]>;
+export declare function fetchBlogPosts(did: string, fetchFn?: typeof fetch): Promise<{
+    posts: BlogPost[];
+}>;
+//# sourceMappingURL=documents.d.ts.map

package/dist/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../src/documents.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEX,4BAA4B,EAC5B,oBAAoB,EACpB,yBAAyB,EAIzB,QAAQ,EACR,MAAM,YAAY,CAAC;AAiEpB,wBAAsB,iBAAiB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,4BAA4B,CAAC,CAgEvC;AAED,wBAAsB,cAAc,CACnC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,yBAAyB,CAAC,CA+EpC;AAED,wBAAsB,oBAAoB,CACzC,GAAG,EAAE,MAAM,EACX,KAAK,SAAI,EACT,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAGjC;AAED,wBAAsB,cAAc,CACnC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC;IAAE,KAAK,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC,CAiBhC"}

package/dist/documents.js

@@ -0,0 +1,174 @@
+import { cache } from './cache.js';
+import { withFallback, resolveIdentity } from './agents.js';
+import { buildPdsBlobUrl } from './media.js';
+async function getBlobUrl(did, blob, fetchFn) {
+    try {
+        const cid = blob.ref?.$link || blob.cid;
+        if (!cid)
+            return undefined;
+        const resolved = await resolveIdentity(did, fetchFn);
+        return buildPdsBlobUrl(resolved.pds, did, cid);
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveViewUrl(site, path, publicationUrl, rkey) {
+    const docPath = path || `/${rkey}`;
+    const normalizedPath = docPath.startsWith('/') ? docPath : `/${docPath}`;
+    if (site.startsWith('at://')) {
+        if (!publicationUrl)
+            return `${site}${normalizedPath}`;
+        const baseUrl = publicationUrl.startsWith('http') ? publicationUrl : `https://${publicationUrl}`;
+        return `${baseUrl.replace(/\/$/, '')}${normalizedPath}`;
+    }
+    else {
+        const baseUrl = site.startsWith('http') ? site : `https://${site}`;
+        return `${baseUrl.replace(/\/$/, '')}${normalizedPath}`;
+    }
+}
+export async function fetchPublications(did, fetchFn) {
+    const cacheKey = `standard-site:publications:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const publications = [];
+    try {
+        const publicationsRecords = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.listRecords({
+                repo: did,
+                collection: 'site.standard.publication',
+                limit: 100
+            });
+            return response.data.records;
+        }, true, fetchFn);
+        for (const pubRecord of publicationsRecords) {
+            const pubValue = pubRecord.value;
+            const rkey = pubRecord.uri.split('/').pop() || '';
+            let basicTheme;
+            if (pubValue.basicTheme) {
+                basicTheme = {
+                    background: pubValue.basicTheme.background,
+                    foreground: pubValue.basicTheme.foreground,
+                    accent: pubValue.basicTheme.accent,
+                    accentForeground: pubValue.basicTheme.accentForeground
+                };
+            }
+            const preferences = pubValue.preferences
+                ? {
+                    showInDiscover: pubValue.preferences.showInDiscover,
+                    showComments: pubValue.preferences.showComments,
+                    showMentions: pubValue.preferences.showMentions,
+                    showPrevNext: pubValue.preferences.showPrevNext,
+                    showRecommends: pubValue.preferences.showRecommends
+                }
+                : undefined;
+            publications.push({
+                name: pubValue.name,
+                rkey,
+                uri: pubRecord.uri,
+                url: pubValue.url,
+                description: pubValue.description,
+                icon: pubValue.icon ? await getBlobUrl(did, pubValue.icon, fetchFn) : undefined,
+                basicTheme,
+                preferences
+            });
+        }
+        const data = { publications };
+        cache.set(cacheKey, data);
+        return data;
+    }
+    catch {
+        return { publications: [] };
+    }
+}
+export async function fetchDocuments(did, fetchFn) {
+    const cacheKey = `standard-site:documents:${did}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const documents = [];
+    try {
+        const publicationsData = await fetchPublications(did, fetchFn);
+        const publicationsMap = new Map();
+        for (const pub of publicationsData.publications) {
+            publicationsMap.set(pub.uri, pub);
+        }
+        const documentsRecords = await withFallback(did, async (agent) => {
+            const response = await agent.com.atproto.repo.listRecords({
+                repo: did,
+                collection: 'site.standard.document',
+                limit: 100
+            });
+            return response.data.records;
+        }, true, fetchFn);
+        for (const docRecord of documentsRecords) {
+            const docValue = docRecord.value;
+            const rkey = docRecord.uri.split('/').pop() || '';
+            const site = docValue.site;
+            let publication;
+            let publicationRkey;
+            let pubUrl;
+            if (site.startsWith('at://')) {
+                publication = publicationsMap.get(site);
+                publicationRkey = site.split('/').pop();
+                pubUrl = publication?.url;
+            }
+            else {
+                pubUrl = site;
+            }
+            const url = resolveViewUrl(site, docValue.path, pubUrl, rkey);
+            const coverImage = docValue.coverImage
+                ? await getBlobUrl(did, docValue.coverImage, fetchFn)
+                : undefined;
+            documents.push({
+                title: docValue.title,
+                rkey,
+                uri: docRecord.uri,
+                url,
+                site,
+                path: docValue.path,
+                description: docValue.description,
+                coverImage,
+                content: docValue.content,
+                textContent: docValue.textContent,
+                bskyPostRef: docValue.bskyPostRef,
+                tags: docValue.tags,
+                publishedAt: docValue.publishedAt,
+                updatedAt: docValue.updatedAt,
+                publicationName: publication?.name,
+                publicationRkey,
+                preferences: docValue.preferences
+            });
+        }
+        documents.sort((a, b) => new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime());
+        const data = { documents };
+        cache.set(cacheKey, data);
+        return data;
+    }
+    catch {
+        return { documents: [] };
+    }
+}
+export async function fetchRecentDocuments(did, limit = 5, fetchFn) {
+    const { documents } = await fetchDocuments(did, fetchFn);
+    return documents.slice(0, limit);
+}
+export async function fetchBlogPosts(did, fetchFn) {
+    const { documents } = await fetchDocuments(did, fetchFn);
+    const posts = documents.map((doc) => ({
+        title: doc.title,
+        url: doc.url,
+        createdAt: doc.publishedAt,
+        platform: 'standard.site',
+        description: doc.description,
+        rkey: doc.rkey,
+        publicationName: doc.publicationName,
+        publicationRkey: doc.publicationRkey,
+        tags: doc.tags,
+        coverImage: doc.coverImage,
+        textContent: doc.textContent,
+        updatedAt: doc.updatedAt
+    }));
+    return { posts };
+}

package/dist/engagement.d.ts

@@ -0,0 +1,9 @@
+export type EngagementType = 'app.bsky.feed.like' | 'app.bsky.feed.repost';
+interface EngagementResponse {
+    dids: string[];
+    cursor?: string;
+}
+export declare function fetchEngagementFromConstellation(uri: string, type: EngagementType, cursor?: string): Promise<EngagementResponse>;
+export declare function fetchAllEngagement(uri: string, type: EngagementType): Promise<string[]>;
+export {};
+//# sourceMappingURL=engagement.d.ts.map

package/dist/engagement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engagement.d.ts","sourceRoot":"","sources":["../src/engagement.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,oBAAoB,GAAG,sBAAsB,CAAC;AAE3E,UAAU,kBAAkB;IAC3B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,gCAAgC,CACrD,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,kBAAkB,CAAC,CAyB7B;AAED,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAe7F"}

package/dist/engagement.js

@@ -0,0 +1,40 @@
+import { cache } from './cache.js';
+export async function fetchEngagementFromConstellation(uri, type, cursor) {
+    const cacheKey = `engagement:${type}:${uri}:${cursor || 'initial'}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const url = new URL('https://constellation.microcosm.blue/links/distinct-dids');
+    url.searchParams.append('target', uri);
+    url.searchParams.append('collection', type);
+    url.searchParams.append('path', '');
+    url.searchParams.append('limit', '100');
+    if (cursor)
+        url.searchParams.append('cursor', cursor);
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Constellation HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+    const result = {
+        dids: data.dids || [],
+        cursor: data.cursor
+    };
+    cache.set(cacheKey, result);
+    return result;
+}
+export async function fetchAllEngagement(uri, type) {
+    const allDids = new Set();
+    let cursor = undefined;
+    try {
+        do {
+            const response = await fetchEngagementFromConstellation(uri, type, cursor);
+            response.dids.forEach((did) => allDids.add(did));
+            cursor = response.cursor;
+        } while (cursor);
+    }
+    catch {
+        // return what we have
+    }
+    return Array.from(allDids);
+}

package/dist/fetch.d.ts

@@ -0,0 +1,8 @@
+import type { ProfileData, SiteInfoData, LinkData, MusicStatusData, KibunStatusData, TangledReposData } from './types.js';
+export declare function fetchProfile(did: string, fetchFn?: typeof fetch): Promise<ProfileData>;
+export declare function fetchSiteInfo(did: string, fetchFn?: typeof fetch): Promise<SiteInfoData | null>;
+export declare function fetchLinks(did: string, fetchFn?: typeof fetch): Promise<LinkData | null>;
+export declare function fetchMusicStatus(did: string, fetchFn?: typeof fetch): Promise<MusicStatusData | null>;
+export declare function fetchKibunStatus(did: string, fetchFn?: typeof fetch): Promise<KibunStatusData | null>;
+export declare function fetchTangledRepos(did: string, fetchFn?: typeof fetch): Promise<TangledReposData | null>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACX,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,eAAe,EACf,eAAe,EAEf,gBAAgB,EAChB,MAAM,YAAY,CAAC;AAEpB,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,CAgD5F;AAED,wBAAsB,aAAa,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAgC9B;AAED,wBAAsB,UAAU,CAC/B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CA2B1B;AAED,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAkIjC;AAED,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAmCjC;AAED,wBAAsB,iBAAiB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,KAAK,GACpB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CA2ClC"}