birdclaw 0.1.0

package/src/components/TimelineCard.tsx

@@ -0,0 +1,118 @@
+import { formatCompactNumber, formatShortTimestamp } from "#/lib/present";
+import type { TimelineItem } from "#/lib/types";
+import {
+	actionButtonClass,
+	cardFooterClass,
+	cardHeaderClass,
+	contentCardClass,
+	cx,
+	identityBlockClass,
+	identityRowClass,
+	linkPreviewCardClass,
+	metaStackClass,
+	metricRowClass,
+	mutedDotClass,
+	pillAlertClass,
+	pillClass,
+	pillSoftClass,
+	timestampClass,
+} from "#/lib/ui";
+import { AvatarChip } from "./AvatarChip";
+import { EmbeddedTweetCard } from "./EmbeddedTweetCard";
+import { ProfilePreview } from "./ProfilePreview";
+import { TweetMediaGrid } from "./TweetMediaGrid";
+import { TweetRichText } from "./TweetRichText";
+
+function getVisibleUrlCards(item: TimelineItem) {
+	const quotedUrl = item.quotedTweet ? item.quotedTweet.id : null;
+	return (item.entities.urls ?? []).filter((entry) => {
+		if (!item.quotedTweet) return true;
+		return !entry.expandedUrl.includes(quotedUrl ?? "");
+	});
+}
+
+export function TimelineCard({
+	item,
+	onReply,
+}: {
+	item: TimelineItem;
+	onReply: (tweetId: string) => void;
+}) {
+	return (
+		<article className={contentCardClass}>
+			<header className={cardHeaderClass}>
+				<div className={identityBlockClass}>
+					<AvatarChip
+						avatarUrl={item.author.avatarUrl}
+						hue={item.author.avatarHue}
+						name={item.author.displayName}
+						profileId={item.author.id}
+					/>
+					<div>
+						<ProfilePreview profile={item.author}>
+							<div className={identityRowClass}>
+								<strong>{item.author.displayName}</strong>
+								<span>@{item.author.handle}</span>
+								<span className={mutedDotClass} />
+								<span>
+									{formatCompactNumber(item.author.followersCount)} followers
+								</span>
+							</div>
+						</ProfilePreview>
+					</div>
+				</div>
+				<div className={metaStackClass}>
+					<span
+						className={cx(
+							pillClass,
+							item.isReplied ? pillSoftClass : pillAlertClass,
+						)}
+					>
+						{item.isReplied ? "replied" : "needs reply"}
+					</span>
+					<span className={timestampClass}>
+						{formatShortTimestamp(item.createdAt)}
+					</span>
+				</div>
+			</header>
+			<TweetRichText entities={item.entities} text={item.text} />
+			<TweetMediaGrid items={item.media} />
+			{item.replyToTweet ? (
+				<EmbeddedTweetCard item={item.replyToTweet} label="In reply to" />
+			) : null}
+			{item.quotedTweet ? (
+				<EmbeddedTweetCard item={item.quotedTweet} label="Quoted tweet" />
+			) : null}
+			{getVisibleUrlCards(item).map((entry) => (
+				<a
+					key={entry.expandedUrl}
+					className={linkPreviewCardClass}
+					href={entry.expandedUrl}
+					rel="noreferrer"
+					target="_blank"
+				>
+					<strong>{entry.title ?? entry.displayUrl}</strong>
+					<span className="text-[var(--ink-soft)]">
+						{entry.description ?? entry.displayUrl}
+					</span>
+					<span className={timestampClass}>{entry.displayUrl}</span>
+				</a>
+			))}
+			<footer className={cardFooterClass}>
+				<div className={metricRowClass}>
+					<span>{formatCompactNumber(item.likeCount)} likes</span>
+					<span>{item.mediaCount} media</span>
+					<span>{item.bookmarked ? "bookmarked" : "not bookmarked"}</span>
+					<span>{item.accountHandle}</span>
+				</div>
+				<button
+					className={actionButtonClass}
+					onClick={() => onReply(item.id)}
+					type="button"
+				>
+					Reply
+				</button>
+			</footer>
+		</article>
+	);
+}

package/src/components/TweetMediaGrid.tsx

@@ -0,0 +1,39 @@
+import type { TweetMediaItem } from "#/lib/types";
+import { tweetMediaGridClass, tweetMediaTileClass } from "#/lib/ui";
+
+export function TweetMediaGrid({ items }: { items: TweetMediaItem[] }) {
+	if (items.length === 0) {
+		return null;
+	}
+
+	return (
+		<div className={tweetMediaGridClass(Math.min(items.length, 4))}>
+			{items.slice(0, 4).map((item, index) => (
+				<a
+					key={item.url + String(index)}
+					className={tweetMediaTileClass(index, Math.min(items.length, 4))}
+					href={item.url}
+					rel="noreferrer"
+					target="_blank"
+				>
+					{item.type === "image" ? (
+						<img
+							alt={item.altText ?? `Tweet media ${String(index + 1)}`}
+							className="tweet-media-image block size-full object-cover"
+							loading="lazy"
+							src={item.thumbnailUrl ?? item.url}
+						/>
+					) : (
+						<span className="tweet-media-fallback grid min-h-40 place-items-center font-semibold text-[var(--ink-soft)]">
+							{item.type === "video"
+								? "Video"
+								: item.type === "gif"
+									? "GIF"
+									: "Media"}
+						</span>
+					)}
+				</a>
+			))}
+		</div>
+	);
+}

package/src/components/TweetRichText.tsx

@@ -0,0 +1,85 @@
+import { Fragment } from "react";
+import { collectTweetSegments } from "#/lib/tweet-render";
+import type { TweetEntities } from "#/lib/types";
+import {
+	bodyCopyClass,
+	tweetHashtagClass,
+	tweetLinkClass,
+	tweetMentionClass,
+} from "#/lib/ui";
+import { ProfilePreview } from "./ProfilePreview";
+
+export function TweetRichText({
+	text,
+	entities,
+	className = "body-copy",
+}: {
+	text: string;
+	entities: TweetEntities;
+	className?: string;
+}) {
+	const segments = collectTweetSegments(entities);
+	let cursor = 0;
+
+	return (
+		<p className={className === "body-copy" ? bodyCopyClass : className}>
+			{segments.map((segment, index) => {
+				if (
+					segment.start < cursor ||
+					segment.end <= segment.start ||
+					segment.end > text.length
+				) {
+					return null;
+				}
+
+				const prefix = text.slice(cursor, segment.start);
+				cursor = segment.end;
+
+				let node = (
+					<Fragment key={`segment-${String(index)}`}>
+						{text.slice(segment.start, segment.end)}
+					</Fragment>
+				);
+				if (segment.kind === "mention" && segment.profile) {
+					node = (
+						<ProfilePreview
+							key={`segment-${String(index)}`}
+							profile={segment.profile}
+						>
+							<span className={tweetMentionClass}>@{segment.username}</span>
+						</ProfilePreview>
+					);
+				} else if (segment.kind === "url") {
+					node = (
+						<a
+							key={`segment-${String(index)}`}
+							className={tweetLinkClass}
+							href={segment.expandedUrl}
+							rel="noreferrer"
+							target="_blank"
+						>
+							{segment.displayUrl}
+						</a>
+					);
+				} else if (segment.kind === "hashtag") {
+					node = (
+						<span
+							className={tweetHashtagClass}
+							key={`segment-${String(index)}`}
+						>
+							#{segment.tag}
+						</span>
+					);
+				}
+
+				return (
+					<Fragment key={`piece-${String(index)}`}>
+						{prefix}
+						{node}
+					</Fragment>
+				);
+			})}
+			{text.slice(cursor)}
+		</p>
+	);
+}

package/src/lib/actions-transport.ts

@@ -0,0 +1,173 @@
+import {
+	blockUserViaBird,
+	muteUserViaBird,
+	readBirdStatusViaBird,
+	unblockUserViaBird,
+	unmuteUserViaBird,
+} from "./bird-actions";
+import { type ActionsTransport, resolveActionsTransport } from "./config";
+import type {
+	ModerationAction,
+	ModerationActionTransportResult,
+} from "./types";
+import {
+	blockUserViaXurl,
+	lookupAuthenticatedUser,
+	muteUserViaXurl,
+	unblockUserViaXurl,
+	unmuteUserViaXurl,
+} from "./xurl";
+
+export type ActionTransportResult = ModerationActionTransportResult;
+
+interface RunActionParams {
+	action: ModerationAction;
+	query: string;
+	targetUserId?: string;
+	transport?: string;
+}
+
+function normalizeFailure(transport: "bird" | "xurl", output: string) {
+	return `${transport}: ${output}`;
+}
+
+async function runBirdAction(
+	action: ModerationAction,
+	query: string,
+): Promise<ActionTransportResult> {
+	const result =
+		action === "block"
+			? await blockUserViaBird(query)
+			: action === "unblock"
+				? await unblockUserViaBird(query)
+				: action === "mute"
+					? await muteUserViaBird(query)
+					: await unmuteUserViaBird(query);
+
+	return {
+		...result,
+		transport: "bird",
+	};
+}
+
+function getVerifyExpectation(action: ModerationAction) {
+	return action === "block" || action === "unblock"
+		? {
+				field: "blocking" as const,
+				expected: action === "block",
+			}
+		: {
+				field: "muting" as const,
+				expected: action === "mute",
+			};
+}
+
+async function runXurlAction(
+	action: ModerationAction,
+	query: string,
+	targetUserId?: string,
+): Promise<ActionTransportResult> {
+	if (!targetUserId) {
+		return {
+			ok: false,
+			output: "missing target user id for xurl transport",
+			transport: "xurl",
+		};
+	}
+
+	const sourceUser = await lookupAuthenticatedUser();
+	const sourceUserId =
+		sourceUser && typeof sourceUser.id === "string" ? sourceUser.id : "";
+	if (!sourceUserId) {
+		return {
+			ok: false,
+			output: "xurl authenticated user unavailable",
+			transport: "xurl",
+		};
+	}
+
+	const result =
+		action === "block"
+			? await blockUserViaXurl(sourceUserId, targetUserId)
+			: action === "unblock"
+				? await unblockUserViaXurl(sourceUserId, targetUserId)
+				: action === "mute"
+					? await muteUserViaXurl(sourceUserId, targetUserId)
+					: await unmuteUserViaXurl(sourceUserId, targetUserId);
+
+	if (!result.ok) {
+		return {
+			...result,
+			transport: "xurl",
+		};
+	}
+
+	const status = await readBirdStatusViaBird(query);
+	const { field: verifyField, expected: expectedValue } =
+		getVerifyExpectation(action);
+	const actualValue =
+		status && typeof status[verifyField] === "boolean"
+			? Boolean(status[verifyField])
+			: null;
+
+	if (actualValue === null) {
+		return {
+			ok: false,
+			output: `${result.output}\nxurl verify unavailable from bird status`,
+			transport: "xurl",
+		};
+	}
+
+	if (actualValue !== expectedValue) {
+		return {
+			ok: false,
+			output: `${result.output}\nxurl verify mismatch ${verifyField}=${String(actualValue)}`,
+			transport: "xurl",
+		};
+	}
+
+	return {
+		ok: true,
+		output: `${result.output}\nverified ${verifyField}=${String(actualValue)}`,
+		transport: "xurl",
+	};
+}
+
+export async function runModerationAction({
+	action,
+	query,
+	targetUserId,
+	transport,
+}: RunActionParams): Promise<ActionTransportResult> {
+	const requestedTransport = resolveActionsTransport(transport);
+	if (requestedTransport === "bird") {
+		return runBirdAction(action, query);
+	}
+	if (requestedTransport === "xurl") {
+		return runXurlAction(action, query, targetUserId);
+	}
+
+	const birdResult = await runBirdAction(action, query);
+	if (birdResult.ok) {
+		return birdResult;
+	}
+
+	const xurlResult = await runXurlAction(action, query, targetUserId);
+	if (xurlResult.ok) {
+		return {
+			...xurlResult,
+			output: `${xurlResult.output}\nfalling back after ${normalizeFailure("bird", birdResult.output)}`,
+		};
+	}
+
+	return {
+		ok: false,
+		output: [
+			normalizeFailure("bird", birdResult.output),
+			normalizeFailure("xurl", xurlResult.output),
+		].join("\n"),
+		transport: xurlResult.transport,
+	};
+}
+
+export type { ActionsTransport };

package/src/lib/archive-finder.ts

@@ -0,0 +1,128 @@
+import { exec } from "node:child_process";
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import type { ArchiveCandidate } from "./types";
+
+const execAsync = promisify(exec);
+const ARCHIVE_NAME_PATTERNS = [
+	/^twitter-.*\.zip$/i,
+	/^x-.*\.zip$/i,
+	/archive.*\.zip$/i,
+];
+
+function formatFileSize(bytes: number): string {
+	const units = ["B", "KB", "MB", "GB"];
+	let value = bytes;
+	let index = 0;
+
+	while (value >= 1024 && index < units.length - 1) {
+		value /= 1024;
+		index += 1;
+	}
+
+	return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[index]}`;
+}
+
+function formatRelativeDate(date: Date): string {
+	const days = Math.floor(
+		(Date.now() - date.getTime()) / (1000 * 60 * 60 * 24),
+	);
+	if (days <= 0) return "Today";
+	if (days === 1) return "Yesterday";
+	if (days < 7) return `${days} days ago`;
+	if (days < 30) return `${Math.floor(days / 7)} weeks ago`;
+	if (days < 365) return `${Math.floor(days / 30)} months ago`;
+	return `${Math.floor(days / 365)} years ago`;
+}
+
+async function getCandidate(
+	filePath: string,
+): Promise<ArchiveCandidate | null> {
+	try {
+		const stats = await fs.stat(filePath);
+		if (!stats.isFile() || stats.size < 1024 * 1024) {
+			return null;
+		}
+
+		return {
+			path: filePath,
+			name: path.basename(filePath),
+			size: stats.size,
+			sizeFormatted: formatFileSize(stats.size),
+			modifiedTime: stats.mtime.toISOString(),
+			dateFormatted: formatRelativeDate(stats.mtime),
+		};
+	} catch {
+		return null;
+	}
+}
+
+async function searchDirectory(
+	directoryPath: string,
+): Promise<ArchiveCandidate[]> {
+	if (!existsSync(directoryPath)) {
+		return [];
+	}
+
+	const entries = await fs.readdir(directoryPath);
+	const matches = entries.filter((entry) =>
+		ARCHIVE_NAME_PATTERNS.some((pattern) => pattern.test(entry)),
+	);
+
+	const candidates = await Promise.all(
+		matches.map((entry) => getCandidate(path.join(directoryPath, entry))),
+	);
+
+	return candidates.filter((item) => item !== null);
+}
+
+export async function findArchives(): Promise<ArchiveCandidate[]> {
+	if (process.platform !== "darwin") {
+		return [];
+	}
+
+	const found = new Map<string, ArchiveCandidate>();
+	const downloads = await searchDirectory(path.join(homedir(), "Downloads"));
+
+	for (const candidate of downloads) {
+		found.set(candidate.path, candidate);
+	}
+
+	const queries = [
+		'kMDItemDisplayName == "twitter-*.zip"',
+		'kMDItemDisplayName == "x-*.zip"',
+		'kMDItemDisplayName == "*archive*.zip" && kMDItemKind == "Zip archive"',
+	];
+
+	for (const query of queries) {
+		try {
+			const { stdout } = await execAsync(`mdfind -onlyin ~ '${query}'`, {
+				timeout: 5000,
+			});
+
+			const paths = stdout
+				.split("\n")
+				.map((item) => item.trim())
+				.filter((item) => item.length > 0 && item.endsWith(".zip"));
+
+			const candidates = await Promise.all(
+				paths.map((filePath) => getCandidate(filePath)),
+			);
+			for (const candidate of candidates) {
+				if (candidate) {
+					found.set(candidate.path, candidate);
+				}
+			}
+		} catch {
+			// Best-effort only.
+		}
+	}
+
+	return [...found.values()].sort(
+		(left, right) =>
+			new Date(right.modifiedTime).getTime() -
+			new Date(left.modifiedTime).getTime(),
+	);
+}