birdclaw 0.8.2 → 0.8.4

package/src/lib/blocklist.ts

@@ -1,136 +0,0 @@
-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;
-	ok: boolean;
-	blockedAt?: string;
-	handle?: string;
-	error?: string;
-}
-
-export interface BlocklistImportResult {
-	ok: boolean;
-	accountId: string;
-	path: string;
-	requestedCount: number;
-	blockedCount: number;
-	failedCount: number;
-	items: BlocklistImportItem[];
-}
-
-function stripInlineCode(value: string) {
-	const match = value.match(/`([^`]+)`/);
-	return match?.[1] ?? value;
-}
-
-function extractQueryFromLine(value: string) {
-	const trimmed = value.trim();
-	if (!trimmed || trimmed.startsWith("#")) {
-		return null;
-	}
-
-	if (
-		!trimmed.startsWith("@") &&
-		!trimmed.startsWith("-") &&
-		!trimmed.startsWith("*") &&
-		!trimmed.startsWith("+") &&
-		!trimmed.startsWith("`") &&
-		!trimmed.startsWith("http") &&
-		trimmed.split(/\s+/).length > 1
-	) {
-		return null;
-	}
-
-	const withoutBullet = trimmed.replace(/^(?:[-*+]|\d+\.)\s+/, "");
-	const withoutCode = stripInlineCode(withoutBullet).trim();
-	if (!withoutCode) {
-		return null;
-	}
-
-	if (/^(?:https?:\/\/)/i.test(withoutCode)) {
-		return withoutCode.split(/\s+/)[0] ?? null;
-	}
-
-	return (
-		withoutCode
-			.split(/[,\s:;]+/)[0]
-			?.replace(/^["'`]+|["'`,.]+$/g, "")
-			.trim() ?? null
-	);
-}
-
-export function parseBlocklistText(text: string) {
-	const items: string[] = [];
-	const seen = new Set<string>();
-
-	for (const line of text.split(/\r?\n/)) {
-		const query = extractQueryFromLine(line);
-		if (!query || seen.has(query)) {
-			continue;
-		}
-		seen.add(query);
-		items.push(query);
-	}
-
-	return items;
-}
-
-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) {
-			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,
-					ok: false,
-					error: result.transport.output || "block failed",
-				});
-				continue;
-			}
-			items.push({
-				query,
-				ok: true,
-				blockedAt: result.blockedAt,
-				handle: result.profile.handle,
-			});
-		}
-
-		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,167 +0,0 @@
-import { Effect } from "effect";
-import { runModerationAction } from "./actions-transport";
-import { runEffectPromise, tryPromise } from "./effect-runtime";
-import {
-	deleteModerationRow,
-	type ModerationActionOptions,
-	resolveModerationTargetEffect,
-	writeModerationRow,
-} from "./moderation-write";
-
-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 = {},
-) {
-	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,
-			),
-		);
-
-		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 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();
-		yield* trySync(() =>
-			writeModerationRow(
-				db,
-				"blocks",
-				resolvedAccountId,
-				resolved.profile.id,
-				blockedAt,
-			),
-		);
-
-		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 function removeBlockEffect(
-	accountId: string,
-	query: string,
-	options: ModerationActionOptions = {},
-) {
-	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),
-		);
-
-		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,389 +0,0 @@
-import { Effect } from "effect";
-import type { Database } from "./sqlite";
-import { getNativeDb } from "./db";
-import { runEffectPromise, tryPromise } from "./effect-runtime";
-import {
-	getAccountHandle,
-	getDefaultAccountId,
-	toProfile,
-} from "./moderation-target";
-import type { BlockItem, BlockListResponse, BlockSearchItem } from "./types";
-import { upsertProfileFromXUser } from "./x-profile";
-import { listBlockedUsers, lookupAuthenticatedUserFresh } from "./xurl";
-
-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,
-	profileId: string,
-	blockedAt: string,
-) {
-	db.prepare(
-		`
-    insert into blocks (account_id, profile_id, source, created_at)
-    values (?, ?, 'remote', ?)
-    on conflict(account_id, profile_id) do update set
-      source = excluded.source,
-      created_at = blocks.created_at
-    `,
-	).run(accountId, profileId, blockedAt);
-}
-
-function pruneRemoteBlocks(
-	db: Database,
-	accountId: string,
-	profileIds: string[],
-) {
-	if (profileIds.length === 0) {
-		db.prepare(
-			"delete from blocks where account_id = ? and source = 'remote'",
-		).run(accountId);
-		return;
-	}
-
-	const placeholders = profileIds.map(() => "?").join(", ");
-	db.prepare(
-		`
-    delete from blocks
-    where account_id = ?
-      and source = 'remote'
-      and profile_id not in (${placeholders})
-    `,
-	).run(accountId, ...profileIds);
-}
-
-export function listBlocks({
-	account,
-	search,
-	limit = 50,
-}: {
-	account?: string;
-	search?: string;
-	limit?: number;
-} = {}): BlockItem[] {
-	const db = getNativeDb();
-	const params: Array<string | number> = [];
-	let where = "where 1 = 1";
-
-	if (account && account !== "all") {
-		where += " and b.account_id = ?";
-		params.push(account);
-	}
-
-	if (search?.trim()) {
-		where += " and (p.handle like ? or p.display_name like ? or p.bio like ?)";
-		params.push(
-			`%${search.trim()}%`,
-			`%${search.trim()}%`,
-			`%${search.trim()}%`,
-		);
-	}
-
-	params.push(limit);
-
-	const rows = db
-		.prepare(
-			`
-      select
-        b.account_id,
-        a.handle as account_handle,
-        b.source,
-        b.created_at as blocked_at,
-        p.id,
-        p.handle,
-        p.display_name,
-        p.bio,
-        p.followers_count,
-        p.avatar_hue,
-        p.avatar_url,
-        p.created_at
-      from blocks b
-      join accounts a on a.id = b.account_id
-      join profiles p on p.id = b.profile_id
-      ${where}
-      order by b.created_at desc
-      limit ?
-      `,
-		)
-		.all(...params) as Array<Record<string, unknown>>;
-
-	return rows.map((row) => ({
-		accountId: String(row.account_id),
-		accountHandle: String(row.account_handle),
-		source: String(row.source),
-		blockedAt: String(row.blocked_at),
-		profile: toProfile(row),
-	}));
-}
-
-export function searchBlockCandidates({
-	accountId,
-	search,
-	limit = 8,
-}: {
-	accountId: string;
-	search?: string;
-	limit?: number;
-}): BlockSearchItem[] {
-	const db = getNativeDb();
-	if (!search?.trim()) {
-		return [];
-	}
-
-	const accountHandle = getAccountHandle(db, accountId);
-	const rows = db
-		.prepare(
-			`
-      select
-        p.id,
-        p.handle,
-        p.display_name,
-        p.bio,
-        p.followers_count,
-        p.avatar_hue,
-        p.avatar_url,
-        p.created_at,
-        b.created_at as blocked_at
-      from profiles p
-      left join blocks b
-        on b.profile_id = p.id
-       and b.account_id = ?
-      where p.id != 'profile_me'
-        and p.handle != ?
-        and (
-          p.handle like ?
-          or p.display_name like ?
-          or p.bio like ?
-        )
-      order by
-        case when b.created_at is null then 1 else 0 end,
-        b.created_at desc,
-        p.followers_count desc,
-        p.display_name asc
-      limit ?
-      `,
-		)
-		.all(
-			accountId,
-			accountHandle,
-			`%${search.trim()}%`,
-			`%${search.trim()}%`,
-			`%${search.trim()}%`,
-			limit,
-		) as Array<Record<string, unknown>>;
-
-	return rows.map((row) => ({
-		profile: toProfile(row),
-		isBlocked: Boolean(row.blocked_at),
-		blockedAt:
-			typeof row.blocked_at === "string" ? String(row.blocked_at) : undefined,
-	}));
-}
-
-export function getBlocksResponse({
-	accountId,
-	search,
-	limit,
-}: {
-	accountId?: string;
-	search?: string;
-	limit?: number;
-}): BlockListResponse {
-	const db = getNativeDb();
-	const resolvedAccountId =
-		accountId && accountId !== "all" ? accountId : getDefaultAccountId(db);
-
-	return {
-		items: listBlocks({ account: accountId, search, limit }),
-		matches: searchBlockCandidates({
-			accountId: resolvedAccountId,
-			search,
-			limit: Math.min(limit ?? 8, 12),
-		}),
-	};
-}
-
-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 (remoteBlockSyncDisabled()) {
-			return {
-				ok: true,
-				accountId: resolvedAccountId,
-				synced: false,
-				syncedCount: 0,
-				transport: {
-					ok: true,
-					output: "remote block sync disabled in test mode",
-				},
-			};
-		}
-
-		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,
-					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}`,
-					},
-				};
-			}
-
-			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",
-					},
-				};
-			}
-
-			let nextToken: string | null = null;
-			let pageCount = 0;
-			let completed = false;
-
-			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);
-
-			completed = !nextToken;
-			if (completed) {
-				yield* trySync(() => {
-					const pruneMergedBlocks = db.transaction(() => {
-						pruneRemoteBlocks(db, resolvedAccountId, remoteProfileIds);
-					});
-					pruneMergedBlocks();
-				});
-			}
-
-			return {
-				ok: true,
-				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));
-}