birdclaw 0.8.2 → 0.8.4

package/src/lib/moderation-target.ts

@@ -1,216 +0,0 @@
-import type { Database } from "./sqlite";
-import { Effect } from "effect";
-import { lookupProfileViaBird } from "./bird-actions";
-import { getNativeDb } from "./db";
-import { runEffectPromise, tryPromise } from "./effect-runtime";
-import type { ProfileRecord, XurlMentionUser } from "./types";
-import { getExternalUserId, upsertProfileFromXUser } from "./x-profile";
-import {
-	lookupAuthenticatedUser,
-	lookupUsersByHandles,
-	lookupUsersByIds,
-} from "./xurl";
-
-export interface ResolvedModerationProfile {
-	profile: ProfileRecord;
-	externalUserId: string | null;
-}
-
-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,
-	});
-}
-
-export function toProfile(row: Record<string, unknown>): ProfileRecord {
-	const followingCount = Number(row.following_count ?? 0);
-	return {
-		id: String(row.id),
-		handle: String(row.handle),
-		displayName: String(row.display_name),
-		bio: String(row.bio),
-		followersCount: Number(row.followers_count),
-		...(Number.isFinite(followingCount) ? { followingCount } : {}),
-		avatarHue: Number(row.avatar_hue),
-		avatarUrl:
-			typeof row.avatar_url === "string" ? String(row.avatar_url) : undefined,
-		createdAt: String(row.created_at),
-	};
-}
-
-export function normalizeProfileQuery(value: string) {
-	const trimmed = value.trim();
-	if (!trimmed) return "";
-
-	const withoutPrefix = trimmed.replace(/^@/, "");
-	const urlMatch = withoutPrefix.match(
-		/^(?:https?:\/\/)?(?:www\.)?(?:x|twitter)\.com\/([^/?#]+)/i,
-	);
-	return (urlMatch?.[1] ?? withoutPrefix).replace(/^@/, "").trim();
-}
-
-export function getDefaultAccountId(db: Database) {
-	const row = db
-		.prepare(
-			`
-      select id
-      from accounts
-      order by is_default desc, created_at asc
-      limit 1
-      `,
-		)
-		.get() as { id: string } | undefined;
-	return row?.id ?? "acct_primary";
-}
-
-export function getAccountHandle(db: Database, accountId: string) {
-	const row = db
-		.prepare("select handle from accounts where id = ?")
-		.get(accountId) as { handle: string } | undefined;
-	return row?.handle.replace(/^@/, "") ?? "";
-}
-
-export function resolveLocalProfile(
-	db: Database,
-	normalizedQuery: string,
-): ResolvedModerationProfile | null {
-	const row = db
-		.prepare(
-			`
-      select id, handle, display_name, bio, followers_count, following_count, avatar_hue, avatar_url, created_at
-      from profiles
-      where id = ? or handle = ?
-      limit 1
-      `,
-		)
-		.get(normalizedQuery, normalizedQuery) as
-		| Record<string, unknown>
-		| undefined;
-
-	if (!row) {
-		return null;
-	}
-
-	const profile = toProfile(row);
-	return {
-		profile,
-		externalUserId: getExternalUserId(profile.id),
-	};
-}
-
-export function resolveProfileEffect(
-	query: string,
-): Effect.Effect<ResolvedModerationProfile, unknown> {
-	return Effect.gen(function* () {
-		const db = yield* trySync(() => getNativeDb());
-		const normalizedQuery = normalizeProfileQuery(query);
-		if (!normalizedQuery) {
-			return yield* Effect.fail(new Error("Missing profile handle or id"));
-		}
-
-		const local = yield* trySync(() =>
-			resolveLocalProfile(db, normalizedQuery),
-		);
-		if (process.env.BIRDCLAW_DISABLE_LIVE_PROFILE_LOOKUP === "1") {
-			if (local) {
-				return local;
-			}
-			return yield* Effect.fail(
-				new Error(`Profile not found locally: ${query}`),
-			);
-		}
-		if (
-			local &&
-			!local.profile.id.startsWith("profile_group_") &&
-			local.externalUserId
-		) {
-			return local;
-		}
-
-		let user: XurlMentionUser | undefined;
-		let lastError: unknown;
-
-		const birdResult = yield* tryPromise(() =>
-			lookupProfileViaBird(local?.profile.handle ?? normalizedQuery),
-		).pipe(
-			Effect.map((value) => ({ ok: true as const, value })),
-			Effect.catchAll((error) => Effect.succeed({ ok: false as const, error })),
-		);
-		if (birdResult.ok) {
-			user = birdResult.value ?? undefined;
-		} else {
-			lastError = birdResult.error;
-		}
-
-		if (!user) {
-			const xurlResult = yield* tryPromise(() =>
-				/^\d+$/.test(normalizedQuery)
-					? lookupUsersByIds([normalizedQuery])
-					: lookupUsersByHandles([local?.profile.handle ?? normalizedQuery]),
-			).pipe(
-				Effect.map((value) => ({ ok: true as const, value })),
-				Effect.catchAll((error) =>
-					Effect.succeed({ ok: false as const, error }),
-				),
-			);
-			if (xurlResult.ok) {
-				[user] = xurlResult.value;
-			} else {
-				lastError = xurlResult.error;
-			}
-		}
-
-		if (!user && lastError) {
-			if (local) {
-				return local;
-			}
-			return yield* Effect.fail(lastError);
-		}
-
-		if (!user) {
-			if (local) {
-				return local;
-			}
-			return yield* Effect.fail(new Error(`Profile not found: ${query}`));
-		}
-
-		if (local) {
-			return yield* trySync(() => upsertProfileFromXUser(db, user));
-		}
-
-		const username = String(user.username ?? "").replace(/^@/, "");
-		if (username) {
-			const localByHandle = yield* trySync(() =>
-				resolveLocalProfile(db, username),
-			);
-			if (localByHandle) {
-				return yield* trySync(() => upsertProfileFromXUser(db, user));
-			}
-		}
-
-		return yield* trySync(() => upsertProfileFromXUser(db, user));
-	});
-}
-
-export function resolveProfile(
-	query: string,
-): Promise<ResolvedModerationProfile> {
-	return runEffectPromise(resolveProfileEffect(query));
-}
-
-export function getAuthenticatedUserIdEffect() {
-	return Effect.gen(function* () {
-		const me = yield* tryPromise(() => lookupAuthenticatedUser());
-		const id = me?.id;
-		return typeof id === "string" && id.length > 0 ? id : null;
-	}).pipe(Effect.catchAll(() => Effect.succeed(null)));
-}
-
-export function getAuthenticatedUserId() {
-	return runEffectPromise(getAuthenticatedUserIdEffect());
-}

package/src/lib/moderation-write.ts

@@ -1,131 +0,0 @@
-import type { Database } from "./sqlite";
-import { Effect } from "effect";
-import type { ActionsTransport } from "./config";
-import { getNativeDb } from "./db";
-import { runEffectPromise } from "./effect-runtime";
-import {
-	getAccountHandle,
-	getDefaultAccountId,
-	normalizeProfileQuery,
-	resolveProfileEffect,
-} from "./moderation-target";
-import { getExternalUserId } from "./x-profile";
-
-export interface ModerationActionOptions {
-	transport?: ActionsTransport;
-}
-
-interface ResolveModerationTargetParams {
-	accountId: string;
-	query: string;
-	selfActionError: string;
-}
-
-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,
-	});
-}
-
-export function resolveModerationTargetEffect({
-	accountId,
-	query,
-	selfActionError,
-}: ResolveModerationTargetParams) {
-	return Effect.gen(function* () {
-		const db = yield* trySync(() => getNativeDb());
-		const resolvedAccountId = accountId || getDefaultAccountId(db);
-		const accountHandle = yield* trySync(() =>
-			getAccountHandle(db, resolvedAccountId),
-		);
-		if (!accountHandle) {
-			return yield* Effect.fail(
-				new Error(`Unknown account: ${resolvedAccountId}`),
-			);
-		}
-		const normalizedQuery = normalizeProfileQuery(query);
-		if (normalizedQuery.toLowerCase() === accountHandle.toLowerCase()) {
-			return yield* Effect.fail(new Error(selfActionError));
-		}
-
-		const resolved = yield* resolveProfileEffect(query);
-		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 accountProfile = yield* trySync(() =>
-			account
-				? (db
-						.prepare("select id from profiles where handle = ? limit 1")
-						.get(account.handle.replace(/^@/, "")) as
-						| { id: string }
-						| undefined)
-				: undefined,
-		);
-		const accountExternalUserId =
-			account?.external_user_id ?? getExternalUserId(accountProfile?.id ?? "");
-		if (
-			resolved.profile.handle.toLowerCase() === accountHandle.toLowerCase() ||
-			(accountProfile?.id && resolved.profile.id === accountProfile.id) ||
-			(accountExternalUserId &&
-				resolved.externalUserId === accountExternalUserId)
-		) {
-			return yield* Effect.fail(new Error(selfActionError));
-		}
-
-		return {
-			db,
-			resolved,
-			resolvedAccountId,
-			accountIdentity: {
-				id: resolvedAccountId,
-				handle: account?.handle ?? accountHandle,
-				externalUserId: accountExternalUserId || null,
-			},
-			actionQuery:
-				resolved.externalUserId ?? resolved.profile.handle ?? normalizedQuery,
-		};
-	});
-}
-
-export function resolveModerationTarget(params: ResolveModerationTargetParams) {
-	return runEffectPromise(resolveModerationTargetEffect(params));
-}
-
-export function writeModerationRow(
-	db: Database,
-	table: "blocks" | "mutes",
-	accountId: string,
-	profileId: string,
-	createdAt: string,
-) {
-	db.prepare(
-		`
-    insert into ${table} (account_id, profile_id, source, created_at)
-    values (?, ?, 'manual', ?)
-    on conflict(account_id, profile_id) do update set
-      source = excluded.source,
-      created_at = excluded.created_at
-    `,
-	).run(accountId, profileId, createdAt);
-}
-
-export function deleteModerationRow(
-	db: Database,
-	table: "blocks" | "mutes",
-	accountId: string,
-	profileId: string,
-) {
-	db.prepare(
-		`delete from ${table} where account_id = ? and profile_id = ?`,
-	).run(accountId, profileId);
-}

package/src/lib/mutes-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 addMuteEffect(
-	accountId: string,
-	query: string,
-	options: ModerationActionOptions = {},
-) {
-	return Effect.gen(function* () {
-		const { db, resolved, resolvedAccountId, accountIdentity, actionQuery } =
-			yield* resolveModerationTargetEffect({
-				accountId,
-				query,
-				selfActionError: "Cannot mute the current account",
-			});
-		const transport = yield* tryPromise(() =>
-			runModerationAction({
-				action: "mute",
-				query: actionQuery,
-				targetUserId: resolved.externalUserId ?? undefined,
-				transport: options.transport,
-				expectedAccount: accountIdentity,
-			}),
-		);
-
-		if (!transport.ok) {
-			return {
-				ok: false,
-				action: "mute",
-				accountId: resolvedAccountId,
-				profile: resolved.profile,
-				transport,
-			};
-		}
-
-		const mutedAt = new Date().toISOString();
-		yield* trySync(() =>
-			writeModerationRow(
-				db,
-				"mutes",
-				resolvedAccountId,
-				resolved.profile.id,
-				mutedAt,
-			),
-		);
-
-		return {
-			ok: true,
-			action: "mute",
-			accountId: resolvedAccountId,
-			mutedAt,
-			profile: resolved.profile,
-			transport,
-		};
-	});
-}
-
-export function addMute(
-	accountId: string,
-	query: string,
-	options: ModerationActionOptions = {},
-) {
-	return runEffectPromise(addMuteEffect(accountId, query, options));
-}
-
-export function recordMuteEffect(accountId: string, query: string) {
-	return Effect.gen(function* () {
-		const { db, resolved, resolvedAccountId } =
-			yield* resolveModerationTargetEffect({
-				accountId,
-				query,
-				selfActionError: "Cannot mute the current account",
-			});
-
-		const mutedAt = new Date().toISOString();
-		yield* trySync(() =>
-			writeModerationRow(
-				db,
-				"mutes",
-				resolvedAccountId,
-				resolved.profile.id,
-				mutedAt,
-			),
-		);
-
-		return {
-			ok: true,
-			action: "record-mute",
-			accountId: resolvedAccountId,
-			mutedAt,
-			profile: resolved.profile,
-		};
-	});
-}
-
-export function recordMute(accountId: string, query: string) {
-	return runEffectPromise(recordMuteEffect(accountId, query));
-}
-
-export function removeMuteEffect(
-	accountId: string,
-	query: string,
-	options: ModerationActionOptions = {},
-) {
-	return Effect.gen(function* () {
-		const { db, resolved, resolvedAccountId, accountIdentity, actionQuery } =
-			yield* resolveModerationTargetEffect({
-				accountId,
-				query,
-				selfActionError: "Cannot mute the current account",
-			});
-		const transport = yield* tryPromise(() =>
-			runModerationAction({
-				action: "unmute",
-				query: actionQuery,
-				targetUserId: resolved.externalUserId ?? undefined,
-				transport: options.transport,
-				expectedAccount: accountIdentity,
-			}),
-		);
-
-		if (!transport.ok) {
-			return {
-				ok: false,
-				action: "unmute",
-				accountId: resolvedAccountId,
-				profile: resolved.profile,
-				transport,
-			};
-		}
-
-		yield* trySync(() =>
-			deleteModerationRow(db, "mutes", resolvedAccountId, resolved.profile.id),
-		);
-
-		return {
-			ok: true,
-			action: "unmute",
-			accountId: resolvedAccountId,
-			profile: resolved.profile,
-			transport,
-		};
-	});
-}
-
-export function removeMute(
-	accountId: string,
-	query: string,
-	options: ModerationActionOptions = {},
-) {
-	return runEffectPromise(removeMuteEffect(accountId, query, options));
-}

package/src/lib/mutes.ts

@@ -1,84 +0,0 @@
-import { getNativeDb } from "./db";
-import { toProfile } from "./moderation-target";
-import type { BlockItem } from "./types";
-
-export {
-	addMute,
-	addMuteEffect,
-	recordMute,
-	recordMuteEffect,
-	removeMute,
-	removeMuteEffect,
-} from "./mutes-write";
-
-export interface MuteItem {
-	accountId: string;
-	accountHandle: string;
-	source: string;
-	mutedAt: string;
-	profile: BlockItem["profile"];
-}
-
-export function listMutes({
-	account,
-	search,
-	limit = 50,
-}: {
-	account?: string;
-	search?: string;
-	limit?: number;
-} = {}): MuteItem[] {
-	const db = getNativeDb();
-	const params: Array<string | number> = [];
-	let where = "where 1 = 1";
-
-	if (account && account !== "all") {
-		where += " and m.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
-        m.account_id,
-        a.handle as account_handle,
-        m.source,
-        m.created_at as muted_at,
-        p.id,
-        p.handle,
-        p.display_name,
-        p.bio,
-        p.followers_count,
-        p.avatar_hue,
-        p.avatar_url,
-        p.created_at
-      from mutes m
-      join accounts a on a.id = m.account_id
-      join profiles p on p.id = m.profile_id
-      ${where}
-      order by m.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),
-		mutedAt: String(row.muted_at),
-		profile: toProfile(row),
-	}));
-}

package/src/lib/ndjson-stream.ts

@@ -1,106 +0,0 @@
-import { Effect } from "effect";
-import { runEffectBackground } from "./effect-runtime";
-
-const encoder = new TextEncoder();
-const HEARTBEAT_INTERVAL_MS = 15_000;
-const STREAM_START_DELAY_MS = 25;
-const FLUSH_PADDING = `${" ".repeat(16_384)}\n`;
-
-export function createEffectNdjsonResponse<Event>({
-	request,
-	initialEvents = [],
-	run,
-	errorEvent,
-}: {
-	request: Request;
-	initialEvents?: Event[];
-	run: (context: {
-		signal: AbortSignal;
-		emit: (event: Event) => void;
-	}) => Effect.Effect<unknown, unknown>;
-	errorEvent: (error: unknown) => Event;
-}) {
-	let abortStream: (() => void) | undefined;
-
-	return new Response(
-		new ReadableStream<Uint8Array>({
-			cancel() {
-				abortStream?.();
-			},
-			start(controller) {
-				const abortController = new AbortController();
-				let closed = false;
-				let heartbeat: ReturnType<typeof setInterval> | undefined;
-				let startTimer: ReturnType<typeof setTimeout> | undefined;
-
-				const cleanup = () => {
-					request.signal.removeEventListener("abort", abort);
-					if (heartbeat !== undefined) clearInterval(heartbeat);
-					if (startTimer !== undefined) clearTimeout(startTimer);
-				};
-				const abort = () => {
-					if (closed) return;
-					closed = true;
-					cleanup();
-					abortController.abort();
-				};
-				const close = () => {
-					if (closed) return;
-					closed = true;
-					cleanup();
-					abortController.abort();
-					controller.close();
-				};
-				const enqueue = (value: string) => {
-					if (closed) return;
-					try {
-						controller.enqueue(encoder.encode(value));
-					} catch {
-						abort();
-					}
-				};
-				const emit = (event: Event) => {
-					enqueue(`${JSON.stringify(event)}\n`);
-				};
-
-				request.signal.addEventListener("abort", abort, { once: true });
-				abortStream = abort;
-				if (request.signal.aborted) {
-					abort();
-					controller.close();
-					return;
-				}
-				for (const event of initialEvents) emit(event);
-				enqueue(FLUSH_PADDING);
-				heartbeat = setInterval(
-					() => enqueue(FLUSH_PADDING),
-					HEARTBEAT_INTERVAL_MS,
-				);
-
-				startTimer = setTimeout(() => {
-					if (closed) return;
-					try {
-						runEffectBackground(run({ signal: abortController.signal, emit }), {
-							onSuccess: close,
-							onFailure: (error) => {
-								emit(errorEvent(error));
-								close();
-							},
-						});
-					} catch (error) {
-						emit(errorEvent(error));
-						close();
-					}
-				}, STREAM_START_DELAY_MS);
-			},
-		}),
-		{
-			headers: {
-				"cache-control": "no-store, no-transform",
-				"content-encoding": "identity",
-				"content-type": "application/x-ndjson; charset=utf-8",
-				"x-accel-buffering": "no",
-			},
-		},
-	);
-}