birdclaw 0.5.1 → 0.6.0

package/src/lib/whois.ts

@@ -1,13 +1,16 @@
+import { Effect } from "effect";
 import { getNativeDb } from "./db";
+import { runEffectPromise } from "./effect-runtime";
 import {
 	ensureIdentitySearchIndexForDmProfiles,
 	syncIdentitySearchIndexForProfileIds,
 } from "./identity-search-index";
 import { fetchProfileBioEntities } from "./profile-bio-entities";
 import { fetchProfileSnapshots } from "./profile-history";
-import { expandUrlsFromTexts } from "./url-expansion";
-import { resolveProfilesForIds } from "./profile-resolver";
+import { resolveProfilesForIdsEffect } from "./profile-resolver";
+import type { ProfileResolveResult } from "./profile-resolver";
 import { listDmConversations, listTimelineItems } from "./queries";
+import { expandUrlsFromTextsEffect } from "./url-expansion";
 import type {
 	DmConversationItem,
 	ProfileAffiliation,
@@ -61,7 +64,7 @@ export interface WhoisResult {
 	candidates: WhoisCandidate[];
 	relatedTweets: TimelineItem[];
 	urlExpansions: UrlExpansionItem[];
-	profileResolution?: Awaited<ReturnType<typeof resolveProfilesForIds>>;
+	profileResolution?: ProfileResolveResult[];
 }
 
 export interface WhoisEvidenceSignal {
@@ -84,6 +87,13 @@ export interface WhoisEvidenceSignal {
 	source: "profile" | "affiliation" | "bio_entity" | "history" | "dm" | "url";
 }
 
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: (cause) => cause,
+	});
+}
+
 interface WhoisQueryIntent {
 	raw: string;
 	normalized: string;
@@ -771,160 +781,169 @@ function loadWhoisConversations(
 	return [...merged.values()];
 }
 
-export async function runWhois(
+export function runWhoisEffect(
 	query: string,
 	options: WhoisOptions = {},
-): Promise<WhoisResult> {
-	const includeDms = options.dms ?? true;
-	const includeTweets = options.tweets ?? false;
-	const limit = options.limit ?? 10;
-	const context = options.context ?? 4;
-	let conversations = loadWhoisConversations(
-		query,
-		options,
-		includeDms,
-		context,
-		limit,
-	);
-	let profileResolution: WhoisResult["profileResolution"];
-
-	if (options.resolveProfiles ?? true) {
-		profileResolution = await resolveProfilesForIds(
-			conversations.map((item) => item.participant.id),
-			{
-				refresh: options.refreshProfileCache,
-				xurlFallback: options.xurlFallback ?? true,
-			},
-		);
-		conversations = loadWhoisConversations(
-			query,
-			options,
-			includeDms,
-			context,
-			limit,
+): Effect.Effect<WhoisResult, unknown> {
+	return Effect.gen(function* () {
+		const includeDms = options.dms ?? true;
+		const includeTweets = options.tweets ?? false;
+		const limit = options.limit ?? 10;
+		const context = options.context ?? 4;
+		let conversations = yield* trySync(() =>
+			loadWhoisConversations(query, options, includeDms, context, limit),
 		);
-	}
-	syncIdentitySearchIndexForProfileIds(
-		getNativeDb(),
-		conversations.map((item) => item.participant.id),
-	);
+		let profileResolution: WhoisResult["profileResolution"];
 
-	const relatedTweets = includeTweets
-		? [
-				...listTimelineItems({
-					resource: "home",
-					account: options.account,
-					search: query,
-					limit,
-				}),
-				...listTimelineItems({
-					resource: "mentions",
-					account: options.account,
-					search: query,
-					limit,
-				}),
-			]
-		: [];
+		if (options.resolveProfiles ?? true) {
+			profileResolution = yield* resolveProfilesForIdsEffect(
+				conversations.map((item) => item.participant.id),
+				{
+					refresh: options.refreshProfileCache,
+					xurlFallback: options.xurlFallback ?? true,
+				},
+			);
+			conversations = yield* trySync(() =>
+				loadWhoisConversations(query, options, includeDms, context, limit),
+			);
+		}
+		yield* trySync(() =>
+			syncIdentitySearchIndexForProfileIds(
+				getNativeDb(),
+				conversations.map((item) => item.participant.id),
+			),
+		);
 
-	const texts = [
-		...conversations.flatMap(getMessageTexts),
-		...conversations.flatMap((conversation) =>
-			[
-				conversation.participant.bio,
-				conversation.participant.url ?? "",
-				...getProfileBioUrls(conversation.participant),
-			].filter((text) => text.includes("https://t.co/")),
-		),
-		...relatedTweets.map((tweet) => tweet.text),
-	];
-	const urlExpansions =
-		(options.expandUrls ?? true)
-			? await expandUrlsFromTexts(texts, { refresh: options.refreshUrlCache })
+		const relatedTweets = includeTweets
+			? yield* trySync(() => [
+					...listTimelineItems({
+						resource: "home",
+						account: options.account,
+						search: query,
+						limit,
+					}),
+					...listTimelineItems({
+						resource: "mentions",
+						account: options.account,
+						search: query,
+						limit,
+					}),
+				])
 			: [];
-	for (const conversation of conversations) {
-		attachExpansionsToMatches(conversation, urlExpansions);
-	}
 
-	const profileIds = conversations.map(
-		(conversation) => conversation.participant.id,
-	);
-	const bioEntitiesByProfile = fetchProfileBioEntities(
-		getNativeDb(),
-		profileIds,
-	);
-	const snapshotsByProfile = fetchProfileSnapshots(getNativeDb(), profileIds);
-	const candidates = conversations
-		.map((conversation): WhoisCandidate | null => {
-			const conversationExpansions = urlExpansions.filter((item) =>
-				getMessageTexts(conversation).some((text) => text.includes(item.url)),
-			);
-			const profileId = conversation.participant.id;
-			const score = scoreCandidate(
-				query,
-				conversation,
-				conversationExpansions,
-				bioEntitiesByProfile.get(profileId) ?? [],
-				snapshotsByProfile.get(profileId) ?? [],
-			);
-			if (
-				!hasCurrentAffiliationMatch(
-					conversation.participant,
-					options.currentAffiliation,
-				)
-			) {
-				return null;
-			}
-			if (
-				!hasAffiliationEvidenceMatch(
-					conversation.participant,
-					score.profileEvidence,
-					options.affiliation,
-				)
-			) {
-				return null;
-			}
-			if (
-				options.excludeDomainOnly &&
-				!hasNonDomainEvidence(score.profileEvidence)
-			) {
-				return null;
-			}
-			return {
-				conversation,
-				confidence: score.confidence,
-				category: score.category,
-				reasons: score.reasons,
-				profileEvidence: score.profileEvidence,
-				evidence: (conversation.matches ?? []).map((match) => ({
-					messageId: match.message.id,
-					createdAt: match.message.createdAt,
-					direction: match.message.direction,
-					text: match.message.text,
-					...(match.urlExpansions
-						? { urlExpansions: match.urlExpansions }
-						: {}),
-				})),
-			};
-		})
-		.filter((candidate): candidate is WhoisCandidate => candidate !== null)
-		.sort((left, right) => {
-			if (right.confidence !== left.confidence) {
-				return right.confidence - left.confidence;
+		const texts = yield* trySync(() => [
+			...conversations.flatMap(getMessageTexts),
+			...conversations.flatMap((conversation) =>
+				[
+					conversation.participant.bio,
+					conversation.participant.url ?? "",
+					...getProfileBioUrls(conversation.participant),
+				].filter((text) => text.includes("https://t.co/")),
+			),
+			...relatedTweets.map((tweet) => tweet.text),
+		]);
+		const urlExpansions =
+			(options.expandUrls ?? true)
+				? yield* expandUrlsFromTextsEffect(texts, {
+						refresh: options.refreshUrlCache,
+					})
+				: [];
+		yield* trySync(() => {
+			for (const conversation of conversations) {
+				attachExpansionsToMatches(conversation, urlExpansions);
 			}
-			return (
-				new Date(right.conversation.lastMessageAt).getTime() -
-				new Date(left.conversation.lastMessageAt).getTime()
+		});
+
+		const candidates = yield* trySync(() => {
+			const profileIds = conversations.map(
+				(conversation) => conversation.participant.id,
 			);
-		})
-		.slice(0, limit);
+			const db = getNativeDb();
+			const bioEntitiesByProfile = fetchProfileBioEntities(db, profileIds);
+			const snapshotsByProfile = fetchProfileSnapshots(db, profileIds);
+			return conversations
+				.map((conversation): WhoisCandidate | null => {
+					const conversationExpansions = urlExpansions.filter((item) =>
+						getMessageTexts(conversation).some((text) =>
+							text.includes(item.url),
+						),
+					);
+					const profileId = conversation.participant.id;
+					const score = scoreCandidate(
+						query,
+						conversation,
+						conversationExpansions,
+						bioEntitiesByProfile.get(profileId) ?? [],
+						snapshotsByProfile.get(profileId) ?? [],
+					);
+					if (
+						!hasCurrentAffiliationMatch(
+							conversation.participant,
+							options.currentAffiliation,
+						)
+					) {
+						return null;
+					}
+					if (
+						!hasAffiliationEvidenceMatch(
+							conversation.participant,
+							score.profileEvidence,
+							options.affiliation,
+						)
+					) {
+						return null;
+					}
+					if (
+						options.excludeDomainOnly &&
+						!hasNonDomainEvidence(score.profileEvidence)
+					) {
+						return null;
+					}
+					return {
+						conversation,
+						confidence: score.confidence,
+						category: score.category,
+						reasons: score.reasons,
+						profileEvidence: score.profileEvidence,
+						evidence: (conversation.matches ?? []).map((match) => ({
+							messageId: match.message.id,
+							createdAt: match.message.createdAt,
+							direction: match.message.direction,
+							text: match.message.text,
+							...(match.urlExpansions
+								? { urlExpansions: match.urlExpansions }
+								: {}),
+						})),
+					};
+				})
+				.filter((candidate): candidate is WhoisCandidate => candidate !== null)
+				.sort((left, right) => {
+					if (right.confidence !== left.confidence) {
+						return right.confidence - left.confidence;
+					}
+					return (
+						new Date(right.conversation.lastMessageAt).getTime() -
+						new Date(left.conversation.lastMessageAt).getTime()
+					);
+				})
+				.slice(0, limit);
+		});
 
-	return {
-		query,
-		candidates,
-		relatedTweets,
-		urlExpansions,
-		...(profileResolution ? { profileResolution } : {}),
-	};
+		return {
+			query,
+			candidates,
+			relatedTweets,
+			urlExpansions,
+			...(profileResolution ? { profileResolution } : {}),
+		};
+	});
+}
+
+export function runWhois(
+	query: string,
+	options: WhoisOptions = {},
+): Promise<WhoisResult> {
+	return runEffectPromise(runWhoisEffect(query, options));
 }
 
 const CATEGORY_LABELS: Record<WhoisCandidateCategory, string> = {

package/src/lib/x-web.ts

@@ -1,5 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { getCookies } from "@steipete/sweet-cookie";
+import { Effect } from "effect";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 
 const X_WEB_BEARER_TOKEN =
 	"AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA";
@@ -48,53 +50,70 @@ function pickCookieValue(
 	return matches[0]?.value ?? null;
 }
 
-async function resolveXWebCookies() {
-	const envAuthToken = normalizeCookieValue(
-		process.env.AUTH_TOKEN ?? process.env.TWITTER_AUTH_TOKEN,
-	);
-	const envCt0 = normalizeCookieValue(
-		process.env.CT0 ?? process.env.TWITTER_CT0,
-	);
+function resolveXWebCookiesEffect() {
+	return Effect.gen(function* () {
+		const envAuthToken = normalizeCookieValue(
+			process.env.AUTH_TOKEN ?? process.env.TWITTER_AUTH_TOKEN,
+		);
+		const envCt0 = normalizeCookieValue(
+			process.env.CT0 ?? process.env.TWITTER_CT0,
+		);
+
+		if (envAuthToken && envCt0) {
+			return {
+				authToken: envAuthToken,
+				ct0: envCt0,
+				cookieHeader: buildCookieHeader(envAuthToken, envCt0),
+				source: "env",
+			};
+		}
+
+		const cookieResult = yield* tryPromise(() =>
+			getCookies({
+				url: "https://x.com/",
+				origins: [...X_WEB_ORIGINS],
+				names: [...X_WEB_COOKIE_NAMES],
+				browsers: ["safari", "chrome", "firefox"] satisfies CookieSource[],
+				mode: "merge",
+				timeoutMs: process.platform === "darwin" ? 30_000 : undefined,
+			}),
+		);
+
+		const authToken = pickCookieValue(cookieResult.cookies, "auth_token");
+		const ct0 = pickCookieValue(cookieResult.cookies, "ct0");
+		if (!authToken || !ct0) {
+			return null;
+		}
 
-	if (envAuthToken && envCt0) {
 		return {
-			authToken: envAuthToken,
-			ct0: envCt0,
-			cookieHeader: buildCookieHeader(envAuthToken, envCt0),
-			source: "env",
+			authToken,
+			ct0,
+			cookieHeader: buildCookieHeader(authToken, ct0),
+			source: "browser",
 		};
-	}
-
-	const cookieResult = await getCookies({
-		url: "https://x.com/",
-		origins: [...X_WEB_ORIGINS],
-		names: [...X_WEB_COOKIE_NAMES],
-		browsers: ["safari", "chrome", "firefox"] satisfies CookieSource[],
-		mode: "merge",
-		timeoutMs: process.platform === "darwin" ? 30_000 : undefined,
 	});
-
-	const authToken = pickCookieValue(cookieResult.cookies, "auth_token");
-	const ct0 = pickCookieValue(cookieResult.cookies, "ct0");
-	if (!authToken || !ct0) {
-		return null;
-	}
-
-	return {
-		authToken,
-		ct0,
-		cookieHeader: buildCookieHeader(authToken, ct0),
-		source: "browser",
-	};
 }
 
-async function runXWebBlockMutation(
+function runXWebBlockMutationEffect(
 	path: string,
 	params: URLSearchParams,
 	action: string,
 ) {
-	try {
-		const cookies = await resolveXWebCookies();
+	return Effect.gen(function* () {
+		if (process.env.BIRDCLAW_DISABLE_LIVE_WRITES === "1") {
+			return {
+				ok: false,
+				output: `x-web ${action} unavailable: live writes disabled`,
+			};
+		}
+		if (process.env.BIRDCLAW_ALLOW_X_WEB_WRITES !== "1") {
+			return {
+				ok: false,
+				output: `x-web ${action} unavailable: unverified account`,
+			};
+		}
+
+		const cookies = yield* resolveXWebCookiesEffect();
 		if (!cookies) {
 			return {
 				ok: false,
@@ -102,27 +121,29 @@ async function runXWebBlockMutation(
 			};
 		}
 
-		const response = await fetch(`https://x.com/i/api/1.1/${path}`, {
-			method: "POST",
-			headers: {
-				accept: "*/*",
-				"accept-language": "en-US,en;q=0.9",
-				authorization: `Bearer ${X_WEB_BEARER_TOKEN}`,
-				"content-type": "application/x-www-form-urlencoded",
-				cookie: cookies.cookieHeader,
-				origin: "https://x.com",
-				referer: "https://x.com/",
-				"user-agent": X_WEB_USER_AGENT,
-				"x-client-transaction-id": randomUUID().replaceAll("-", ""),
-				"x-csrf-token": cookies.ct0,
-				"x-twitter-active-user": "yes",
-				"x-twitter-auth-type": "OAuth2Session",
-				"x-twitter-client-language": "en",
-			},
-			body: params,
-		});
-
-		const text = await response.text();
+		const response = yield* tryPromise(() =>
+			fetch(`https://x.com/i/api/1.1/${path}`, {
+				method: "POST",
+				headers: {
+					accept: "*/*",
+					"accept-language": "en-US,en;q=0.9",
+					authorization: `Bearer ${X_WEB_BEARER_TOKEN}`,
+					"content-type": "application/x-www-form-urlencoded",
+					cookie: cookies.cookieHeader,
+					origin: "https://x.com",
+					referer: "https://x.com/",
+					"user-agent": X_WEB_USER_AGENT,
+					"x-client-transaction-id": randomUUID().replaceAll("-", ""),
+					"x-csrf-token": cookies.ct0,
+					"x-twitter-active-user": "yes",
+					"x-twitter-auth-type": "OAuth2Session",
+					"x-twitter-client-language": "en",
+				},
+				body: params,
+			}),
+		);
+
+		const text = yield* tryPromise(() => response.text());
 		if (!response.ok) {
 			return {
 				ok: false,
@@ -134,19 +155,21 @@ async function runXWebBlockMutation(
 			ok: true,
 			output: `x-web ${action} ok via ${cookies.source}`,
 		};
-	} catch (error) {
-		return {
-			ok: false,
-			output:
-				error instanceof Error
-					? `x-web ${action} failed: ${error.message}`
-					: `x-web ${action} failed`,
-		};
-	}
+	}).pipe(
+		Effect.catchAll((error) =>
+			Effect.succeed({
+				ok: false,
+				output:
+					error instanceof Error
+						? `x-web ${action} failed: ${error.message}`
+						: `x-web ${action} failed`,
+			}),
+		),
+	);
 }
 
-export async function blockUserViaXWeb(targetUserId: string) {
-	return runXWebBlockMutation(
+export function blockUserViaXWebEffect(targetUserId: string) {
+	return runXWebBlockMutationEffect(
 		"blocks/create.json",
 		new URLSearchParams({
 			user_id: targetUserId,
@@ -156,8 +179,8 @@ export async function blockUserViaXWeb(targetUserId: string) {
 	);
 }
 
-export async function unblockUserViaXWeb(targetUserId: string) {
-	return runXWebBlockMutation(
+export function unblockUserViaXWebEffect(targetUserId: string) {
+	return runXWebBlockMutationEffect(
 		"blocks/destroy.json",
 		new URLSearchParams({
 			user_id: targetUserId,
@@ -166,3 +189,11 @@ export async function unblockUserViaXWeb(targetUserId: string) {
 		"unblock",
 	);
 }
+
+export function blockUserViaXWeb(targetUserId: string) {
+	return runEffectPromise(blockUserViaXWebEffect(targetUserId));
+}
+
+export function unblockUserViaXWeb(targetUserId: string) {
+	return runEffectPromise(unblockUserViaXWebEffect(targetUserId));
+}