import { useState, useEffect } from "react";

const API_URL = import.meta.env.PUBLIC_API_URL || "https://api.stevedylan.dev";

interface GuestAuthState {

	authenticated: boolean;

	did?: string;

	handle?: string;

	isGuest?: boolean;

	loading: boolean;

}

interface GuestReplyProps {

	atUri: string;

	postTitle: string;

	onReplyPosted?: () => void;

}

export function GuestReply({

	atUri,

	postTitle,

	onReplyPosted,

}: GuestReplyProps) {

	const [authState, setAuthState] = useState<GuestAuthState>({

		authenticated: false,

		loading: true,

	});

	const [replyContent, setReplyContent] = useState("");

	const [isSubmitting, setIsSubmitting] = useState(false);

	const [error, setError] = useState<string | null>(null);

	const [success, setSuccess] = useState(false);

	useEffect(() => {

		checkAuthStatus();

	}, []);

	const checkAuthStatus = async () => {

		try {

			const response = await fetch(`${API_URL}/guest-auth/status`, {

				credentials: "include",

			});

			const data = await response.json();

			setAuthState({

				authenticated: data.authenticated,

				did: data.did,

				handle: data.handle,

				isGuest: data.isGuest,

				loading: false,

			});

		} catch (error) {

			console.error("Failed to check auth status:", error);

			setAuthState({ authenticated: false, loading: false });

		}

	};

	const handleLogin = () => {

		// Pass current URL as returnTo parameter

		const currentPath = window.location.pathname;

		window.location.href = `${API_URL}/guest-auth/login?returnTo=${encodeURIComponent(currentPath)}`;

	};

	const handleLogout = async () => {

		try {

			await fetch(`${API_URL}/guest-auth/logout`, {

				method: "POST",

				credentials: "include",

			});

			setAuthState({ authenticated: false, loading: false });

			setReplyContent("");

		} catch (error) {

			console.error("Logout failed:", error);

		}

	};

	const handleReply = async (e: React.FormEvent) => {

		e.preventDefault();

		if (!replyContent.trim()) {

			setError("Reply content is required");

			return;

		}

		setIsSubmitting(true);

		setError(null);

		setSuccess(false);

		try {

			const response = await fetch(`${API_URL}/now/reply`, {

				method: "POST",

				credentials: "include",

				headers: {

					"Content-Type": "application/json",

				},

				body: JSON.stringify({

					parentUri: atUri,

					content: replyContent.trim(),

				}),

			});

			const data = await response.json();

			if (!response.ok) {

				throw new Error(data.error || "Failed to post reply");

			}

			setReplyContent("");

			setSuccess(true);

			setTimeout(() => setSuccess(false), 5000);

			// Notify parent to refresh replies list

			onReplyPosted?.();

		} catch (err) {

			setError(err instanceof Error ? err.message : "Failed to post reply");

		} finally {

			setIsSubmitting(false);

		}

	};

	const emailSubject = encodeURIComponent(`Re: ${postTitle}`);

	const mailtoLink = `mailto:contact@stevedylan.dev?subject=${emailSubject}`;

	if (authState.loading) {

		return (

			<div className="mt-8 p-6 border border-gray-700 rounded-lg">

				<p className="text-sm text-gray-400">Loading...</p>

			</div>

		);

	}

	return (

		<div className="mt-8 space-y-4">

			<h2 className="text-xl font-bold">Reply</h2>

			{!authState.authenticated ? (

				<div className="space-y-4">

					<p className="text-sm text-gray-400">

						Sign in with your ATProto account to reply, or send an email.

					</p>

					<div className="flex gap-3 flex-wrap">

						<button

							onClick={handleLogin}

							className="px-4 py-2 border border-white hover:bg-white hover:text-black transition-colors text-sm"

						>

							Sign in with ATProto

						</button>

						<a

							href={mailtoLink}

							className="px-4 py-2 border border-white hover:bg-white hover:text-black transition-colors text-sm inline-block"

						>

							Reply via Email

						</a>

					</div>

				</div>

			) : (

				<div className="space-y-4">

					<div className="flex items-center justify-between">

						<p className="text-sm text-gray-400">

							Signed in as {authState.handle || authState.did}

						</p>

						<button

							onClick={handleLogout}

							className="text-xs text-gray-500 hover:text-gray-300 transition-colors"

						>

							Sign out

						</button>

					</div>

					<form onSubmit={handleReply} className="space-y-3">

						<textarea

							value={replyContent}

							onChange={(e) => setReplyContent(e.target.value)}

							placeholder="Write your reply..."

							rows={4}

							className="w-full bg-transparent p-3 border border-white text-white resize-none"

							disabled={isSubmitting}

						/>

						<div className="flex items-center justify-between">

							<div className="flex items-center gap-3">

								{error && <span className="text-sm text-red-500">{error}</span>}

								{success && (

									<span className="text-sm text-green-500">

										Reply posted successfully!

									</span>

								)}

							</div>

							<div className="flex gap-3">

								<a

									href={mailtoLink}

									className="text-sm text-gray-500 hover:text-gray-300 transition-colors"

								>

									or email

								</a>

								<button

									type="submit"

									disabled={isSubmitting || !replyContent.trim()}

									className="px-4 py-2 border border-white hover:bg-white hover:text-black disabled:opacity-50 disabled:cursor-not-allowed transition-colors text-sm"

								>

									{isSubmitting ? "Posting..." : "Post Reply"}

								</button>

							</div>

						</div>

					</form>

				</div>

			)}

		</div>

	);

}

import { useState } from "react";

import { ReplyList } from "./ReplyList";

import { GuestReply } from "./GuestReply";

interface ReplyContainerProps {

	atUri: string;

	postTitle: string;

}

export function ReplyContainer({ atUri, postTitle }: ReplyContainerProps) {

	const [refreshKey, setRefreshKey] = useState(0);

	const handleReplyPosted = () => {

		// Increment key to force ReplyList to re-fetch

		setRefreshKey((prev) => prev + 1);

	};

	return (

		<>

			<ReplyList key={refreshKey} atUri={atUri} />

			<GuestReply

				atUri={atUri}

				postTitle={postTitle}

				onReplyPosted={handleReplyPosted}

			/>

		</>

	);

}

import { useState, useEffect } from "react";

const API_URL = import.meta.env.PUBLIC_API_URL || "https://api.stevedylan.dev";

interface Author {

	did: string;

	handle: string;

	displayName?: string;

	avatar?: string;

}

interface Reply {

	uri: string;

	cid: string;

	author: Author;

	record: {

		text: string;

		createdAt: string;

	};

	indexedAt: string;

	replyCount: number;

	likeCount: number;

}

interface ReplyListProps {

	atUri: string;

}

export function ReplyList({ atUri }: ReplyListProps) {

	const [replies, setReplies] = useState<Reply[]>([]);

	const [loading, setLoading] = useState(true);

	const [error, setError] = useState<string | null>(null);

	useEffect(() => {

		fetchReplies();

	}, [atUri]);

	const fetchReplies = async () => {

		try {

			setLoading(true);

			setError(null);

			const encodedUri = encodeURIComponent(atUri);

			const response = await fetch(`${API_URL}/now/replies/${encodedUri}`);

			if (!response.ok) {

				throw new Error("Failed to fetch replies");

			}

			const data = await response.json();

			setReplies(data.replies || []);

		} catch (err) {

			console.error("Error fetching replies:", err);

			setError(err instanceof Error ? err.message : "Failed to load replies");

		} finally {

			setLoading(false);

		}

	};

	const formatDate = (dateString: string) => {

		const date = new Date(dateString);

		const now = new Date();

		const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000);

		if (diffInSeconds < 60) {

			return `${diffInSeconds}s ago`;

		} else if (diffInSeconds < 3600) {

			return `${Math.floor(diffInSeconds / 60)}m ago`;

		} else if (diffInSeconds < 86400) {

			return `${Math.floor(diffInSeconds / 3600)}h ago`;

		} else if (diffInSeconds < 604800) {

			return `${Math.floor(diffInSeconds / 86400)}d ago`;

		} else {

			return date.toLocaleDateString();

		}

	};

	if (loading) {

		return (

			<div className="mt-8">

				<h3 className="text-lg font-bold mb-4">Replies</h3>

				<p className="text-sm text-gray-400">Loading replies...</p>

			</div>

		);

	}

	if (error) {

		return (

			<div className="mt-8">

				<h3 className="text-lg font-bold mb-4">Replies</h3>

				<p className="text-sm text-red-500">{error}</p>

			</div>

		);

	}

	if (replies.length === 0) {

		return (

			<div className="mt-8">

				<h3 className="text-lg font-bold mb-4">Replies</h3>

				<p className="text-sm text-gray-400">

					No replies yet. Be the first to reply!

				</p>

			</div>

		);

	}

	return (

		<div className="mt-8">

			<h3 className="text-lg font-bold mb-4">Replies ({replies.length})</h3>

			<div className="space-y-4">

				{replies.map((reply) => (

					<div

						key={reply.uri}

						className="border border-gray-700 rounded-lg p-4 hover:border-gray-600 transition-colors"

					>

						<div className="flex items-start gap-3">

							{reply.author.avatar ? (

								<img

									src={reply.author.avatar}

									alt={reply.author.handle}

									className="w-10 h-10 rounded-full"

								/>

							) : (

								<div className="w-10 h-10 rounded-full bg-gray-700 flex items-center justify-center">

									<span className="text-gray-400 text-sm">

										{reply.author.handle.charAt(0).toUpperCase()}

									</span>

								</div>

							)}

							<div className="flex-1 min-w-0">

								<div className="flex items-center gap-2 flex-wrap">

									<span className="font-semibold text-sm">

										{reply.author.displayName || reply.author.handle}

									</span>

									<a

										href={`https://bsky.app/profile/${reply.author.handle}`}

										target="_blank"

										rel="noopener noreferrer"

										className="text-xs text-gray-400 hover:text-gray-300"

									>

										@{reply.author.handle}

									</a>

									<span className="text-xs text-gray-500">

										{formatDate(reply.record.createdAt)}

									</span>

								</div>

								<p className="mt-2 text-sm whitespace-pre-wrap break-words">

									{reply.record.text}

								</p>

								<div className="mt-3 flex items-center gap-4 text-xs text-gray-500">

									{reply.replyCount > 0 && (

										<span>{reply.replyCount} replies</span>

									)}

									{reply.likeCount > 0 && <span>{reply.likeCount} likes</span>}

									<a

										href={`https://bsky.app/profile/${reply.author.handle}/post/${reply.uri.split("/").pop()}`}

										target="_blank"

										rel="noopener noreferrer"

										className="hover:text-gray-300"

									>

										View on Bluesky

									</a>

								</div>

							</div>

						</div>

					</div>

				))}

			</div>

		</div>

	);

}

import { ReplyContainer } from "@/components/post/ReplyContainer";

				<ReplyContainer client:load atUri={atUri} postTitle={title} />

import { home, now, auth, guestAuth } from "./routes";

app.route("/guest-auth", guestAuth);

import { Hono } from "hono";

import { generateDPoPKeyPair } from "../lib/dpop";

import {

	fetchOAuthMetadata,

	generatePKCE,

	generateState,

	sendPAR,

	buildAuthorizationUrl,

	exchangeCodeForTokens,

	refreshAccessToken,

} from "../lib/oauth";

import {

	storeAuthState,

	getAndDeleteAuthState,

	createSession,

	getSession,

	deleteSession,

	getSessionIdFromCookie,

	setSessionCookie,

	clearSessionCookie,

	isTokenExpired,

	updateSession,

} from "../lib/session";

interface Env {

	SESSIONS: KVNamespace;

	ALLOWED_DID: string;

	PDS_URL: string;

	CLIENT_URL: string;

	API_URL: string;

}

const guestAuth = new Hono<{ Bindings: Env }>();

// OAuth client metadata endpoint for guests

guestAuth.get("/client-metadata.json", (c) => {

	const clientId = `${c.env.API_URL}/guest-auth/client-metadata.json`;

	const redirectUri = `${c.env.API_URL}/guest-auth/callback`;

	return c.json({

		client_id: clientId,

		client_name: "Steve Dylan's Blog (Guest)",

		client_uri: c.env.API_URL,

		redirect_uris: [redirectUri],

		grant_types: ["authorization_code", "refresh_token"],

		response_types: ["code"],

		scope: "atproto transition:generic",

		token_endpoint_auth_method: "none",

		application_type: "web",

		dpop_bound_access_tokens: true,

	});

});

// Start OAuth login flow for guests

guestAuth.get("/login", async (c) => {

	try {

		const clientId = `${c.env.API_URL}/guest-auth/client-metadata.json`;

		const redirectUri = `${c.env.API_URL}/guest-auth/callback`;

		// Get optional return URL from query params

		const returnTo = c.req.query("returnTo") || "/now";

		// Fetch OAuth metadata from PDS

		const metadata = await fetchOAuthMetadata(c.env.PDS_URL);

		// Generate PKCE and state

		const pkce = await generatePKCE();

		const state = generateState();

		// Generate DPoP keypair

		const dpopKeyPair = await generateDPoPKeyPair();

		// Send PAR request

		const { parResponse, dpopNonce } = await sendPAR(

			metadata,

			clientId,

			redirectUri,

			state,

			pkce,

			dpopKeyPair,

			"atproto transition:generic",

		);

		// Store auth state in KV with returnTo URL

		await storeAuthState(

			c.env.SESSIONS,

			state,

			pkce.codeVerifier,

			dpopKeyPair,

			dpopNonce,

		);

		// Store returnTo separately to retrieve after callback

		await c.env.SESSIONS.put(

			`guest_return:${state}`,

			returnTo,

			{ expirationTtl: 600 }, // 10 minutes

		);

		// Build authorization URL and redirect

		const authUrl = buildAuthorizationUrl(

			metadata,

			parResponse.request_uri,

			clientId,

		);

		return c.redirect(authUrl);

	} catch (error) {

		console.error("Guest login error:", error);

		return c.redirect(`${c.env.CLIENT_URL}/now?error=login_failed`);

	}

});

// OAuth callback handler for guests

guestAuth.get("/callback", async (c) => {

	try {

		const code = c.req.query("code");

		const state = c.req.query("state");

		const error = c.req.query("error");

		const errorDescription = c.req.query("error_description");

		// Handle OAuth errors

		if (error) {

			console.error("OAuth error:", error, errorDescription);

			return c.redirect(

				`${c.env.CLIENT_URL}/now?error=${encodeURIComponent(error)}`,

			);

		}

		if (!code || !state) {

			return c.redirect(`${c.env.CLIENT_URL}/now?error=missing_params`);

		}

		// Retrieve and validate auth state

		const authState = await getAndDeleteAuthState(c.env.SESSIONS, state);

		if (!authState) {

			return c.redirect(`${c.env.CLIENT_URL}/now?error=invalid_state`);

		}

		// Get return URL

		const returnTo =

			(await c.env.SESSIONS.get(`guest_return:${state}`)) || "/now";

		await c.env.SESSIONS.delete(`guest_return:${state}`);

		const clientId = `${c.env.API_URL}/guest-auth/client-metadata.json`;

		const redirectUri = `${c.env.API_URL}/guest-auth/callback`;

		// Fetch OAuth metadata

		const metadata = await fetchOAuthMetadata(c.env.PDS_URL);

		// Exchange code for tokens

		const { tokenResponse, dpopNonce } = await exchangeCodeForTokens(

			metadata,

			code,

			authState.codeVerifier,

			clientId,

			redirectUri,

			authState.dpopKeyPair,

			authState.dpopNonce,

		);

		// For guests, allow any ATProto account (no DID check)

		// Create session with a "guest_" prefix to differentiate from admin sessions

		const sessionId = await createSession(

			c.env.SESSIONS,

			tokenResponse.access_token,

			tokenResponse.refresh_token || "",

			authState.dpopKeyPair,

			dpopNonce,

			tokenResponse.sub,

			tokenResponse.expires_in,

		);

		// Prefix session ID to mark as guest

		const guestSessionId = `guest_${sessionId}`;

		// Store the original session ID mapping

		await c.env.SESSIONS.put(

			`guest_session:${guestSessionId}`,

			sessionId,

			{ expirationTtl: 60 * 60 * 24 * 14 }, // 14 days

		);

		// Set session cookie and redirect to return URL

		setSessionCookie(c, guestSessionId, c.env.CLIENT_URL);

		return c.redirect(`${c.env.CLIENT_URL}${returnTo}`);

	} catch (error) {

		console.error("Guest callback error:", error);

		return c.redirect(`${c.env.CLIENT_URL}/now?error=callback_failed`);

	}

});

// Logout endpoint for guests

guestAuth.post("/logout", async (c) => {

	const sessionId = getSessionIdFromCookie(c);

	if (sessionId?.startsWith("guest_")) {

		// Get original session ID

		const originalSessionId = await c.env.SESSIONS.get(

			`guest_session:${sessionId}`,

		);

		if (originalSessionId) {

			await deleteSession(c.env.SESSIONS, originalSessionId);

			await c.env.SESSIONS.delete(`guest_session:${sessionId}`);

		}

	}

	clearSessionCookie(c, c.env.CLIENT_URL);

	return c.json({ success: true });

});

// Check auth status for guests

guestAuth.get("/status", async (c) => {

	const sessionId = getSessionIdFromCookie(c);

	if (!sessionId || !sessionId.startsWith("guest_")) {

		return c.json({ authenticated: false });

	}

	// Get original session ID

	const originalSessionId = await c.env.SESSIONS.get(

		`guest_session:${sessionId}`,

	);

	if (!originalSessionId) {

		clearSessionCookie(c, c.env.CLIENT_URL);

		return c.json({ authenticated: false });

	}

	const sessionData = await getSession(c.env.SESSIONS, originalSessionId);

	if (!sessionData) {

		clearSessionCookie(c, c.env.CLIENT_URL);

		await c.env.SESSIONS.delete(`guest_session:${sessionId}`);

		return c.json({ authenticated: false });

	}

	const { session, dpopKeyPair } = sessionData;

	// Check if token needs refresh

	if (isTokenExpired(session.expiresAt) && session.refreshToken) {

		try {

			const metadata = await fetchOAuthMetadata(c.env.PDS_URL);

			const clientId = `${c.env.API_URL}/guest-auth/client-metadata.json`;

			const { tokenResponse, dpopNonce } = await refreshAccessToken(

				metadata,

				session.refreshToken,

				clientId,

				dpopKeyPair,

				session.dpopNonce,

			);

			// Update session with new tokens

			await updateSession(

				c.env.SESSIONS,

				originalSessionId,

				tokenResponse.access_token,

				tokenResponse.refresh_token || session.refreshToken,

				dpopNonce,

				tokenResponse.expires_in,

			);

			return c.json({

				authenticated: true,

				did: session.did,

				handle: session.handle,

				isGuest: true,

			});

		} catch (error) {

			console.error("Token refresh failed:", error);

			await deleteSession(c.env.SESSIONS, originalSessionId);

			await c.env.SESSIONS.delete(`guest_session:${sessionId}`);

			clearSessionCookie(c, c.env.CLIENT_URL);

			return c.json({ authenticated: false });

		}

	}

	return c.json({

		authenticated: true,

		did: session.did,

		handle: session.handle,

		isGuest: true,

	});

});

export default guestAuth;

export { default as guestAuth } from "./guest-auth";

// Helper function to get session for both admin and guest users

async function getAnySession(c: any, sessionId: string) {

	if (sessionId.startsWith("guest_")) {

		// Guest session

		const originalSessionId = await c.env.SESSIONS.get(

			`guest_session:${sessionId}`,

		);

		if (!originalSessionId) return null;

		return await getSession(c.env.SESSIONS, originalSessionId);

	} else {

		// Admin session

		return await getSession(c.env.SESSIONS, sessionId);

	}

}

	}

});

// Create a reply to a post (for guests)

now.post("/reply", async (c) => {

	try {

		// Get session from cookie

		const sessionId = getSessionIdFromCookie(c);

		if (!sessionId) {

			return c.json({ error: "Not authenticated" }, 401);

		}

		const sessionData = await getAnySession(c, sessionId);

		if (!sessionData) {

			return c.json({ error: "Session not found" }, 401);

		}

		let { session, dpopKeyPair } = sessionData;

		// Refresh token if expired

		if (isTokenExpired(session.expiresAt) && session.refreshToken) {

			const metadata = await fetchOAuthMetadata(c.env.PDS_URL);

			const clientId = sessionId.startsWith("guest_")

				? `${c.env.API_URL}/guest-auth/client-metadata.json`

				: `${c.env.API_URL}/auth/client-metadata.json`;

			const { tokenResponse, dpopNonce } = await refreshAccessToken(

				metadata,

				session.refreshToken,

				clientId,

				dpopKeyPair,

				session.dpopNonce,

			);

			// Get the actual session ID for update

			const actualSessionId = sessionId.startsWith("guest_")

				? (await c.env.SESSIONS.get(`guest_session:${sessionId}`)) || ""

				: sessionId;

			// Update session with new tokens

			await updateSession(

				c.env.SESSIONS,

				actualSessionId,

				tokenResponse.access_token,

				tokenResponse.refresh_token || session.refreshToken,

				dpopNonce,

				tokenResponse.expires_in,

			);

			// Update local session object

			session.accessToken = tokenResponse.access_token;

			session.dpopNonce = dpopNonce;

		}

		// Parse request body

		const body = await c.req.json<{

			parentUri: string;

			content: string;

		}>();

		if (!body.parentUri || body.parentUri.trim().length === 0) {

			return c.json({ error: "Parent URI is required" }, 400);

		}

		if (!body.content || body.content.trim().length === 0) {

			return c.json({ error: "Content is required" }, 400);

		}

		// Fetch the parent post to get its CID

		const getRecordUrl =

			`${c.env.PDS_URL}/xrpc/com.atproto.repo.getRecord?` +

			new URLSearchParams({

				repo: body.parentUri.split("/")[2], // Extract DID from URI

				collection: body.parentUri.split("/")[3], // Extract collection

				rkey: body.parentUri.split("/")[4], // Extract rkey

			});

		const parentResponse = await fetch(getRecordUrl);

		if (!parentResponse.ok) {

			console.error("Failed to fetch parent post");

			return c.json({ error: "Failed to fetch parent post" }, 400);

		}

		const parentData = await parentResponse.json();

		const parentCid = parentData.cid;

		// Create the reply record using app.bsky.feed.post lexicon

		const createRecordUrl = `${c.env.PDS_URL}/xrpc/com.atproto.repo.createRecord`;

		const replyRecord = {

			repo: session.did,

			collection: "app.bsky.feed.post",

			record: {

				$type: "app.bsky.feed.post",

				text: body.content.trim(),

				createdAt: new Date().toISOString(),

				reply: {

					root: {

						uri: body.parentUri,

						cid: parentCid,

					},

					parent: {

						uri: body.parentUri,

						cid: parentCid,

					},

				},

			},

		};

		// Make request with DPoP

		const makeRequest = async (nonce?: string): Promise<Response> => {

			const dpopProof = await createDPoPProof(dpopKeyPair, {

				method: "POST",

				url: createRecordUrl,

				nonce: nonce || session.dpopNonce,

				accessToken: session.accessToken,

			});

			return fetch(createRecordUrl, {

				method: "POST",

				headers: {

					"Content-Type": "application/json",

					Authorization: `DPoP ${session.accessToken}`,

					DPoP: dpopProof,

				},

				body: JSON.stringify(replyRecord),

			});

		};

		let response = await makeRequest();

		// Handle DPoP nonce requirement

		if (response.status === 401) {

			const newNonce = extractDPoPNonce(response);

			if (newNonce) {

				// Retry with new nonce

				response = await makeRequest(newNonce);

				// Get the actual session ID for update

				const actualSessionId = sessionId.startsWith("guest_")

					? (await c.env.SESSIONS.get(`guest_session:${sessionId}`)) || ""

					: sessionId;

				// Update session with new nonce

				await updateSession(

					c.env.SESSIONS,

					actualSessionId,

					session.accessToken,

					session.refreshToken,

					newNonce,

					Math.floor((session.expiresAt - Date.now()) / 1000),

				);

			}

		}

		if (!response.ok) {

			const errorData = await response.json();

			console.error("Failed to create reply:", errorData);

			return c.json(

				{ error: "Failed to create reply", details: errorData },

				response.status as 400 | 401 | 403 | 500,

			);

		}

		const result = (await response.json()) as { uri: string; cid: string };

		return c.json({ success: true, uri: result.uri, cid: result.cid });

	} catch (error) {

		console.error("Error creating reply:", error);

		return c.json({ error: "Internal server error" }, 500);

	}

});

// Get replies for a post

now.get("/replies/:uri", async (c) => {

	try {

		const encodedUri = c.req.param("uri");

		const uri = decodeURIComponent(encodedUri);

		// Use app.bsky.feed.getPostThread to fetch the post and its replies

		const threadUrl = `${PDS_URL}/xrpc/app.bsky.feed.getPostThread?uri=${encodeURIComponent(uri)}`;

		const response = await fetch(threadUrl);

		if (!response.ok) {

			console.error("Failed to fetch thread:", response.status);

			return c.json({ replies: [] });

		}

		const data = await response.json();

		// Extract replies from the thread

		const replies: any[] = [];

		if (data.thread?.replies && Array.isArray(data.thread.replies)) {

			for (const reply of data.thread.replies) {

				if (reply.post) {

					replies.push({

						uri: reply.post.uri,

						cid: reply.post.cid,

						author: {

							did: reply.post.author.did,

							handle: reply.post.author.handle,

							displayName: reply.post.author.displayName,

							avatar: reply.post.author.avatar,

						},

						record: reply.post.record,

						indexedAt: reply.post.indexedAt,

						replyCount: reply.post.replyCount || 0,

						likeCount: reply.post.likeCount || 0,

					});

				}

			}

		}

		return c.json({ replies });

	} catch (error) {

		console.error("Error fetching replies:", error);

		return c.json({ replies: [] });