birdclaw 0.1.1 → 0.2.1

package/src/lib/profile-replies.ts

@@ -16,7 +16,7 @@ export async function inspectProfileReplies(
 ): Promise<ProfileRepliesResponse> {
 	const resolved = await resolveProfile(query);
 	if (!resolved.externalUserId) {
-		throw new Error(`Profile has no external X user id: ${query}`);
+		throw new Error(`Profile has no external Twitter user id: ${query}`);
 	}
 
 	const timeline = await listUserTweets(resolved.externalUserId, {

package/src/lib/queries.ts

@@ -199,6 +199,7 @@ export async function getQueryEnvelope(): Promise<QueryEnvelope> {
 			id: row.id,
 			name: row.name,
 			handle: row.handle,
+			externalUserId: row.external_user_id,
 			transport: row.transport,
 			isDefault: row.is_default,
 			createdAt: row.created_at,
@@ -217,6 +218,8 @@ export function listTimelineItems({
 	until,
 	includeReplies = true,
 	qualityFilter = "all",
+	likedOnly = false,
+	bookmarkedOnly = false,
 	limit = 18,
 }: TimelineQuery): TimelineItem[] {
 	const db = getNativeDb();
@@ -225,6 +228,11 @@ export function listTimelineItems({
 	let join = "";
 	let where = "where t.kind = ?";
 
+	if (likedOnly || bookmarkedOnly) {
+		params.length = 0;
+		where = "where 1 = 1";
+	}
+
 	if (account && account !== "all") {
 		where += " and a.id = ?";
 		params.push(account);
@@ -256,6 +264,14 @@ export function listTimelineItems({
 		params.push(search.trim());
 	}
 
+	if (likedOnly) {
+		where += " and t.liked = 1";
+	}
+
+	if (bookmarkedOnly) {
+		where += " and t.bookmarked = 1";
+	}
+
 	params.push(limit);
 
 	const rows = db
@@ -630,11 +646,14 @@ export function queryResource(
 		};
 	}
 
+	const { resource: _filterResource, ...timelineFilters } =
+		filters as TimelineQuery;
+
 	return {
 		resource,
 		items: listTimelineItems({
 			resource,
-			...(filters as TimelineQuery),
+			...timelineFilters,
 		}),
 	};
 }

package/src/lib/seed.ts

@@ -34,8 +34,8 @@ export function seedDemoData(db: Database.Database) {
 	}
 
 	const insertAccount = db.prepare(`
-    insert into accounts (id, name, handle, transport, is_default, created_at)
-    values (@id, @name, @handle, @transport, @isDefault, @createdAt)
+    insert into accounts (id, name, handle, external_user_id, transport, is_default, created_at)
+    values (@id, @name, @handle, @externalUserId, @transport, @isDefault, @createdAt)
   `);
 
 	const insertProfile = db.prepare(`
@@ -81,6 +81,7 @@ export function seedDemoData(db: Database.Database) {
 			id: "acct_primary",
 			name: "Peter",
 			handle: "@steipete",
+			externalUserId: "25401953",
 			transport: "xurl",
 			isDefault: 1,
 			createdAt: now.toISOString(),
@@ -89,6 +90,7 @@ export function seedDemoData(db: Database.Database) {
 			id: "acct_studio",
 			name: "Studio",
 			handle: "@birdclaw_lab",
+			externalUserId: null,
 			transport: "xurl",
 			isDefault: 0,
 			createdAt: now.toISOString(),

package/src/lib/theme-transition.ts

@@ -7,12 +7,6 @@ export interface ThemeTransitionContext {
 	pointerClientY?: number;
 }
 
-interface DocumentWithViewTransition extends Document {
-	startViewTransition?: (callback: () => void) => {
-		finished: Promise<void>;
-	};
-}
-
 const clamp01 = (value: number) => {
 	if (Number.isNaN(value)) return 0.5;
 	if (value <= 0) return 0;
@@ -58,10 +52,12 @@ export function startThemeTransition({
 	}
 
 	const root = document.documentElement;
-	const documentWithTransition = document as DocumentWithViewTransition;
+	const startViewTransition =
+		typeof document.startViewTransition === "function"
+			? document.startViewTransition.bind(document)
+			: undefined;
 	const canUseViewTransition =
-		Boolean(documentWithTransition.startViewTransition) &&
-		!hasReducedMotionPreference();
+		Boolean(startViewTransition) && !hasReducedMotionPreference();
 
 	const applyTheme = () => {
 		flushSync(() => {
@@ -98,7 +94,7 @@ export function startThemeTransition({
 	root.classList.add("theme-transition");
 
 	try {
-		const transition = documentWithTransition.startViewTransition?.(() => {
+		const transition = startViewTransition?.(() => {
 			applyTheme();
 		});
 

package/src/lib/theme.tsx

@@ -111,7 +111,15 @@ export function ThemeProvider({ children }: { children: ReactNode }) {
 			return;
 		}
 
-		const media = window.matchMedia("(prefers-color-scheme: dark)");
+		const media = window.matchMedia(
+			"(prefers-color-scheme: dark)",
+		) as unknown as {
+			matches: boolean;
+			addEventListener?: (type: "change", listener: () => void) => void;
+			removeEventListener?: (type: "change", listener: () => void) => void;
+			addListener?: (listener: () => void) => void;
+			removeListener?: (listener: () => void) => void;
+		};
 		const onChange = () => {
 			const nextResolvedTheme = media.matches ? "dark" : "light";
 			setResolvedTheme(nextResolvedTheme);
@@ -119,16 +127,16 @@ export function ThemeProvider({ children }: { children: ReactNode }) {
 			document.documentElement.style.colorScheme = nextResolvedTheme;
 		};
 
-		if ("addEventListener" in media) {
+		if (typeof media.addEventListener === "function") {
 			media.addEventListener("change", onChange);
 		} else {
-			media.addListener(onChange);
+			media.addListener?.(onChange);
 		}
 		return () => {
-			if ("removeEventListener" in media) {
+			if (typeof media.removeEventListener === "function") {
 				media.removeEventListener("change", onChange);
 			} else {
-				media.removeListener(onChange);
+				media.removeListener?.(onChange);
 			}
 		};
 	}, [isReady, theme]);

package/src/lib/timeline-collections-live.ts

@@ -0,0 +1,406 @@
+import type Database from "better-sqlite3";
+import { listBookmarkedTweetsViaBird, listLikedTweetsViaBird } from "./bird";
+import { getNativeDb } from "./db";
+import { readSyncCache, writeSyncCache } from "./sync-cache";
+import type {
+	XurlMentionData,
+	XurlMentionsResponse,
+	XurlMentionUser,
+} from "./types";
+import { ensureStubProfileForXUser, upsertProfileFromXUser } from "./x-profile";
+import {
+	listBookmarkedTweetsViaXurl,
+	listLikedTweetsViaXurl,
+	lookupUsersByHandles,
+} from "./xurl";
+
+export type TimelineCollectionKind = "likes" | "bookmarks";
+export type TimelineCollectionMode = "auto" | "xurl" | "bird";
+
+const DEFAULT_COLLECTION_CACHE_TTL_MS = 2 * 60_000;
+const MIN_XURL_LIMIT = 5;
+const MAX_XURL_LIMIT = 100;
+
+function parseCacheTtlMs(value?: number) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+		return DEFAULT_COLLECTION_CACHE_TTL_MS;
+	}
+	return Math.floor(value);
+}
+
+function parseMaxPages(value?: number) {
+	if (value === undefined) {
+		return null;
+	}
+	if (!Number.isFinite(value) || value < 1) {
+		throw new Error("--max-pages must be at least 1");
+	}
+	return Math.floor(value);
+}
+
+function assertLimit(limit: number) {
+	if (!Number.isFinite(limit) || limit < 1) {
+		throw new Error("--limit must be at least 1");
+	}
+}
+
+function assertXurlLimit(limit: number) {
+	if (limit < MIN_XURL_LIMIT || limit > MAX_XURL_LIMIT) {
+		throw new Error("xurl mode requires --limit between 5 and 100");
+	}
+}
+
+function resolveAccount(db: Database.Database, accountId?: string) {
+	const row = accountId
+		? (db
+				.prepare(
+					"select id, handle, external_user_id from accounts where id = ?",
+				)
+				.get(accountId) as
+				| { id: string; handle: string; external_user_id: string | null }
+				| undefined)
+		: (db
+				.prepare(
+					`
+          select id, handle, external_user_id
+          from accounts
+          order by is_default desc, created_at asc
+          limit 1
+          `,
+				)
+				.get() as
+				| { id: string; handle: string; external_user_id: string | null }
+				| undefined);
+
+	if (!row) {
+		throw new Error(`Unknown account: ${accountId ?? "default"}`);
+	}
+
+	return {
+		accountId: row.id,
+		username: row.handle.replace(/^@/, ""),
+		externalUserId:
+			typeof row.external_user_id === "string" &&
+			row.external_user_id.length > 0
+				? row.external_user_id
+				: undefined,
+	};
+}
+
+function getMediaCount(tweet: XurlMentionData) {
+	const urls = Array.isArray(tweet.entities?.urls) ? tweet.entities.urls : [];
+	return urls.filter(
+		(url) =>
+			url &&
+			typeof url === "object" &&
+			typeof (url as Record<string, unknown>).media_key === "string",
+	).length;
+}
+
+function replaceTweetFts(db: Database.Database, tweetId: string, text: string) {
+	db.prepare("delete from tweets_fts where tweet_id = ?").run(tweetId);
+	db.prepare("insert into tweets_fts (tweet_id, text) values (?, ?)").run(
+		tweetId,
+		text,
+	);
+}
+
+function mergePayloads(pages: XurlMentionsResponse[]): XurlMentionsResponse {
+	const tweets: XurlMentionData[] = [];
+	const seenTweetIds = new Set<string>();
+	const users: XurlMentionUser[] = [];
+	const seenUserIds = new Set<string>();
+
+	for (const page of pages) {
+		for (const tweet of page.data) {
+			if (seenTweetIds.has(tweet.id)) {
+				continue;
+			}
+			seenTweetIds.add(tweet.id);
+			tweets.push(tweet);
+		}
+
+		for (const user of page.includes?.users ?? []) {
+			if (seenUserIds.has(user.id)) {
+				continue;
+			}
+			seenUserIds.add(user.id);
+			users.push(user);
+		}
+	}
+
+	const lastPage = pages.at(-1);
+	return {
+		data: tweets,
+		includes: users.length > 0 ? { users } : undefined,
+		meta: {
+			result_count: tweets.length,
+			page_count: pages.length,
+			next_token: lastPage?.meta?.next_token ?? null,
+			...(tweets[0] ? { newest_id: tweets[0].id } : {}),
+			...(tweets.at(-1) ? { oldest_id: tweets.at(-1)?.id } : {}),
+		},
+	};
+}
+
+function mergeTimelineCollectionIntoLocalStore(
+	db: Database.Database,
+	accountId: string,
+	kind: TimelineCollectionKind,
+	payload: XurlMentionsResponse,
+	source: "xurl" | "bird",
+) {
+	const usersById = new Map(
+		(payload.includes?.users ?? []).map((user) => [user.id, user]),
+	);
+	const tweetKind = kind === "likes" ? "like" : "bookmark";
+	const liked = kind === "likes" ? 1 : 0;
+	const bookmarked = kind === "bookmarks" ? 1 : 0;
+	const upsertTweet = db.prepare(
+		`
+    insert into tweets (
+      id, account_id, author_profile_id, kind, text, created_at,
+      is_replied, reply_to_id, like_count, media_count, bookmarked, liked,
+      entities_json, media_json, quoted_tweet_id
+    ) values (?, ?, ?, ?, ?, ?, 0, null, ?, ?, ?, ?, ?, '[]', null)
+    on conflict(id) do update set
+      account_id = excluded.account_id,
+      author_profile_id = excluded.author_profile_id,
+      kind = case
+        when tweets.kind in ('home', 'mention') then tweets.kind
+        else excluded.kind
+      end,
+      text = excluded.text,
+      created_at = excluded.created_at,
+      like_count = excluded.like_count,
+      media_count = excluded.media_count,
+      entities_json = excluded.entities_json,
+      media_json = excluded.media_json,
+      bookmarked = max(tweets.bookmarked, excluded.bookmarked),
+      liked = max(tweets.liked, excluded.liked)
+    `,
+	);
+	const upsertCollection = db.prepare(`
+    insert into tweet_collections (
+      account_id, tweet_id, kind, collected_at, source, raw_json, updated_at
+    ) values (?, ?, ?, null, ?, ?, ?)
+    on conflict(account_id, tweet_id, kind) do update set
+      source = excluded.source,
+      raw_json = excluded.raw_json,
+      updated_at = excluded.updated_at
+  `);
+
+	db.transaction(() => {
+		const updatedAt = new Date().toISOString();
+		for (const tweet of payload.data) {
+			const author =
+				usersById.get(tweet.author_id) ??
+				({
+					id: tweet.author_id,
+					username: `user_${tweet.author_id}`,
+					name: `user_${tweet.author_id}`,
+				} as const);
+			const profile = usersById.has(tweet.author_id)
+				? upsertProfileFromXUser(db, author)
+				: ensureStubProfileForXUser(db, tweet.author_id);
+			upsertTweet.run(
+				tweet.id,
+				accountId,
+				profile.profile.id,
+				tweetKind,
+				tweet.text,
+				tweet.created_at,
+				Number(tweet.public_metrics?.like_count ?? 0),
+				getMediaCount(tweet),
+				bookmarked,
+				liked,
+				JSON.stringify(tweet.entities ?? {}),
+			);
+			upsertCollection.run(
+				accountId,
+				tweet.id,
+				kind,
+				source,
+				JSON.stringify(tweet),
+				updatedAt,
+			);
+			replaceTweetFts(db, tweet.id, tweet.text);
+		}
+	})();
+}
+
+async function fetchXurlCollection({
+	kind,
+	username,
+	userId,
+	limit,
+	all,
+	maxPages,
+}: {
+	kind: TimelineCollectionKind;
+	username: string;
+	userId?: string;
+	limit: number;
+	all: boolean;
+	maxPages: number | null;
+}) {
+	let resolvedUserId = userId;
+	if (!resolvedUserId) {
+		const [accountUser] = await lookupUsersByHandles([username]);
+		if (!accountUser?.id) {
+			throw new Error(`Could not resolve Twitter user id for @${username}`);
+		}
+		resolvedUserId = String(accountUser.id);
+	}
+
+	const pages: XurlMentionsResponse[] = [];
+	let nextToken: string | undefined;
+	let pageCount = 0;
+	do {
+		const payload =
+			kind === "likes"
+				? await listLikedTweetsViaXurl({
+						maxResults: limit,
+						username,
+						userId: resolvedUserId,
+						paginationToken: nextToken,
+					})
+				: await listBookmarkedTweetsViaXurl({
+						maxResults: limit,
+						username,
+						userId: resolvedUserId,
+						paginationToken: nextToken,
+					});
+		pages.push(payload);
+		nextToken =
+			typeof payload.meta?.next_token === "string"
+				? payload.meta.next_token
+				: undefined;
+		pageCount += 1;
+	} while (all && nextToken && (maxPages === null || pageCount < maxPages));
+
+	return mergePayloads(pages);
+}
+
+async function fetchBirdCollection({
+	kind,
+	limit,
+	all,
+	maxPages,
+}: {
+	kind: TimelineCollectionKind;
+	limit: number;
+	all: boolean;
+	maxPages: number | null;
+}) {
+	return kind === "likes"
+		? listLikedTweetsViaBird({
+				maxResults: limit,
+				all,
+				maxPages: maxPages ?? undefined,
+			})
+		: listBookmarkedTweetsViaBird({
+				maxResults: limit,
+				all,
+				maxPages: maxPages ?? undefined,
+			});
+}
+
+export async function syncTimelineCollection({
+	kind,
+	account,
+	mode = "auto",
+	limit = 20,
+	all = false,
+	maxPages,
+	refresh = false,
+	cacheTtlMs,
+}: {
+	kind: TimelineCollectionKind;
+	account?: string;
+	mode?: TimelineCollectionMode;
+	limit?: number;
+	all?: boolean;
+	maxPages?: number;
+	refresh?: boolean;
+	cacheTtlMs?: number;
+}) {
+	assertLimit(limit);
+	const parsedMaxPages = parseMaxPages(maxPages);
+	if (mode === "xurl" || mode === "auto") {
+		assertXurlLimit(limit);
+	}
+
+	const db = getNativeDb();
+	const resolvedAccount = resolveAccount(db, account);
+	const cacheKey = `${kind}:${mode}:${resolvedAccount.accountId}:${String(limit)}:${all ? "all" : "single"}:${parsedMaxPages === null ? "all-pages" : String(parsedMaxPages)}`;
+	const ttlMs = parseCacheTtlMs(cacheTtlMs);
+	const cached = readSyncCache<XurlMentionsResponse>(cacheKey, db);
+	const cacheAgeMs = cached
+		? Date.now() - new Date(cached.updatedAt).getTime()
+		: Number.POSITIVE_INFINITY;
+
+	if (!refresh && cached && cacheAgeMs <= ttlMs) {
+		return {
+			ok: true,
+			source: "cache",
+			kind,
+			accountId: resolvedAccount.accountId,
+			count: cached.value.data.length,
+			payload: cached.value,
+		};
+	}
+
+	let source: "xurl" | "bird";
+	let payload: XurlMentionsResponse;
+	if (mode === "bird") {
+		payload = await fetchBirdCollection({
+			kind,
+			limit,
+			all,
+			maxPages: parsedMaxPages,
+		});
+		source = "bird";
+	} else {
+		try {
+			payload = await fetchXurlCollection({
+				kind,
+				username: resolvedAccount.username,
+				userId: resolvedAccount.externalUserId,
+				limit,
+				all,
+				maxPages: parsedMaxPages,
+			});
+			source = "xurl";
+		} catch (error) {
+			if (mode === "xurl") {
+				throw error;
+			}
+			payload = await fetchBirdCollection({
+				kind,
+				limit,
+				all,
+				maxPages: parsedMaxPages,
+			});
+			source = "bird";
+		}
+	}
+
+	mergeTimelineCollectionIntoLocalStore(
+		db,
+		resolvedAccount.accountId,
+		kind,
+		payload,
+		source,
+	);
+	writeSyncCache(cacheKey, payload, db);
+
+	return {
+		ok: true,
+		source,
+		kind,
+		accountId: resolvedAccount.accountId,
+		count: payload.data.length,
+		payload,
+	};
+}

package/src/lib/types.ts

@@ -8,6 +8,7 @@ export interface AccountRecord {
 	id: string;
 	name: string;
 	handle: string;
+	externalUserId?: string | null;
 	transport: string;
 	isDefault: number;
 	createdAt: string;
@@ -95,7 +96,7 @@ export interface TimelineItem {
 	id: string;
 	accountId: string;
 	accountHandle: string;
-	kind: Exclude<ResourceKind, "dms">;
+	kind: "home" | "mention" | "like" | "bookmark";
 	text: string;
 	createdAt: string;
 	isReplied: boolean;
@@ -144,6 +145,8 @@ export interface TimelineQuery {
 	until?: string;
 	includeReplies?: boolean;
 	qualityFilter?: TimelineQualityFilter;
+	likedOnly?: boolean;
+	bookmarkedOnly?: boolean;
 	limit?: number;
 }