@ewanc26/atproto 0.1.0

package/src/musicbrainz.ts

@@ -0,0 +1,188 @@
+import { cache } from './cache.js';
+
+interface MusicBrainzRelease {
+	id: string;
+	score: number;
+	title: string;
+}
+
+interface MusicBrainzSearchResponse {
+	releases: MusicBrainzRelease[];
+}
+
+interface iTunesSearchResponse {
+	resultCount: number;
+	results: Array<{ artworkUrl100?: string }>;
+}
+
+export async function searchMusicBrainzRelease(
+	trackName: string,
+	artistName: string,
+	releaseName?: string
+): Promise<string | null> {
+	const cacheKey = `mb:release:${trackName}:${artistName}:${releaseName || 'none'}`;
+	const cached = cache.get<string | null>(cacheKey);
+	if (cached !== null) return cached;
+
+	try {
+		if (releaseName) {
+			const result = await searchByReleaseName(releaseName, artistName);
+			if (result) { cache.set(cacheKey, result); return result; }
+		}
+		const result = await searchByTrackName(trackName, artistName);
+		if (result) { cache.set(cacheKey, result); return result; }
+		cache.set(cacheKey, null);
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+async function searchByReleaseName(releaseName: string, artistName: string): Promise<string | null> {
+	try {
+		const query = `release:"${releaseName}" AND artist:"${artistName}"`;
+		const url = `https://musicbrainz.org/ws/2/release/?query=${encodeURIComponent(query)}&fmt=json&limit=5`;
+		const response = await fetch(url, {
+			headers: { 'User-Agent': 'ewancroft.uk/1.0.0 (https://ewancroft.uk)', Accept: 'application/json' }
+		});
+		if (!response.ok) return null;
+		const data: MusicBrainzSearchResponse = await response.json();
+		if (!data.releases?.length) return null;
+		const best = data.releases[0];
+		if (best.score < 80) return null;
+		return best.id;
+	} catch { return null; }
+}
+
+async function searchByTrackName(trackName: string, artistName: string): Promise<string | null> {
+	try {
+		const query = `recording:"${trackName}" AND artist:"${artistName}"`;
+		const url = `https://musicbrainz.org/ws/2/release/?query=${encodeURIComponent(query)}&fmt=json&limit=5`;
+		const response = await fetch(url, {
+			headers: { 'User-Agent': 'ewancroft.uk/1.0.0 (https://ewancroft.uk)', Accept: 'application/json' }
+		});
+		if (!response.ok) return null;
+		const data: MusicBrainzSearchResponse = await response.json();
+		if (!data.releases?.length) return null;
+		const best = data.releases[0];
+		if (best.score < 75) return null;
+		return best.id;
+	} catch { return null; }
+}
+
+export function buildCoverArtUrl(releaseMbId: string, size: 250 | 500 | 1200 = 500): string {
+	return `https://coverartarchive.org/release/${releaseMbId}/front-${size}`;
+}
+
+export async function searchiTunesArtwork(
+	trackName: string,
+	artistName: string,
+	releaseName?: string
+): Promise<string | null> {
+	const cacheKey = `itunes:artwork:${trackName}:${artistName}:${releaseName || 'none'}`;
+	const cached = cache.get<string | null>(cacheKey);
+	if (cached !== null) return cached;
+
+	try {
+		const searchTerm = releaseName ? `${releaseName} ${artistName}` : `${trackName} ${artistName}`;
+		const url = `https://itunes.apple.com/search?term=${encodeURIComponent(searchTerm)}&entity=album&limit=5`;
+		const response = await fetch(url);
+		if (!response.ok) { cache.set(cacheKey, null); return null; }
+		const data: iTunesSearchResponse = await response.json();
+		if (!data.results?.length) { cache.set(cacheKey, null); return null; }
+		let artworkUrl = data.results[0].artworkUrl100;
+		if (artworkUrl) {
+			artworkUrl = artworkUrl.replace('100x100', '600x600');
+			cache.set(cacheKey, artworkUrl);
+			return artworkUrl;
+		}
+		cache.set(cacheKey, null);
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+export async function searchDeezerArtwork(
+	trackName: string,
+	artistName: string,
+	releaseName?: string
+): Promise<string | null> {
+	// Deezer has CORS restrictions in browsers — skip silently
+	return null;
+}
+
+export async function searchLastFmArtwork(
+	trackName: string,
+	artistName: string,
+	releaseName?: string
+): Promise<string | null> {
+	if (!releaseName) return null;
+
+	const cacheKey = `lastfm:artwork:${trackName}:${artistName}:${releaseName}`;
+	const cached = cache.get<string | null>(cacheKey);
+	if (cached !== null) return cached;
+
+	try {
+		const url = `https://ws.audioscrobbler.com/2.0/?method=album.getinfo&api_key=8de8b91ab0c3f8d08a35c33bf0e0e803&artist=${encodeURIComponent(artistName)}&album=${encodeURIComponent(releaseName)}&format=json`;
+		const response = await fetch(url);
+		if (!response.ok) { cache.set(cacheKey, null); return null; }
+		const data: any = await response.json();
+		if (!data.album?.image) { cache.set(cacheKey, null); return null; }
+		const images = data.album.image;
+		const largeImage =
+			images.find((img: any) => img.size === 'extralarge') ||
+			images.find((img: any) => img.size === 'large') ||
+			images.find((img: any) => img.size === 'medium');
+		if (largeImage?.['#text']) {
+			cache.set(cacheKey, largeImage['#text']);
+			return largeImage['#text'];
+		}
+		cache.set(cacheKey, null);
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Cascading artwork search: Cover Art Archive → MusicBrainz+CAA → iTunes → Last.fm
+ */
+export async function findArtwork(
+	trackName: string,
+	artistName: string,
+	releaseName?: string,
+	releaseMbId?: string,
+	fetchFn?: typeof fetch
+): Promise<string | null> {
+	const _fetch = fetchFn || globalThis.fetch;
+
+	// 1. Try Cover Art Archive with known MBID
+	if (releaseMbId) {
+		const caaUrl = buildCoverArtUrl(releaseMbId, 500);
+		try {
+			const res = await _fetch(caaUrl, { method: 'HEAD' });
+			if (res.ok) return caaUrl;
+		} catch { /* continue */ }
+	}
+
+	// 2. Search MusicBrainz for MBID, then try CAA
+	const mbId = await searchMusicBrainzRelease(trackName, artistName, releaseName);
+	if (mbId) {
+		const caaUrl = buildCoverArtUrl(mbId, 500);
+		try {
+			const res = await _fetch(caaUrl, { method: 'HEAD' });
+			if (res.ok) return caaUrl;
+		} catch { /* continue */ }
+	}
+
+	// 3. Try iTunes
+	const iTunesUrl = await searchiTunesArtwork(trackName, artistName, releaseName);
+	if (iTunesUrl) return iTunesUrl;
+
+	// 4. Try Last.fm
+	const lastFmUrl = await searchLastFmArtwork(trackName, artistName, releaseName);
+	if (lastFmUrl) return lastFmUrl;
+
+	return null;
+}

package/src/pagination/fetchAllRecords.ts

@@ -0,0 +1,57 @@
+import { withFallback } from '../agents.js';
+
+export interface FetchRecordsConfig {
+	repo: string;
+	collection: string;
+	limit?: number;
+	fetchFn?: typeof fetch;
+}
+
+export interface AtProtoRecord<T = any> {
+	uri: string;
+	value: T;
+	cid?: string;
+}
+
+export async function fetchAllRecords<T = any>(
+	config: FetchRecordsConfig
+): Promise<AtProtoRecord<T>[]> {
+	const { repo, collection, limit = 100, fetchFn } = config;
+	const allRecords: AtProtoRecord<T>[] = [];
+	let cursor: string | undefined;
+
+	try {
+		do {
+			const records = await withFallback(
+				repo,
+				async (agent) => {
+					const response = await agent.com.atproto.repo.listRecords({
+						repo,
+						collection,
+						limit,
+						cursor
+					});
+					cursor = response.data.cursor;
+					return response.data.records;
+				},
+				true,
+				fetchFn
+			);
+			allRecords.push(...(records as AtProtoRecord<T>[]));
+		} while (cursor);
+	} catch (error) {
+		console.warn(`Failed to fetch records from ${collection}:`, error);
+		throw error;
+	}
+
+	return allRecords;
+}
+
+export async function fetchAllUserRecords<T = any>(
+	did: string,
+	collection: string,
+	fetchFn?: typeof fetch,
+	limit?: number
+): Promise<AtProtoRecord<T>[]> {
+	return fetchAllRecords<T>({ repo: did, collection, limit, fetchFn });
+}

package/src/pagination/index.ts

@@ -0,0 +1,2 @@
+export { fetchAllRecords, fetchAllUserRecords } from './fetchAllRecords.js';
+export type { FetchRecordsConfig, AtProtoRecord } from './fetchAllRecords.js';

package/src/posts.ts

@@ -0,0 +1,197 @@
+import { cache } from './cache.js';
+import { withFallback } from './agents.js';
+import type { BlueskyPost, PostAuthor, ExternalLink } from './types.js';
+
+export async function fetchLatestBlueskyPost(
+	did: string,
+	fetchFn?: typeof fetch
+): Promise<BlueskyPost | null> {
+	const cacheKey = `blueskypost:latest:${did}`;
+	const cached = cache.get<BlueskyPost>(cacheKey);
+	if (cached) return cached;
+
+	try {
+		const feedResponse = await withFallback(
+			did,
+			async (agent) => agent.getAuthorFeed({ actor: did, limit: 5 }),
+			false,
+			fetchFn
+		);
+
+		const feed = feedResponse.data.feed;
+		if (!feed.length) return null;
+
+		const latestFeedItem = feed[0];
+		const latestPostData = latestFeedItem.post;
+
+		const isRepost = latestFeedItem.reason?.$type === 'app.bsky.feed.defs#reasonRepost';
+		let repostAuthor: PostAuthor | undefined;
+		let repostCreatedAt: string | undefined;
+
+		if (isRepost && latestFeedItem.reason) {
+			const reason = latestFeedItem.reason as any;
+			repostAuthor = {
+				did: reason.by.did,
+				handle: reason.by.handle,
+				displayName: reason.by.displayName,
+				avatar: reason.by.avatar
+			};
+			repostCreatedAt = reason.indexedAt;
+		}
+
+		const post = await fetchPostFromUri(did, latestPostData.uri, 0, fetchFn);
+		if (!post) return null;
+
+		if (isRepost) {
+			post.isRepost = true;
+			post.repostAuthor = repostAuthor;
+			post.repostCreatedAt = repostCreatedAt;
+			post.originalPost = { ...post };
+		}
+
+		cache.set(cacheKey, post);
+		return post;
+	} catch {
+		return null;
+	}
+}
+
+export async function fetchPostFromUri(
+	did: string,
+	uri: string,
+	depth: number,
+	fetchFn?: typeof fetch
+): Promise<BlueskyPost | null> {
+	if (depth >= 3) return null;
+
+	try {
+		const threadResponse = await withFallback(
+			did,
+			async (agent) => agent.getPostThread({ uri, depth: 0 }),
+			false,
+			fetchFn
+		);
+
+		if (!threadResponse.data.thread || !('post' in threadResponse.data.thread)) return null;
+
+		const postData = threadResponse.data.thread.post;
+		const value = postData.record as any;
+		const embed = (postData as any).embed ?? null;
+
+		const author: PostAuthor = {
+			did: postData.author.did,
+			handle: postData.author.handle,
+			displayName: postData.author.displayName,
+			avatar: postData.author.avatar
+		};
+
+		let imageUrls: string[] | undefined;
+		let imageAlts: string[] | undefined;
+		let hasImages = false;
+		let hasVideo = false;
+		let videoUrl: string | undefined;
+		let videoThumbnail: string | undefined;
+		let quotedPost: BlueskyPost | undefined;
+		let quotedPostUri: string | undefined;
+		let externalLink: ExternalLink | undefined;
+
+		const facets = value.facets;
+
+		if (embed?.$type === 'app.bsky.embed.images#view' && Array.isArray(embed.images)) {
+			hasImages = true;
+			imageUrls = [];
+			imageAlts = [];
+			for (const img of embed.images) {
+				const imageUrl = img.fullsize || img.thumb;
+				if (imageUrl) { imageUrls.push(imageUrl); imageAlts.push(img.alt || ''); }
+			}
+		}
+
+		if (embed?.$type === 'app.bsky.embed.video#view') {
+			if (embed.playlist) { hasVideo = true; videoUrl = embed.playlist; }
+			if (embed.thumbnail) videoThumbnail = embed.thumbnail;
+		}
+
+		if (embed?.$type === 'app.bsky.embed.external#view' && embed.external) {
+			externalLink = {
+				uri: embed.external.uri,
+				title: embed.external.title,
+				description: embed.external.description,
+				thumb: embed.external.thumb
+			};
+		}
+
+		if (embed?.$type === 'app.bsky.embed.recordWithMedia#view') {
+			const media = embed.media;
+			if (media?.$type === 'app.bsky.embed.images#view' && Array.isArray(media.images)) {
+				hasImages = true;
+				imageUrls = [];
+				imageAlts = [];
+				for (const img of media.images) {
+					const imageUrl = img.fullsize || img.thumb;
+					if (imageUrl) { imageUrls.push(imageUrl); imageAlts.push(img.alt || ''); }
+				}
+			}
+			if (media?.$type === 'app.bsky.embed.video#view') {
+				if (media.playlist) { hasVideo = true; videoUrl = media.playlist; }
+				if (media.thumbnail) videoThumbnail = media.thumbnail;
+			}
+			if (media?.$type === 'app.bsky.embed.external#view' && media.external) {
+				externalLink = {
+					uri: media.external.uri,
+					title: media.external.title,
+					description: media.external.description,
+					thumb: media.external.thumb
+				};
+			}
+			const quotedRecord = embed.record?.record || embed.record;
+			if (quotedRecord?.uri) {
+				quotedPostUri = quotedRecord.uri as string;
+				quotedPost = (await fetchPostFromUri(did, quotedPostUri, depth + 1, fetchFn)) ?? undefined;
+			}
+		}
+
+		if (embed?.$type === 'app.bsky.embed.record#view') {
+			const quotedRecord = embed.record?.record || embed.record;
+			if (quotedRecord?.uri) {
+				quotedPostUri = quotedRecord.uri as string;
+				quotedPost = (await fetchPostFromUri(did, quotedPostUri, depth + 1, fetchFn)) ?? undefined;
+			}
+		}
+
+		let replyParent: BlueskyPost | undefined;
+		let replyRoot: BlueskyPost | undefined;
+		if (value.reply) {
+			if (value.reply.parent?.uri) {
+				replyParent = (await fetchPostFromUri(did, value.reply.parent.uri as string, depth + 1, fetchFn)) ?? undefined;
+			}
+			if (value.reply.root?.uri && value.reply.root.uri !== value.reply.parent?.uri) {
+				replyRoot = (await fetchPostFromUri(did, value.reply.root.uri as string, depth + 1, fetchFn)) ?? undefined;
+			}
+		}
+
+		return {
+			text: value.text,
+			createdAt: value.createdAt,
+			uri: postData.uri,
+			author,
+			likeCount: postData.likeCount || 0,
+			repostCount: postData.repostCount || 0,
+			replyCount: postData.replyCount,
+			hasImages,
+			imageUrls,
+			imageAlts,
+			hasVideo,
+			videoUrl,
+			videoThumbnail,
+			quotedPostUri,
+			quotedPost,
+			facets,
+			externalLink,
+			replyParent,
+			replyRoot
+		};
+	} catch {
+		return null;
+	}
+}

package/src/types.ts

@@ -0,0 +1,272 @@
+/**
+ * Type definitions for AT Protocol services
+ * Identical to src/lib/services/atproto/types.ts — no SvelteKit dependencies.
+ */
+
+export interface ProfileData {
+	did: string;
+	handle: string;
+	displayName?: string;
+	description?: string;
+	avatar?: string;
+	banner?: string;
+	followersCount?: number;
+	followsCount?: number;
+	postsCount?: number;
+	pronouns?: string;
+}
+
+export interface StatusData {
+	text: string;
+	createdAt: string;
+}
+
+export interface Technology {
+	name: string;
+	url?: string;
+	description?: string;
+}
+
+export interface License {
+	name: string;
+	url?: string;
+}
+
+export interface BasedOnItem {
+	section?: string;
+	name?: string;
+	url?: string;
+	description?: string;
+	type?: string;
+}
+
+export interface RelatedService {
+	section?: string;
+	name?: string;
+	url?: string;
+	description?: string;
+	relationship?: string;
+}
+
+export interface Repository {
+	platform?: string;
+	url: string;
+	type?: string;
+	description?: string;
+}
+
+export interface Credit {
+	section?: string;
+	name?: string;
+	type: string;
+	url?: string;
+	author?: string;
+	license?: License;
+	description?: string;
+}
+
+export interface SectionLicense {
+	section?: string;
+	name?: string;
+	url?: string;
+}
+
+export interface SiteInfoData {
+	technologyStack?: Technology[];
+	privacyStatement?: string;
+	openSourceInfo?: {
+		description?: string;
+		license?: License;
+		basedOn?: BasedOnItem[];
+		relatedServices?: RelatedService[];
+		repositories?: Repository[];
+	};
+	credits?: Credit[];
+	additionalInfo?: {
+		websiteBirthYear?: number;
+		purpose?: string;
+		sectionLicense?: SectionLicense[];
+	};
+}
+
+export interface LinkCard {
+	url: string;
+	text: string;
+	emoji: string;
+}
+
+export interface LinkData {
+	cards: LinkCard[];
+}
+
+export interface BlogPost {
+	title: string;
+	url: string;
+	createdAt: string;
+	platform: 'standard.site';
+	description?: string;
+	rkey: string;
+	publicationName?: string;
+	publicationRkey?: string;
+	tags?: string[];
+	coverImage?: string;
+	textContent?: string;
+	updatedAt?: string;
+}
+
+export interface BlogPostsData {
+	posts: BlogPost[];
+}
+
+export interface Facet {
+	index: { byteStart: number; byteEnd: number };
+	features: Array<{ $type: string; uri?: string; did?: string; tag?: string }>;
+}
+
+export interface ExternalLink {
+	uri: string;
+	title: string;
+	description?: string;
+	thumb?: string;
+}
+
+export interface PostAuthor {
+	did: string;
+	handle: string;
+	displayName?: string;
+	avatar?: string;
+	pronouns?: string;
+}
+
+export interface BlueskyPost {
+	text: string;
+	createdAt: string;
+	uri: string;
+	author: PostAuthor;
+	likeCount?: number;
+	repostCount?: number;
+	replyCount?: number;
+	hasImages: boolean;
+	imageUrls?: string[];
+	imageAlts?: string[];
+	hasVideo?: boolean;
+	videoUrl?: string;
+	videoThumbnail?: string;
+	quotedPostUri?: string;
+	quotedPost?: BlueskyPost;
+	facets?: Facet[];
+	externalLink?: ExternalLink;
+	replyParent?: BlueskyPost;
+	replyRoot?: BlueskyPost;
+	isRepost?: boolean;
+	repostAuthor?: PostAuthor;
+	repostCreatedAt?: string;
+	originalPost?: BlueskyPost;
+}
+
+export interface ResolvedIdentity {
+	did: string;
+	pds: string;
+}
+
+export interface CacheEntry<T> {
+	data: T;
+	timestamp: number;
+}
+
+export interface MusicArtist {
+	artistName: string;
+	artistMbId?: string;
+}
+
+export interface MusicStatusData {
+	trackName: string;
+	artists: MusicArtist[];
+	releaseName?: string;
+	playedTime: string;
+	originUrl?: string;
+	recordingMbId?: string;
+	releaseMbId?: string;
+	isrc?: string;
+	duration?: number;
+	musicServiceBaseDomain?: string;
+	submissionClientAgent?: string;
+	$type: 'fm.teal.alpha.actor.status' | 'fm.teal.alpha.feed.play';
+	expiry?: string;
+	artwork?: { ref?: { $link: string }; mimeType?: string; size?: number };
+	artworkUrl?: string;
+}
+
+export interface KibunStatusData {
+	text: string;
+	emoji: string;
+	createdAt: string;
+	$type: 'social.kibun.status';
+}
+
+export interface TangledRepo {
+	uri: string;
+	name: string;
+	description?: string;
+	knot: string;
+	createdAt: string;
+	labels?: string[];
+	source?: string;
+	spindle?: string;
+}
+
+export interface TangledReposData {
+	repos: TangledRepo[];
+}
+
+export interface StandardSiteThemeColor {
+	r: number;
+	g: number;
+	b: number;
+	a?: number;
+}
+
+export interface StandardSiteBasicTheme {
+	background: StandardSiteThemeColor;
+	foreground: StandardSiteThemeColor;
+	accent: StandardSiteThemeColor;
+	accentForeground: StandardSiteThemeColor;
+}
+
+export interface StandardSitePublication {
+	name: string;
+	rkey: string;
+	uri: string;
+	url: string;
+	description?: string;
+	icon?: string;
+	basicTheme?: StandardSiteBasicTheme;
+	preferences?: { showInDiscover?: boolean };
+}
+
+export interface StandardSitePublicationsData {
+	publications: StandardSitePublication[];
+}
+
+export interface StandardSiteDocument {
+	title: string;
+	rkey: string;
+	uri: string;
+	url: string;
+	site: string;
+	path?: string;
+	description?: string;
+	coverImage?: string;
+	content?: any;
+	textContent?: string;
+	bskyPostRef?: { uri: string; cid: string };
+	tags?: string[];
+	publishedAt: string;
+	updatedAt?: string;
+	publicationName?: string;
+	publicationRkey?: string;
+}
+
+export interface StandardSiteDocumentsData {
+	documents: StandardSiteDocument[];
+}