feat: Proxy `getRecord` requests to the user's PDS after DID resolution instead of a central AppView endpoint.

src/api/repo/record/read.rs

···
     let record_cid_str: String = match record_row {
         Ok(Some(row)) => row.record_cid,
         _ => {
-             let appview_endpoint = std::env::var("BSKY_APPVIEW_ENDPOINT")
-                .unwrap_or_else(|_| "https://api.bsky.app".to_string());
+            let did = if input.repo.starts_with("did:") {
+                input.repo.clone()
+            } else {
+                info!("Resolving handle {} to DID for P2P proxy", input.repo);
+                match crate::handle::resolve_handle(&input.repo).await {
+                    Ok(d) => d,
+                    Err(e) => {
+                        error!("Failed to resolve handle {}: {}", input.repo, e);
+                        return (
+                            StatusCode::NOT_FOUND,
+                            Json(json!({"error": "RepoNotFound", "message": "Could not resolve handle"})),
+                        )
+                            .into_response();
+                    }
+                }
+            };
+
+            let resolved_service = match state.did_resolver.resolve_did(&did).await {
+                Some(s) => s,
+                None => {
+                    error!("Failed to resolve PDS for DID {}", did);
+                    return (
+                        StatusCode::NOT_FOUND,
+                        Json(json!({"error": "RepoNotFound", "message": "Could not resolve DID service endpoint"})),
+                    )
+                        .into_response();
+                }
+            };
+
             let mut url = format!(
                 "{}/xrpc/com.atproto.repo.getRecord?repo={}&collection={}&rkey={}",
-                appview_endpoint.trim_end_matches('/'),
+                resolved_service.url.trim_end_matches('/'),
                 urlencoding::encode(&input.repo),
                 urlencoding::encode(&input.collection),
                 urlencoding::encode(&input.rkey)
···
                 url.push_str(&format!("&cid={}", urlencoding::encode(cid)));
             }
             info!(
-                "Record not found locally (user exists). Proxying getRecord for {} to AppView: {}",
-                input.repo, url
+                "Record not found locally. Proxying getRecord for {} (DID: {}) to PDS: {}",
+                input.repo, did, url
             );
+
             match proxy_client().get(&url).send().await {
                 Ok(resp) => {
                     let status = resp.status();
                     let body = match resp.bytes().await {
                         Ok(b) => b,
                         Err(e) => {
-                            error!("Error reading AppView proxy response: {:?}", e);
+                            error!("Error reading upstream PDS response: {:?}", e);
                             return (
                                 StatusCode::BAD_GATEWAY,
                                 Json(json!({
                                     "error": "UpstreamFailure",
-                                    "message": "Error reading upstream response from AppView"
+                                    "message": "Error reading upstream response"
                                 })),
                             )
                                 .into_response();
···
                         });
                 }
                 Err(e) => {
-                    error!("Error proxying request to AppView: {:?}", e);
+                    error!("Error proxying request to upstream PDS: {:?}", e);
                     return (
                         StatusCode::BAD_GATEWAY,
                         Json(json!({
                             "error": "UpstreamFailure",
-                            "message": "Failed to reach AppView"
+                            "message": "Failed to reach upstream PDS"
                         })),
                     )
                         .into_response();