birdclaw 0.1.0

package/src/lib/blocks-write.ts

@@ -0,0 +1,118 @@
+import { runModerationAction } from "./actions-transport";
+import {
+	deleteModerationRow,
+	type ModerationActionOptions,
+	resolveModerationTarget,
+	writeModerationRow,
+} from "./moderation-write";
+
+export async function addBlock(
+	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,
+		transport: options.transport,
+	});
+
+	if (!transport.ok) {
+		return {
+			ok: false,
+			action: "block",
+			accountId: resolvedAccountId,
+			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 async function recordBlock(accountId: string, query: string) {
+	const { db, resolved, resolvedAccountId } = await resolveModerationTarget({
+		accountId,
+		query,
+		selfActionError: "Cannot block the current account",
+	});
+
+	const blockedAt = new Date().toISOString();
+	writeModerationRow(
+		db,
+		"blocks",
+		resolvedAccountId,
+		resolved.profile.id,
+		blockedAt,
+	);
+
+	return {
+		ok: true,
+		action: "record-block",
+		accountId: resolvedAccountId,
+		blockedAt,
+		profile: resolved.profile,
+	};
+}
+
+export async function removeBlock(
+	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,
+		transport: options.transport,
+	});
+
+	if (!transport.ok) {
+		return {
+			ok: false,
+			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,
+	};
+}

package/src/lib/blocks.ts

@@ -0,0 +1,326 @@
+import type Database from "better-sqlite3";
+import { getNativeDb } from "./db";
+import {
+	getAccountHandle,
+	getDefaultAccountId,
+	toProfile,
+} from "./moderation-target";
+import type {
+	BlockItem,
+	BlockListResponse,
+	BlockSearchItem,
+	XurlMentionUser,
+} from "./types";
+import { upsertProfileFromXUser } from "./x-profile";
+import { listBlockedUsers, lookupAuthenticatedUser } from "./xurl";
+
+export { addBlock, recordBlock, removeBlock } from "./blocks-write";
+
+function remoteBlockSyncDisabled() {
+	return process.env.BIRDCLAW_DISABLE_LIVE_WRITES === "1";
+}
+
+function upsertRemoteBlock(
+	db: Database.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.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 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(/^@/, "") : "";
+		const accountHandle = getAccountHandle(db, resolvedAccountId);
+
+		if (!sourceUserId) {
+			return {
+				ok: false,
+				accountId: resolvedAccountId,
+				synced: false,
+				syncedCount: 0,
+				transport: {
+					ok: false,
+					output:
+						"xurl block sync unavailable without an authenticated account",
+				},
+			};
+		}
+
+		if (accountHandle && sourceUsername && accountHandle !== sourceUsername) {
+			return {
+				ok: false,
+				accountId: resolvedAccountId,
+				synced: false,
+				syncedCount: 0,
+				transport: {
+					ok: false,
+					output: `xurl is authenticated as @${sourceUsername}, not @${accountHandle}`,
+				},
+			};
+		}
+
+		let nextToken: string | null = null;
+		let pageCount = 0;
+
+		do {
+			const page = await listBlockedUsers(sourceUserId, nextToken ?? undefined);
+			const mergeRemotePage = db.transaction(() => {
+				for (const user of page.items) {
+					const resolved = upsertProfileFromXUser(db, user as XurlMentionUser);
+					remoteProfileIds.push(resolved.profile.id);
+					upsertRemoteBlock(
+						db,
+						resolvedAccountId,
+						resolved.profile.id,
+						blockedAt,
+					);
+				}
+			});
+			mergeRemotePage();
+			nextToken = page.nextToken;
+			pageCount += 1;
+		} while (nextToken && pageCount < 20);
+
+		const pruneMergedBlocks = db.transaction(() => {
+			pruneRemoteBlocks(db, resolvedAccountId, remoteProfileIds);
+		});
+		pruneMergedBlocks();
+
+		return {
+			ok: true,
+			accountId: resolvedAccountId,
+			synced: true,
+			syncedCount: remoteProfileIds.length,
+			transport: {
+				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",
+			},
+		};
+	}
+}

package/src/lib/config.ts

@@ -0,0 +1,152 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export interface BirdclawPaths {
+	rootDir: string;
+	dbPath: string;
+	mediaOriginalsDir: string;
+	mediaThumbsDir: string;
+	configPath: string;
+}
+
+export type MentionsDataSource = "birdclaw" | "xurl" | "bird";
+export type ActionsTransport = "auto" | "bird" | "xurl";
+
+export interface BirdclawConfig {
+	mentions?: {
+		dataSource?: MentionsDataSource;
+		birdCommand?: string;
+	};
+	actions?: {
+		transport?: ActionsTransport;
+	};
+}
+
+let cachedPaths: BirdclawPaths | undefined;
+let cachedConfig: BirdclawConfig | undefined;
+
+export function getBirdclawPaths(): BirdclawPaths {
+	if (cachedPaths) {
+		return cachedPaths;
+	}
+
+	const rootDir =
+		process.env.BIRDCLAW_HOME?.trim() || path.join(os.homedir(), ".birdclaw");
+
+	cachedPaths = {
+		rootDir,
+		dbPath: path.join(rootDir, "birdclaw.sqlite"),
+		mediaOriginalsDir: path.join(rootDir, "media", "originals"),
+		mediaThumbsDir: path.join(rootDir, "media", "thumbs"),
+		configPath: path.join(rootDir, "config.json"),
+	};
+
+	return cachedPaths;
+}
+
+function parseConfigFile(configPath: string): BirdclawConfig {
+	if (!existsSync(configPath)) {
+		return {};
+	}
+
+	const raw = readFileSync(configPath, "utf8").trim();
+	if (!raw) {
+		return {};
+	}
+
+	const parsed = JSON.parse(raw) as BirdclawConfig;
+	return parsed && typeof parsed === "object" ? parsed : {};
+}
+
+export function getBirdclawConfig(): BirdclawConfig {
+	if (cachedConfig) {
+		return cachedConfig;
+	}
+
+	const configPath =
+		process.env.BIRDCLAW_CONFIG?.trim() || getBirdclawPaths().configPath;
+	cachedConfig = parseConfigFile(configPath);
+	return cachedConfig;
+}
+
+export function resolveMentionsDataSource(
+	requestedMode?: string,
+): MentionsDataSource {
+	if (
+		requestedMode === "birdclaw" ||
+		requestedMode === "xurl" ||
+		requestedMode === "bird"
+	) {
+		return requestedMode;
+	}
+
+	const envMode = process.env.BIRDCLAW_MENTIONS_DATA_SOURCE?.trim();
+	if (envMode === "birdclaw" || envMode === "xurl" || envMode === "bird") {
+		return envMode;
+	}
+
+	const configMode = getBirdclawConfig().mentions?.dataSource;
+	if (
+		configMode === "birdclaw" ||
+		configMode === "xurl" ||
+		configMode === "bird"
+	) {
+		return configMode;
+	}
+
+	return "birdclaw";
+}
+
+export function resolveActionsTransport(
+	requestedMode?: string,
+): ActionsTransport {
+	if (
+		requestedMode === "auto" ||
+		requestedMode === "bird" ||
+		requestedMode === "xurl"
+	) {
+		return requestedMode;
+	}
+
+	const envMode = process.env.BIRDCLAW_ACTIONS_TRANSPORT?.trim();
+	if (envMode === "auto" || envMode === "bird" || envMode === "xurl") {
+		return envMode;
+	}
+
+	const configMode = getBirdclawConfig().actions?.transport;
+	if (configMode === "auto" || configMode === "bird" || configMode === "xurl") {
+		return configMode;
+	}
+
+	return "auto";
+}
+
+export function getBirdCommand() {
+	const envCommand = process.env.BIRDCLAW_BIRD_COMMAND?.trim();
+	if (envCommand) {
+		return envCommand;
+	}
+
+	const configuredCommand = getBirdclawConfig().mentions?.birdCommand?.trim();
+	if (configuredCommand) {
+		return configuredCommand;
+	}
+
+	return path.join(os.homedir(), "Projects", "bird", "bird");
+}
+
+export function ensureBirdclawDirs(): BirdclawPaths {
+	const paths = getBirdclawPaths();
+
+	mkdirSync(paths.rootDir, { recursive: true });
+	mkdirSync(paths.mediaOriginalsDir, { recursive: true });
+	mkdirSync(paths.mediaThumbsDir, { recursive: true });
+
+	return paths;
+}
+
+export function resetBirdclawPathsForTests() {
+	cachedPaths = undefined;
+	cachedConfig = undefined;
+}