birdclaw 0.8.2 → 0.8.4

package/src/lib/config.ts

@@ -1,224 +0,0 @@
-import {
-	accessSync,
-	constants,
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	writeFileSync,
-} 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" | "auto" | "xurl" | "bird";
-export type ActionsTransport = "auto" | "bird" | "xurl";
-
-export interface BirdclawConfig {
-	mentions?: {
-		dataSource?: MentionsDataSource;
-		birdCommand?: string;
-	};
-	actions?: {
-		transport?: ActionsTransport;
-	};
-	backup?: {
-		repoPath?: string;
-		remote?: string;
-		autoSync?: boolean;
-		staleAfterSeconds?: number;
-	};
-}
-
-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;
-}
-
-function getConfigPath() {
-	return process.env.BIRDCLAW_CONFIG?.trim() || getBirdclawPaths().configPath;
-}
-
-export function writeBirdclawConfig(config: BirdclawConfig) {
-	const configPath = getConfigPath();
-	mkdirSync(path.dirname(configPath), { recursive: true });
-	writeFileSync(configPath, `${JSON.stringify(config, null, "\t")}\n`, "utf8");
-	cachedConfig = config;
-	return configPath;
-}
-
-export function setActionsTransport(transport: ActionsTransport) {
-	const config = getBirdclawConfig();
-	const nextConfig: BirdclawConfig = {
-		...config,
-		actions: {
-			...config.actions,
-			transport,
-		},
-	};
-	const configPath = writeBirdclawConfig(nextConfig);
-	return { configPath, transport };
-}
-
-export function resolveMentionsDataSource(
-	requestedMode?: string,
-): MentionsDataSource {
-	if (
-		requestedMode === "birdclaw" ||
-		requestedMode === "auto" ||
-		requestedMode === "xurl" ||
-		requestedMode === "bird"
-	) {
-		return requestedMode;
-	}
-
-	const envMode = process.env.BIRDCLAW_MENTIONS_DATA_SOURCE?.trim();
-	if (
-		envMode === "birdclaw" ||
-		envMode === "auto" ||
-		envMode === "xurl" ||
-		envMode === "bird"
-	) {
-		return envMode;
-	}
-
-	const configMode = getBirdclawConfig().mentions?.dataSource;
-	if (
-		configMode === "birdclaw" ||
-		configMode === "auto" ||
-		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";
-}
-
-function findCommandOnPath(command: string) {
-	const pathValue = process.env.PATH;
-	if (!pathValue) {
-		return undefined;
-	}
-
-	for (const directory of pathValue.split(path.delimiter)) {
-		if (!directory) {
-			continue;
-		}
-		const candidate = path.join(directory, command);
-		try {
-			accessSync(candidate, constants.X_OK);
-			return candidate;
-		} catch {
-			continue;
-		}
-	}
-
-	return undefined;
-}
-
-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;
-	}
-
-	const pathCommand = findCommandOnPath("bird");
-	if (pathCommand) {
-		return pathCommand;
-	}
-
-	return "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;
-}

package/src/lib/conversation-surface.ts

@@ -1,205 +0,0 @@
-import { useCallback, useEffect, useSyncExternalStore } from "react";
-import type { ReactNode } from "react";
-import { Effect } from "effect";
-import type { EmbeddedTweet } from "#/lib/types";
-import { runEffectPromise } from "./effect-runtime";
-
-type ConversationStatus = "idle" | "loading" | "ready" | "error";
-
-interface ConversationRecord {
-	error: string | null;
-	items: EmbeddedTweet[];
-	status: ConversationStatus;
-}
-
-interface ConversationSurfaceSnapshot {
-	expandedTweetId: string | null;
-	records: ReadonlyMap<string, ConversationRecord>;
-}
-
-type Listener = () => void;
-
-const emptyRecord: ConversationRecord = {
-	error: null,
-	items: [],
-	status: "idle",
-};
-
-let snapshot: ConversationSurfaceSnapshot = {
-	expandedTweetId: null,
-	records: new Map(),
-};
-const listeners = new Set<Listener>();
-const inFlight = new Set<string>();
-let activeScopes = 0;
-let generation = 0;
-
-function emit() {
-	for (const listener of listeners) {
-		listener();
-	}
-}
-
-function setSnapshot(next: ConversationSurfaceSnapshot) {
-	snapshot = next;
-	emit();
-}
-
-function updateRecord(tweetId: string, record: ConversationRecord) {
-	const records = new Map(snapshot.records);
-	records.set(tweetId, record);
-	setSnapshot({ ...snapshot, records });
-}
-
-function subscribe(listener: Listener) {
-	listeners.add(listener);
-	return () => {
-		listeners.delete(listener);
-	};
-}
-
-function getSnapshot() {
-	return snapshot;
-}
-
-function fetchConversationItemsEffect(tweetId: string) {
-	return Effect.gen(function* () {
-		const response = yield* Effect.tryPromise({
-			try: () =>
-				fetch(`/api/conversation?tweetId=${encodeURIComponent(tweetId)}`),
-			catch: (error) => error,
-		});
-		const data = (yield* Effect.tryPromise({
-			try: () => response.json(),
-			catch: (error) => error,
-		})) as {
-			error?: string;
-			items?: EmbeddedTweet[];
-			ok?: boolean;
-		};
-		if (!response.ok || data.ok === false) {
-			return yield* Effect.fail(
-				new Error(data.error ?? "Conversation unavailable"),
-			);
-		}
-		return (data.items ?? []).filter(Boolean);
-	});
-}
-
-export function loadConversationEffect(
-	surfaceId: string,
-	tweetId = surfaceId,
-): Effect.Effect<void, never> {
-	return Effect.gen(function* () {
-		const current = snapshot.records.get(surfaceId);
-		if (current?.status === "ready" || inFlight.has(surfaceId)) {
-			return;
-		}
-
-		const loadGeneration = generation;
-		inFlight.add(surfaceId);
-		yield* Effect.gen(function* () {
-			updateRecord(surfaceId, {
-				error: null,
-				items: current?.items ?? [],
-				status: "loading",
-			});
-
-			const result = yield* fetchConversationItemsEffect(tweetId).pipe(
-				Effect.match({
-					onFailure: (error) => ({ error, ok: false as const }),
-					onSuccess: (items) => ({ items, ok: true as const }),
-				}),
-			);
-
-			if (loadGeneration !== generation) {
-				return;
-			}
-			if (result.ok) {
-				updateRecord(surfaceId, {
-					error: null,
-					items: result.items,
-					status: "ready",
-				});
-			} else {
-				updateRecord(surfaceId, {
-					error:
-						result.error instanceof Error
-							? result.error.message
-							: "Conversation unavailable",
-					items: [],
-					status: "error",
-				});
-			}
-		}).pipe(Effect.ensuring(Effect.sync(() => inFlight.delete(surfaceId))));
-	});
-}
-
-function loadConversation(surfaceId: string, tweetId = surfaceId) {
-	return runEffectPromise(loadConversationEffect(surfaceId, tweetId));
-}
-
-export function retainConversationSurfaceScope() {
-	activeScopes += 1;
-	return () => {
-		activeScopes = Math.max(0, activeScopes - 1);
-		if (activeScopes === 0) {
-			resetConversationSurface();
-		}
-	};
-}
-
-export function resetConversationSurface() {
-	generation += 1;
-	inFlight.clear();
-	setSnapshot({
-		expandedTweetId: null,
-		records: new Map(),
-	});
-}
-
-export function ConversationSurfaceScope({
-	children,
-}: {
-	children: ReactNode;
-}) {
-	useEffect(() => retainConversationSurfaceScope(), []);
-	return children;
-}
-
-export function useConversationSurface(surfaceId: string, tweetId = surfaceId) {
-	const currentSnapshot = useSyncExternalStore(
-		subscribe,
-		getSnapshot,
-		getSnapshot,
-	);
-	const record = currentSnapshot.records.get(surfaceId) ?? emptyRecord;
-	const isOpen = currentSnapshot.expandedTweetId === surfaceId;
-
-	const toggle = useCallback(() => {
-		const nextExpanded =
-			snapshot.expandedTweetId === surfaceId ? null : surfaceId;
-		setSnapshot({ ...snapshot, expandedTweetId: nextExpanded });
-		if (nextExpanded) {
-			void loadConversation(surfaceId, tweetId);
-		}
-	}, [surfaceId, tweetId]);
-
-	const prefetch = useCallback(() => {
-		const current = snapshot.records.get(surfaceId);
-		if (current?.status === "ready" || current?.status === "loading") {
-			return;
-		}
-		void loadConversation(surfaceId, tweetId);
-	}, [surfaceId, tweetId]);
-
-	return {
-		error: record.error,
-		isOpen,
-		items: record.items,
-		loading: record.status === "loading",
-		prefetch,
-		status: record.status,
-		toggle,
-	};
-}

package/src/lib/data-sources.ts

@@ -1,219 +0,0 @@
-import { Effect } from "effect";
-import { getAuthenticatedBirdAccountEffect } from "./bird";
-import { getNativeDb } from "./db";
-import { runEffectPromise } from "./effect-runtime";
-import type {
-	LiveDataSourceAccount,
-	LiveDataSourceCapability,
-	LiveDataSourcesResponse,
-	LiveDataSourceStatus,
-} from "./types";
-import {
-	getTransportStatusEffect,
-	lookupAuthenticatedOAuth2UserEffect,
-	readXurlOAuth2AccountsEffect,
-} from "./xurl";
-
-function errorMessage(error: unknown) {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function readLocalAccounts(): LiveDataSourceAccount[] {
-	const db = getNativeDb();
-	const rows = db
-		.prepare(
-			`
-      select id, handle, external_user_id, is_default
-      from accounts
-      order by is_default desc, lower(handle) asc
-      `,
-		)
-		.all() as Array<{
-		id: string;
-		handle: string;
-		external_user_id: string | null;
-		is_default: number;
-	}>;
-	return rows.map((row) => ({
-		id: row.external_user_id ?? row.id,
-		handle: row.handle,
-		username: row.handle.replace(/^@/, ""),
-		isDefault: row.is_default === 1,
-	}));
-}
-
-function getBirdclawStatusEffect(): Effect.Effect<LiveDataSourceStatus, never> {
-	return Effect.try({
-		try: () => readLocalAccounts(),
-		catch: (error) => error,
-	}).pipe(
-		Effect.map((accounts) => ({
-			source: "birdclaw" as const,
-			label: "Birdclaw local",
-			works: true,
-			installed: true,
-			status: "ok" as const,
-			detail:
-				accounts.length > 0
-					? `${accounts.length.toString()} local account${accounts.length === 1 ? "" : "s"}`
-					: "local database ready; no accounts imported yet",
-			accounts,
-		})),
-		Effect.catchAll((error) =>
-			Effect.succeed({
-				source: "birdclaw" as const,
-				label: "Birdclaw local",
-				works: false,
-				installed: true,
-				status: "error" as const,
-				detail: errorMessage(error),
-				accounts: [],
-			}),
-		),
-	);
-}
-
-function getBirdStatusEffect(): Effect.Effect<LiveDataSourceStatus, never> {
-	return getAuthenticatedBirdAccountEffect().pipe(
-		Effect.map((account) => ({
-			source: "bird" as const,
-			label: "bird",
-			works: true,
-			installed: true,
-			status: "ok" as const,
-			detail: `authenticated as @${account.username}`,
-			accounts: [
-				{
-					...(account.id ? { id: account.id } : {}),
-					username: account.username,
-					handle: `@${account.username}`,
-				},
-			],
-		})),
-		Effect.catchAll((error) =>
-			Effect.succeed({
-				source: "bird" as const,
-				label: "bird",
-				works: false,
-				status: "error" as const,
-				detail: errorMessage(error),
-				accounts: [],
-			}),
-		),
-	);
-}
-
-function getXurlStatusEffect(): Effect.Effect<LiveDataSourceStatus, never> {
-	return Effect.gen(function* () {
-		const transport = yield* getTransportStatusEffect();
-		const oauth2Accounts = yield* readXurlOAuth2AccountsEffect();
-		const authenticated = yield* lookupAuthenticatedOAuth2UserEffect().pipe(
-			Effect.catchAll(() => Effect.succeed(null)),
-		);
-		const authenticatedAccount =
-			authenticated && typeof authenticated === "object"
-				? ({
-						...(typeof authenticated.id === "string"
-							? { id: authenticated.id }
-							: {}),
-						...(typeof authenticated.username === "string"
-							? {
-									username: authenticated.username,
-									handle: `@${authenticated.username}`,
-								}
-							: {}),
-					} satisfies LiveDataSourceAccount)
-				: undefined;
-		const accounts: LiveDataSourceAccount[] = [
-			...(authenticatedAccount ? [authenticatedAccount] : []),
-			...oauth2Accounts,
-		];
-		const deduped = accounts.filter(
-			(account, index) =>
-				accounts.findIndex(
-					(candidate) =>
-						(candidate.app ?? "") === (account.app ?? "") &&
-						(candidate.username ?? candidate.handle ?? "") ===
-							(account.username ?? account.handle ?? ""),
-				) === index,
-		);
-		const works = transport.availableTransport === "xurl";
-		return {
-			source: "xurl" as const,
-			label: "xurl",
-			works,
-			installed: transport.installed,
-			status: works ? ("ok" as const) : ("warning" as const),
-			detail: transport.statusText,
-			accounts: deduped,
-		};
-	}).pipe(
-		Effect.catchAll((error) =>
-			Effect.succeed({
-				source: "xurl" as const,
-				label: "xurl",
-				works: false,
-				status: "error" as const,
-				detail: errorMessage(error),
-				accounts: [],
-			}),
-		),
-	);
-}
-
-const capabilities: LiveDataSourceCapability[] = [
-	{
-		key: "timeline",
-		label: "Home timeline",
-		primary: "xurl",
-		fallbacks: ["bird"],
-	},
-	{
-		key: "mentions",
-		label: "Mentions",
-		primary: "xurl",
-		fallbacks: ["bird", "birdclaw"],
-		notes: "bird fallback is skipped when a since/start cursor requires xurl.",
-	},
-	{
-		key: "search",
-		label: "Fresh search",
-		primary: "bird",
-		fallbacks: ["xurl", "birdclaw"],
-		notes: "dated searches require xurl.",
-	},
-	{
-		key: "dms",
-		label: "DMs",
-		primary: "xurl",
-		fallbacks: ["bird", "birdclaw"],
-		notes: "message requests require bird.",
-	},
-	{
-		key: "follow-graph",
-		label: "Followers / following",
-		primary: "bird",
-		fallbacks: ["xurl", "birdclaw"],
-	},
-];
-
-export function getLiveDataSourcesEffect(): Effect.Effect<
-	LiveDataSourcesResponse,
-	never
-> {
-	return Effect.gen(function* () {
-		const sources = yield* Effect.all(
-			[getBirdclawStatusEffect(), getBirdStatusEffect(), getXurlStatusEffect()],
-			{ concurrency: "unbounded" },
-		);
-		return {
-			generatedAt: new Date().toISOString(),
-			sources,
-			capabilities,
-		};
-	});
-}
-
-export function getLiveDataSources(): Promise<LiveDataSourcesResponse> {
-	return runEffectPromise(getLiveDataSourcesEffect());
-}