birdclaw 0.5.0 → 0.6.0

package/src/lib/blocklist.ts

@@ -1,5 +1,7 @@
 import { readFile } from "node:fs/promises";
+import { Effect } from "effect";
 import { addBlock } from "./blocks";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 
 export interface BlocklistImportItem {
 	query: string;
@@ -76,14 +78,31 @@ export function parseBlocklistText(text: string) {
 	return items;
 }
 
-export async function importBlocklist(accountId: string, filePath: string) {
-	const text = await readFile(filePath, "utf8");
-	const queries = parseBlocklistText(text);
-	const items: BlocklistImportItem[] = [];
+export function importBlocklistEffect(accountId: string, filePath: string) {
+	return Effect.gen(function* () {
+		const text = yield* tryPromise(() => readFile(filePath, "utf8"));
+		const queries = parseBlocklistText(text);
+		const items: BlocklistImportItem[] = [];
 
-	for (const query of queries) {
-		try {
-			const result = await addBlock(accountId, query);
+		for (const query of queries) {
+			const blocked = yield* tryPromise(() => addBlock(accountId, query)).pipe(
+				Effect.map((result) => ({ ok: true as const, result })),
+				Effect.catchAll((error) =>
+					Effect.succeed({ ok: false as const, error }),
+				),
+			);
+			if (!blocked.ok) {
+				items.push({
+					query,
+					ok: false,
+					error:
+						blocked.error instanceof Error
+							? blocked.error.message
+							: "block failed",
+				});
+				continue;
+			}
+			const { result } = blocked;
 			if (!result.ok) {
 				items.push({
 					query,
@@ -98,22 +117,20 @@ export async function importBlocklist(accountId: string, filePath: string) {
 				blockedAt: result.blockedAt,
 				handle: result.profile.handle,
 			});
-		} catch (error) {
-			items.push({
-				query,
-				ok: false,
-				error: error instanceof Error ? error.message : "block failed",
-			});
 		}
-	}
 
-	return {
-		ok: items.every((item) => item.ok),
-		accountId,
-		path: filePath,
-		requestedCount: queries.length,
-		blockedCount: items.filter((item) => item.ok).length,
-		failedCount: items.filter((item) => !item.ok).length,
-		items,
-	} satisfies BlocklistImportResult;
+		return {
+			ok: items.every((item) => item.ok),
+			accountId,
+			path: filePath,
+			requestedCount: queries.length,
+			blockedCount: items.filter((item) => item.ok).length,
+			failedCount: items.filter((item) => !item.ok).length,
+			items,
+		} satisfies BlocklistImportResult;
+	});
+}
+
+export function importBlocklist(accountId: string, filePath: string) {
+	return runEffectPromise(importBlocklistEffect(accountId, filePath));
 }

package/src/lib/blocks-write.ts

@@ -1,118 +1,167 @@
+import { Effect } from "effect";
 import { runModerationAction } from "./actions-transport";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 import {
 	deleteModerationRow,
 	type ModerationActionOptions,
-	resolveModerationTarget,
+	resolveModerationTargetEffect,
 	writeModerationRow,
 } from "./moderation-write";
 
-export async function addBlock(
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: (error) =>
+			error instanceof Error ? error : new Error(String(error)),
+	});
+}
+
+export function addBlockEffect(
 	accountId: string,
 	query: string,
 	options: ModerationActionOptions = {},
 ) {
-	const { db, resolved, resolvedAccountId, actionQuery } =
-		await resolveModerationTarget({
-			accountId,
-			query,
-			selfActionError: "Cannot block the current account",
-		});
-	const transport = await runModerationAction({
-		action: "block",
-		query: actionQuery,
-		targetUserId: resolved.externalUserId ?? undefined,
-		transport: options.transport,
-	});
+	return Effect.gen(function* () {
+		const { db, resolved, resolvedAccountId, accountIdentity, actionQuery } =
+			yield* resolveModerationTargetEffect({
+				accountId,
+				query,
+				selfActionError: "Cannot block the current account",
+			});
+		const transport = yield* tryPromise(() =>
+			runModerationAction({
+				action: "block",
+				query: actionQuery,
+				targetUserId: resolved.externalUserId ?? undefined,
+				transport: options.transport,
+				expectedAccount: accountIdentity,
+			}),
+		);
+
+		if (!transport.ok) {
+			return {
+				ok: false,
+				action: "block",
+				accountId: resolvedAccountId,
+				profile: resolved.profile,
+				transport,
+			};
+		}
+
+		const blockedAt = new Date().toISOString();
+		yield* trySync(() =>
+			writeModerationRow(
+				db,
+				"blocks",
+				resolvedAccountId,
+				resolved.profile.id,
+				blockedAt,
+			),
+		);
 
-	if (!transport.ok) {
 		return {
-			ok: false,
+			ok: true,
 			action: "block",
 			accountId: resolvedAccountId,
+			blockedAt,
 			profile: resolved.profile,
 			transport,
 		};
-	}
-
-	const blockedAt = new Date().toISOString();
-	writeModerationRow(
-		db,
-		"blocks",
-		resolvedAccountId,
-		resolved.profile.id,
-		blockedAt,
-	);
+	});
+}
 
-	return {
-		ok: true,
-		action: "block",
-		accountId: resolvedAccountId,
-		blockedAt,
-		profile: resolved.profile,
-		transport,
-	};
+export function addBlock(
+	accountId: string,
+	query: string,
+	options: ModerationActionOptions = {},
+) {
+	return runEffectPromise(addBlockEffect(accountId, query, options));
 }
 
-export async function recordBlock(accountId: string, query: string) {
-	const { db, resolved, resolvedAccountId } = await resolveModerationTarget({
-		accountId,
-		query,
-		selfActionError: "Cannot block the current account",
-	});
+export function recordBlockEffect(accountId: string, query: string) {
+	return Effect.gen(function* () {
+		const { db, resolved, resolvedAccountId } =
+			yield* resolveModerationTargetEffect({
+				accountId,
+				query,
+				selfActionError: "Cannot block the current account",
+			});
 
-	const blockedAt = new Date().toISOString();
-	writeModerationRow(
-		db,
-		"blocks",
-		resolvedAccountId,
-		resolved.profile.id,
-		blockedAt,
-	);
+		const blockedAt = new Date().toISOString();
+		yield* trySync(() =>
+			writeModerationRow(
+				db,
+				"blocks",
+				resolvedAccountId,
+				resolved.profile.id,
+				blockedAt,
+			),
+		);
 
-	return {
-		ok: true,
-		action: "record-block",
-		accountId: resolvedAccountId,
-		blockedAt,
-		profile: resolved.profile,
-	};
+		return {
+			ok: true,
+			action: "record-block",
+			accountId: resolvedAccountId,
+			blockedAt,
+			profile: resolved.profile,
+		};
+	});
+}
+
+export function recordBlock(accountId: string, query: string) {
+	return runEffectPromise(recordBlockEffect(accountId, query));
 }
 
-export async function removeBlock(
+export function removeBlockEffect(
 	accountId: string,
 	query: string,
 	options: ModerationActionOptions = {},
 ) {
-	const { db, resolved, resolvedAccountId, actionQuery } =
-		await resolveModerationTarget({
-			accountId,
-			query,
-			selfActionError: "Cannot block the current account",
-		});
-	const transport = await runModerationAction({
-		action: "unblock",
-		query: actionQuery,
-		targetUserId: resolved.externalUserId ?? undefined,
-		transport: options.transport,
-	});
+	return Effect.gen(function* () {
+		const { db, resolved, resolvedAccountId, accountIdentity, actionQuery } =
+			yield* resolveModerationTargetEffect({
+				accountId,
+				query,
+				selfActionError: "Cannot block the current account",
+			});
+		const transport = yield* tryPromise(() =>
+			runModerationAction({
+				action: "unblock",
+				query: actionQuery,
+				targetUserId: resolved.externalUserId ?? undefined,
+				transport: options.transport,
+				expectedAccount: accountIdentity,
+			}),
+		);
+
+		if (!transport.ok) {
+			return {
+				ok: false,
+				action: "unblock",
+				accountId: resolvedAccountId,
+				profile: resolved.profile,
+				transport,
+			};
+		}
+
+		yield* trySync(() =>
+			deleteModerationRow(db, "blocks", resolvedAccountId, resolved.profile.id),
+		);
 
-	if (!transport.ok) {
 		return {
-			ok: false,
+			ok: true,
 			action: "unblock",
 			accountId: resolvedAccountId,
 			profile: resolved.profile,
 			transport,
 		};
-	}
-
-	deleteModerationRow(db, "blocks", resolvedAccountId, resolved.profile.id);
+	});
+}
 
-	return {
-		ok: true,
-		action: "unblock",
-		accountId: resolvedAccountId,
-		profile: resolved.profile,
-		transport,
-	};
+export function removeBlock(
+	accountId: string,
+	query: string,
+	options: ModerationActionOptions = {},
+) {
+	return runEffectPromise(removeBlockEffect(accountId, query, options));
 }

package/src/lib/blocks.ts

@@ -1,5 +1,7 @@
+import { Effect } from "effect";
 import type { Database } from "./sqlite";
 import { getNativeDb } from "./db";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 import {
 	getAccountHandle,
 	getDefaultAccountId,
@@ -7,14 +9,32 @@ import {
 } from "./moderation-target";
 import type { BlockItem, BlockListResponse, BlockSearchItem } from "./types";
 import { upsertProfileFromXUser } from "./x-profile";
-import { listBlockedUsers, lookupAuthenticatedUser } from "./xurl";
+import { listBlockedUsers, lookupAuthenticatedUserFresh } from "./xurl";
 
-export { addBlock, recordBlock, removeBlock } from "./blocks-write";
+export {
+	addBlock,
+	addBlockEffect,
+	recordBlock,
+	recordBlockEffect,
+	removeBlock,
+	removeBlockEffect,
+} from "./blocks-write";
 
 function remoteBlockSyncDisabled() {
 	return process.env.BIRDCLAW_DISABLE_LIVE_WRITES === "1";
 }
 
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: toError,
+	});
+}
+
 function upsertRemoteBlock(
 	db: Database,
 	accountId: string,
@@ -206,116 +226,164 @@ export function getBlocksResponse({
 	};
 }
 
-export async function syncBlocks(accountId: string) {
-	const db = getNativeDb();
-	const resolvedAccountId = accountId || getDefaultAccountId(db);
-	const blockedAt = new Date().toISOString();
-	const remoteProfileIds: string[] = [];
-
-	if (remoteBlockSyncDisabled()) {
-		return {
-			ok: true,
-			accountId: resolvedAccountId,
-			synced: false,
-			syncedCount: 0,
-			transport: {
-				ok: true,
-				output: "remote block sync disabled in test mode",
-			},
-		};
-	}
-
-	try {
-		const me = await lookupAuthenticatedUser();
-		const sourceUserId =
-			typeof me?.id === "string" && me.id.length > 0 ? me.id : null;
-		const sourceUsername =
-			typeof me?.username === "string" ? me.username.replace(/^@/, "") : "";
+export function syncBlocksEffect(accountId: string) {
+	return Effect.gen(function* () {
+		const db = yield* trySync(() => getNativeDb());
+		const resolvedAccountId = accountId || getDefaultAccountId(db);
 		const accountHandle = getAccountHandle(db, resolvedAccountId);
+		if (!accountHandle) {
+			return yield* Effect.fail(
+				new Error(`Unknown account: ${resolvedAccountId}`),
+			);
+		}
+		const account = yield* trySync(
+			() =>
+				db
+					.prepare("select handle, external_user_id from accounts where id = ?")
+					.get(resolvedAccountId) as
+					| { handle: string; external_user_id: string | null }
+					| undefined,
+		);
+		const blockedAt = new Date().toISOString();
+		const remoteProfileIds: string[] = [];
 
-		if (!sourceUserId) {
+		if (remoteBlockSyncDisabled()) {
 			return {
-				ok: false,
+				ok: true,
 				accountId: resolvedAccountId,
 				synced: false,
 				syncedCount: 0,
 				transport: {
-					ok: false,
-					output:
-						"xurl block sync unavailable without an authenticated account",
+					ok: true,
+					output: "remote block sync disabled in test mode",
 				},
 			};
 		}
 
-		if (accountHandle && sourceUsername && accountHandle !== sourceUsername) {
-			return {
-				ok: false,
-				accountId: resolvedAccountId,
-				synced: false,
-				syncedCount: 0,
-				transport: {
+		return yield* Effect.gen(function* () {
+			const me = yield* tryPromise(() => lookupAuthenticatedUserFresh()).pipe(
+				Effect.mapError(toError),
+			);
+			const sourceUserId =
+				typeof me?.id === "string" && me.id.length > 0 ? me.id : null;
+			const sourceUsername =
+				typeof me?.username === "string" ? me.username.replace(/^@/, "") : "";
+			const accountExternalUserId = account?.external_user_id?.trim() ?? "";
+			if (!sourceUserId) {
+				return {
 					ok: false,
-					output: `xurl is authenticated as @${sourceUsername}, not @${accountHandle}`,
-				},
-			};
-		}
+					accountId: resolvedAccountId,
+					synced: false,
+					syncedCount: 0,
+					transport: {
+						ok: false,
+						output:
+							"xurl block sync unavailable without an authenticated account",
+					},
+				};
+			}
+
+			if (accountExternalUserId && sourceUserId !== accountExternalUserId) {
+				return {
+					ok: false,
+					accountId: resolvedAccountId,
+					synced: false,
+					syncedCount: 0,
+					transport: {
+						ok: false,
+						output: `xurl is authenticated as user ${sourceUserId}, not account ${resolvedAccountId}`,
+					},
+				};
+			}
 
-		let nextToken: string | null = null;
-		let pageCount = 0;
+			if (
+				!accountExternalUserId &&
+				(!sourceUsername || accountHandle !== sourceUsername)
+			) {
+				return {
+					ok: false,
+					accountId: resolvedAccountId,
+					synced: false,
+					syncedCount: 0,
+					transport: {
+						ok: false,
+						output: sourceUsername
+							? `xurl is authenticated as @${sourceUsername}, not @${accountHandle}`
+							: "xurl authenticated username unavailable",
+					},
+				};
+			}
 
-		do {
-			const page = await listBlockedUsers(sourceUserId, nextToken ?? undefined);
-			const mergeRemotePage = db.transaction(() => {
-				for (const user of page.items) {
-					const resolved = upsertProfileFromXUser(db, user);
-					remoteProfileIds.push(resolved.profile.id);
-					upsertRemoteBlock(
-						db,
-						resolvedAccountId,
-						resolved.profile.id,
-						blockedAt,
-					);
-				}
-			});
-			mergeRemotePage();
-			nextToken = page.nextToken;
-			pageCount += 1;
-		} while (nextToken && pageCount < 20);
+			let nextToken: string | null = null;
+			let pageCount = 0;
+			let completed = false;
 
-		const pruneMergedBlocks = db.transaction(() => {
-			pruneRemoteBlocks(db, resolvedAccountId, remoteProfileIds);
-		});
-		pruneMergedBlocks();
+			do {
+				const page = yield* tryPromise(() =>
+					listBlockedUsers(sourceUserId, nextToken ?? undefined),
+				).pipe(Effect.mapError(toError));
+				yield* trySync(() => {
+					const mergeRemotePage = db.transaction(() => {
+						for (const user of page.items) {
+							const resolved = upsertProfileFromXUser(db, user);
+							remoteProfileIds.push(resolved.profile.id);
+							upsertRemoteBlock(
+								db,
+								resolvedAccountId,
+								resolved.profile.id,
+								blockedAt,
+							);
+						}
+					});
+					mergeRemotePage();
+				});
+				nextToken = page.nextToken;
+				pageCount += 1;
+			} while (nextToken && pageCount < 20);
 
-		return {
-			ok: true,
-			accountId: resolvedAccountId,
-			synced: true,
-			syncedCount: remoteProfileIds.length,
-			transport: {
+			completed = !nextToken;
+			if (completed) {
+				yield* trySync(() => {
+					const pruneMergedBlocks = db.transaction(() => {
+						pruneRemoteBlocks(db, resolvedAccountId, remoteProfileIds);
+					});
+					pruneMergedBlocks();
+				});
+			}
+
+			return {
 				ok: true,
-				output: `synced ${remoteProfileIds.length} remote blocks`,
-			},
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			accountId: resolvedAccountId,
-			synced: remoteProfileIds.length > 0,
-			syncedCount: remoteProfileIds.length,
-			transport: {
-				ok: false,
-				output:
-					remoteProfileIds.length > 0
-						? `partial block sync after ${remoteProfileIds.length} profiles: ${
-								error instanceof Error
-									? error.message
-									: "xurl block sync failed"
-							}`
-						: error instanceof Error
-							? error.message
-							: "xurl block sync failed",
-			},
-		};
-	}
+				accountId: resolvedAccountId,
+				synced: true,
+				syncedCount: remoteProfileIds.length,
+				partial: !completed,
+				transport: {
+					ok: true,
+					output: completed
+						? `synced ${remoteProfileIds.length} remote blocks`
+						: `synced ${remoteProfileIds.length} remote blocks (partial; skipped pruning)`,
+				},
+			};
+		}).pipe(
+			Effect.catchAll((error) =>
+				Effect.succeed({
+					ok: false,
+					accountId: resolvedAccountId,
+					synced: remoteProfileIds.length > 0,
+					syncedCount: remoteProfileIds.length,
+					transport: {
+						ok: false,
+						output:
+							remoteProfileIds.length > 0
+								? `partial block sync after ${remoteProfileIds.length} profiles: ${error.message}`
+								: error.message,
+					},
+				}),
+			),
+		);
+	});
+}
+
+export function syncBlocks(accountId: string) {
+	return runEffectPromise(syncBlocksEffect(accountId));
 }