BlueskyClient.cs

using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Sockets;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using dnproto.repo;
using dnproto.log;
using dnproto.uri;

namespace dnproto.ws;

/// <summary>
/// Entry point for interacting with this SDK.
/// </summary>
public class BlueskyClient
{
    public static IDnProtoLogger Logger = new Logger();

    #region ACTOR

    /// <summary>
    /// Finds a bunch of info for a handle. (did, didDoc, pds)
    ///
    /// Attempts the following steps:
    ///
    ///     1. Resolve handle to did (dns or http).
    ///     2. Resolve did to didDoc. (did:plc or did:web)
    ///     3. Resolve didDoc to pds.
    ///     4. Get handle from diddoc (if not already known).
    ///
    /// </summary>
    /// <param name="handle"></param>
    /// <returns></returns>
    public static ActorInfo ResolveActorInfo(string actor, ActorQueryOptions? queryOptions = null)
    {
        //
        // If you don't specify options, you'll get the default options.
        //
        if (queryOptions is null) queryOptions = new ActorQueryOptions();

        //
        // Return value
        //
        var ret = new ActorInfo();
        ret.Actor = actor;

        //
        // For logging
        //
        StringBuilder logLine = new StringBuilder($"[ACTOR] [BSKY] actor={actor} all={queryOptions.All} bsky={queryOptions.ResolveHandleViaBluesky} dns={queryOptions.ResolveHandleViaDns} http={queryOptions.ResolveHandleViaHttp} didDoc={queryOptions.ResolveDidDoc}");
        DateTime startTime = DateTime.UtcNow;

        try
        {
            Logger.LogTrace($"ResolveActorInfo: actor: {actor}");
            if (string.IsNullOrEmpty(actor))
            {
                Logger.LogTrace("ResolveActorInfo: actor is null or empty. Exiting.");
                return ret;
            }

            //
            // 1. Resolve handle to did. Call all three methods (bluesky api, dns, http).
            //
            if(actor.StartsWith("did:", StringComparison.Ordinal))
            {
                if (!IsValidDid(actor))
                {
                    Logger.LogWarning($"[SECURITY] Rejected invalid DID during actor resolution: {actor}");
                    return ret;
                }

                ret.Did = actor;
                Logger.LogTrace("Actor is already a did.");
            }
            else
            {
                string normalizedHandle = actor.ToLowerInvariant();

                if (!IsValidHandle(normalizedHandle))
                {
                    Logger.LogWarning($"[SECURITY] Rejected invalid handle during actor resolution: {actor}");
                    return ret;
                }

                ret.Handle = normalizedHandle;
                Logger.LogTrace("Actor is not a did, resolving to did.");

                if (queryOptions.All || queryOptions.ResolveHandleViaBluesky)
                {
                    ret.Did_Bsky = ResolveHandleToDid_ViaBlueskyApi(normalizedHandle);
                }

                if (queryOptions.All || queryOptions.ResolveHandleViaDns)
                {                
                    ret.Did_Dns = ResolveHandleToDid_ViaDns(normalizedHandle);
                }
                
                if (queryOptions.All || queryOptions.ResolveHandleViaHttp)
                {
                    ret.Did_Http = ResolveHandleToDid_ViaHttp(normalizedHandle);
                }

                ret.Did = ret.Did_Bsky ?? ret.Did_Dns ?? ret.Did_Http;

                logLine.Append($" did={ret.Did}");
            }

            if (string.IsNullOrEmpty(ret.Did) || !ret.Did.StartsWith("did:")) return ret;

            if (!IsValidDid(ret.Did))
            {
                Logger.LogWarning($"[SECURITY] Rejected invalid DID syntax during actor resolution: actor={actor} did={ret.Did}");
                return ret;
            }

            if (!ret.Did.StartsWith("did:plc:", StringComparison.Ordinal)
                && !ret.Did.StartsWith("did:web:", StringComparison.Ordinal))
            {
                Logger.LogWarning($"[SECURITY] Rejected unsupported DID method during actor resolution: actor={actor} did={ret.Did}");
                return ret;
            }


            //
            // 2. Resolve did to didDoc. (did:plc or did:web)
            //
            if (queryOptions.All || queryOptions.ResolveDidDoc)
            {
                ret.DidDoc = ResolveDidToDidDoc(ret.Did);
                if (string.IsNullOrEmpty(ret.DidDoc)) return ret;

                logLine.Append($" didDocLength={ret.DidDoc?.Length}");
            }

            Logger.LogTrace("didDoc length: " + ret.DidDoc?.Length);


            //
            // 3. Resolve didDoc to pds.
            //
            if(string.IsNullOrEmpty(ret.DidDoc) == false)
            {
                ret.Pds = BlueskyClient.ResolveDidDocToPds(ret.DidDoc);
                if (string.IsNullOrEmpty(ret.Pds)) return ret;
                ret.Pds = ret.Pds.Replace("https://", "");
                logLine.Append($" pds={ret.Pds}");
            }


            //
            // 4. Get handle from diddoc
            //
            if(string.IsNullOrEmpty(ret.DidDoc) == false)
            {
                JsonNode? didDocJson = JsonNode.Parse(ret.DidDoc);

                if(string.IsNullOrEmpty(ret.Handle))
                {
                    string? handleFromDidDoc = null;
                    handleFromDidDoc = didDocJson?["alsoKnownAs"]?.AsArray()?.FirstOrDefault()?.ToString()?.Replace("at://", "")?.Split('/')?[0];
                    if (!string.IsNullOrEmpty(handleFromDidDoc))
                    {
                        string normalizedHandle = handleFromDidDoc.ToLowerInvariant();
                        if (IsValidHandle(normalizedHandle))
                        {
                            ret.Handle = normalizedHandle;
                        }
                        else
                        {
                            Logger.LogWarning($"[SECURITY] Ignored invalid handle extracted from DID document: actor={actor} did={ret.Did} handle={handleFromDidDoc}");
                        }
                    }
                }


                //
                // 5. Get public key from diddoc
                //
                if (string.IsNullOrEmpty(ret.PublicKeyMultibase))
                {
                    foreach (var verificationMethod in didDocJson?["verificationMethod"]?.AsArray() ?? new JsonArray())
                    {
                        if (verificationMethod == null) continue;
                        var vmId = verificationMethod["id"]?.ToString();
                        if (vmId != null && vmId.EndsWith("#atproto"))
                        {
                            ret.PublicKeyMultibase = verificationMethod["publicKeyMultibase"]?.ToString();
                            break;
                        }
                    }
                }
            }


            //
            // return
            //
            return ret;
        }
        finally
        {
            DateTime endTime = DateTime.UtcNow;
            TimeSpan duration = endTime - startTime;
            logLine.Append($" [{duration.TotalMilliseconds:F2}ms]");
            Logger.LogInfo(logLine.ToString());
        }
    }


    /// <summary>
    /// Resolves a did to a didDoc.
    /// For did:plc, go to the plc directory. 
    /// For did:web, resolve the doc via HTTP at the .well-known endpoint.
    /// </summary>
    /// <param name="did">The did to resolve.</param>
    /// <returns>The resolved didDoc or null if not found.</returns>
    public static string? ResolveDidToDidDoc(string? did)
    {
        if(did == null) return null;

        string? didDoc = null;
        if (did.StartsWith("did:plc:", StringComparison.Ordinal))
        {
            didDoc = BlueskyClient.ResolveDidToDidDoc_DidPlc(did);
        }
        else if (did.StartsWith("did:web:", StringComparison.Ordinal))
        {
            didDoc = BlueskyClient.ResolveDidToDidDoc_DidWeb(did);
        }

        return didDoc;
    }



    /// <summary>
    /// Resolves a handle to a did, using dns.
    /// </summary>
    /// <param name="handle">The handle to resolve.</param>
    /// <returns>The resolved did or null if not found.</returns>
    public static string? ResolveHandleToDid_ViaDns(string? handle)
    {
        if (string.IsNullOrEmpty(handle))
        {
            Logger.LogTrace("ResolveHandleToDid_ViaDns: Handle is null or empty.");
            return null;
        }

        string? did = null;
        string url = $"https://cloudflare-dns.com/dns-query?name=_atproto.{handle}&type=TXT";

        Logger.LogTrace($"ResolveHandleToDid_ViaDns: handle: {handle}");
        Logger.LogTrace($"ResolveHandleToDid_ViaDns: url: {url}");

        JsonNode? response = BlueskyClient.SendRequest(url, HttpMethod.Get, acceptHeader: "application/dns-json");

        if (response != null)
        {
            // print response for debugging
            var options = new JsonSerializerOptions { WriteIndented = true };
            Logger.LogTrace(response.ToJsonString(options));

            // get did
            foreach (var answer in response["Answer"]?.AsArray() ?? new JsonArray())
            {
                if(answer == null) continue;
                var dataRaw = answer.AsObject()?["data"]?.ToString();
                var data = dataRaw?.Replace("\"", "");

                Logger.LogTrace($"dataRaw: {dataRaw}");
                Logger.LogTrace($"data: {data}");

                if (string.IsNullOrEmpty(data)) continue;
                
                if(data.StartsWith("did="))
                {
                    if(string.IsNullOrEmpty(did) == false)
                    {
                        Logger.LogError("Multiple DID records found in DNS TXT records.");
                        return did;
                    }

                    did = data.Replace("did=", "");
                }
            }
        }

        Logger.LogTrace($"ResolveHandleToDid_ViaDns: did: {did}");

        return did;
    }


    /// <summary>
    /// Resolves a handle to a did, using http.
    /// </summary>
    /// <param name="handle">The handle to resolve.</param>
    /// <returns>The resolved did or null if not found.</returns>
    public static string? ResolveHandleToDid_ViaHttp(string? handle)
    {
        string? did = null;
        string url = $"https://{handle}/.well-known/atproto-did";

        Logger.LogTrace($"ResolveHandleToDid_ViaHttp: handle: {handle}");
        Logger.LogTrace($"ResolveHandleToDid_ViaHttp: url: {url}");

        string? responseText = null;

        try
        {
            responseText = BlueskyClient.SendRequestEx(url, HttpMethod.Get);
        }
        catch (Exception ex)
        {
            Exception? inner = ex;
            int count = 1;
            while (inner != null)
            {
                Logger.LogTrace($"ResolveHandleToDid_ViaHttp: Exception {count}: {inner.Message}");
                Logger.LogTrace(inner.StackTrace ?? "");
                inner = inner.InnerException;
                count++;
            }
        }

        if (responseText != null && responseText.StartsWith("did:"))
        {
            did = responseText;
        }

        Logger.LogTrace($"ResolveHandleToDid_ViaHttp: did: {did}");

        return did;
    }


    /// <summary>
    /// Resolves a handle to a did, using the Bluesky public api.
    /// </summary>
    /// <param name="handle">The handle to resolve.</param>
    /// <returns>The resolved did or null if not found.</returns>
    public static string? ResolveHandleToDid_ViaBlueskyApi(string? handle)
    {
        Logger.LogTrace($"ResolveHandleToDid_ViaBlueskyApi: handle: {handle}");

        if (string.IsNullOrEmpty(handle))
        {
            Logger.LogTrace("ResolveHandleToDid_ViaBlueskyApi: Handle is null or empty. Exiting.");
            return null;
        }

        string url = $"https://public.api.bsky.app/xrpc/com.atproto.identity.resolveHandle?handle={handle}";
        Logger.LogTrace($"ResolveHandleToDid_ViaBlueskyApi: url: {url}");

        JsonNode? response = BlueskyClient.SendRequest(url, HttpMethod.Get);

        string? did = JsonData.SelectString(response, "did");

        Logger.LogTrace($"ResolveHandleToDid_ViaBlueskyApi: did: {did}");
        return did;
    }


    /// <summary>
    /// Resolves a did to didDoc, for did:plc.
    /// </summary>
    /// <param name="did">The did to resolve.</param>
    /// <returns>The resolved didDoc or null if not found.</returns>
    public static string? ResolveDidToDidDoc_DidPlc(string? did)
    {
        Logger.LogTrace($"ResolveDidToDidDoc_DidPlc: did: {did}");

        if (string.IsNullOrEmpty(did) || !did.StartsWith("did:plc"))
        {
            Logger.LogError($"ResolveDidToDidDoc_DidPlc: invalid did, exiting.");
            return null;
        }

        string? didDoc = null;
        string url = $"https://plc.directory/{did}";
        Logger.LogTrace($"ResolveDidToDidDoc_DidPlc: url: {url}");

        var response = BlueskyClient.SendRequest(url, HttpMethod.Get);

        didDoc = JsonData.ConvertToJsonString(response);


        return didDoc;
    }

    /// <summary>
    /// Resolves a did to didDoc, for did:web.
    /// </summary>
    /// <param name="did">The did to resolve.</param>
    /// <returns>The resolved didDoc or null if not found.</returns>
    public static string? ResolveDidToDidDoc_DidWeb(string? did)
    {
        Logger.LogTrace($"ResolveDidToDidDoc_DidWeb: did: {did}");

        if (string.IsNullOrEmpty(did) || !did.StartsWith("did:web:", StringComparison.Ordinal))
        {
            Logger.LogError($"ResolveDidToDidDoc_DidWeb: invalid did, exiting.");
            return null;
        }

        string? url = BuildDidWebDocUrl(did);
        if (string.IsNullOrEmpty(url))
        {
            Logger.LogWarning($"[SECURITY] Rejected invalid did:web during resolution: {did}");
            return null;
        }

        Logger.LogTrace($"ResolveDidToDidDoc_DidWeb: url: {url}");

        var response = BlueskyClient.SendRequest(url, HttpMethod.Get);

        var didDoc = JsonData.ConvertToJsonString(response);

        return didDoc;
    }

    /// <summary>
    /// Resolves a didDoc to pds.
    /// This is used to get the pds from the didDoc.
    /// </summary>
    /// <param name="didDoc">The didDoc to resolve.</param>
    /// <returns>The resolved pds or null if not found.</returns>
    public static string? ResolveDidDocToPds(string? didDoc)
    {
        Logger.LogTrace($"ResolveDidDocToPds: didDoc length: {didDoc?.Length}");

        if (string.IsNullOrEmpty(didDoc))
        {
            Logger.LogError("DidDoc is null or empty.");
            return null;
        }

        JsonNode? didDocJson = JsonNode.Parse(didDoc);
        if (didDocJson == null) return null;

        foreach (var service in didDocJson["service"]?.AsArray() ?? new JsonArray())
        {
            if (service == null) continue;
            var serviceType = service["type"]?.ToString();
            if (serviceType == "AtprotoPersonalDataServer")
            {
                var pds = service["serviceEndpoint"]?.ToString();
                if (!string.IsNullOrEmpty(pds))
                {
                    string? host = ExtractPdsHostFromEndpoint(pds);
                    if (!string.IsNullOrEmpty(host))
                    {
                        return host;
                    }

                    Logger.LogWarning($"[SECURITY] Ignored invalid PDS serviceEndpoint in DID document: {pds}");
                }
            }
        }
        
        return null;
    }

    public static bool IsValidHandle(string? handle)
    {
        if (string.IsNullOrEmpty(handle)) return false;
        if (handle.Length > 253) return false;
        if (!handle.All(static c => c <= 127)) return false;
        if (handle.StartsWith('.') || handle.EndsWith('.')) return false;

        string[] labels = handle.Split('.');
        if (labels.Length < 2) return false;

        foreach (string label in labels)
        {
            if (string.IsNullOrEmpty(label) || label.Length > 63) return false;
            if (label.StartsWith('-') || label.EndsWith('-')) return false;

            foreach (char ch in label)
            {
                if (!(char.IsAsciiLetterOrDigit(ch) || ch == '-')) return false;
            }
        }

        char tldFirstChar = labels[^1][0];
        if (char.IsDigit(tldFirstChar)) return false;

        return true;
    }

    public static bool IsValidDid(string? did)
    {
        if (string.IsNullOrEmpty(did)) return false;
        if (did.Length > 2048) return false;
        if (!did.All(static c => c <= 127)) return false;
        if (!did.StartsWith("did:", StringComparison.Ordinal)) return false;

        string rest = did.Substring(4);
        int methodSeparatorIndex = rest.IndexOf(':');
        if (methodSeparatorIndex <= 0) return false;

        string method = rest.Substring(0, methodSeparatorIndex);
        string identifier = rest.Substring(methodSeparatorIndex + 1);

        if (!method.All(static c => c is >= 'a' and <= 'z')) return false;
        if (string.IsNullOrEmpty(identifier)) return false;
        if (identifier.EndsWith(':') || identifier.EndsWith('%')) return false;

        foreach (char ch in identifier)
        {
            bool isAllowed = char.IsAsciiLetterOrDigit(ch)
                || ch == '.'
                || ch == '_'
                || ch == ':'
                || ch == '%'
                || ch == '-';

            if (!isAllowed) return false;
        }

        return true;
    }

    public static string? BuildDidWebDocUrl(string? did)
    {
        if (string.IsNullOrEmpty(did)) return null;

        const string prefix = "did:web:";
        if (!did.StartsWith(prefix, StringComparison.Ordinal)) return null;

        string identifier = did.Substring(prefix.Length);
        string[] parts = identifier.Split(':');
        if (parts.Length == 0 || string.IsNullOrEmpty(parts[0])) return null;

        string authority = parts[0];
        if (!IsValidDidWebAuthority(authority)) return null;

        var pathSegments = new List<string>();
        for (int i = 1; i < parts.Length; i++)
        {
            string segment = parts[i];
            if (!IsValidDidWebPathSegment(segment)) return null;
            pathSegments.Add(segment);
        }

        string path = pathSegments.Count == 0
            ? "/.well-known/did.json"
            : $"/{string.Join("/", pathSegments)}/did.json";

        string url = $"https://{authority}{path}";
        if (!Uri.TryCreate(url, UriKind.Absolute, out Uri? parsed)) return null;
        if (parsed.Scheme != Uri.UriSchemeHttps) return null;
        if (string.IsNullOrEmpty(parsed.Host)) return null;

        return url;
    }

    public static bool IsValidDidWebAuthority(string authority)
    {
        if (string.IsNullOrEmpty(authority)) return false;
        if (!authority.All(static c => c <= 127)) return false;

        foreach (char ch in authority)
        {
            if (ch is '/' or '\\' or '?' or '#' or '@' or '%' or '[' or ']')
            {
                return false;
            }
        }

        string host = authority;
        string? portText = null;
        int colonCount = authority.Count(static c => c == ':');
        if (colonCount > 1)
        {
            return false;
        }

        int colonIndex = authority.LastIndexOf(':');
        if (colonIndex > 0)
        {
            host = authority.Substring(0, colonIndex);
            portText = authority.Substring(colonIndex + 1);
            if (string.IsNullOrEmpty(host) || string.IsNullOrEmpty(portText)) return false;
            if (!int.TryParse(portText, out int port) || port < 1 || port > 65535) return false;
        }

        string hostLower = host.ToLowerInvariant();
        if (hostLower == "localhost" || hostLower.EndsWith(".localhost", StringComparison.Ordinal))
        {
            return false;
        }

        if (IPAddress.TryParse(hostLower, out IPAddress? ipAddress))
        {
            return IsPublicIp(ipAddress);
        }

        return IsValidHandle(hostLower);
    }

    public static bool IsValidDidWebPathSegment(string segment)
    {
        if (string.IsNullOrEmpty(segment)) return false;
        if (segment == "." || segment == "..") return false;
        if (!segment.All(static c => c <= 127)) return false;

        for (int i = 0; i < segment.Length; i++)
        {
            char ch = segment[i];

            if (ch == '%')
            {
                if (i + 2 >= segment.Length) return false;
                if (!Uri.IsHexDigit(segment[i + 1]) || !Uri.IsHexDigit(segment[i + 2])) return false;
                i += 2;
                continue;
            }

            bool isAllowed = char.IsAsciiLetterOrDigit(ch)
                || ch == '-'
                || ch == '_'
                || ch == '.'
                || ch == '~';

            if (!isAllowed) return false;
        }

        return true;
    }

    public static string? ExtractPdsHostFromEndpoint(string endpoint)
    {
        if (!Uri.TryCreate(endpoint, UriKind.Absolute, out Uri? parsed)) return null;

        if (parsed.Scheme != Uri.UriSchemeHttp && parsed.Scheme != Uri.UriSchemeHttps)
        {
            return null;
        }

        if (!string.IsNullOrEmpty(parsed.UserInfo)) return null;
        if (!string.IsNullOrEmpty(parsed.Query)) return null;
        if (!string.IsNullOrEmpty(parsed.Fragment)) return null;
        if (parsed.AbsolutePath != "/") return null;
        if (string.IsNullOrEmpty(parsed.Host)) return null;

        string host = parsed.Host.ToLowerInvariant();
        if (host == "localhost" || host.EndsWith(".localhost", StringComparison.Ordinal))
        {
            return null;
        }

        if (IPAddress.TryParse(host, out IPAddress? ipAddress))
        {
            if (!IsPublicIp(ipAddress)) return null;
        }
        else if (!IsValidHandle(host))
        {
            return null;
        }

        if (!parsed.IsDefaultPort)
        {
            return $"{host}:{parsed.Port}";
        }

        return host;
    }

    public static bool IsPublicIp(IPAddress ipAddress)
    {
        if (ipAddress.AddressFamily == AddressFamily.InterNetwork)
        {
            byte[] bytes = ipAddress.GetAddressBytes();

            // 10.0.0.0/8
            if (bytes[0] == 10) return false;

            // 172.16.0.0/12
            if (bytes[0] == 172 && bytes[1] >= 16 && bytes[1] <= 31) return false;

            // 192.168.0.0/16
            if (bytes[0] == 192 && bytes[1] == 168) return false;

            // 169.254.0.0/16 (link-local)
            if (bytes[0] == 169 && bytes[1] == 254) return false;

            // 127.0.0.0/8 (loopback)
            if (bytes[0] == 127) return false;

            // 0.0.0.0/8 (unspecified)
            if (bytes[0] == 0) return false;

            return true;
        }

        if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6)
        {
            if (IPAddress.IsLoopback(ipAddress)) return false;
            if (ipAddress.Equals(IPAddress.IPv6None)) return false;
            if (ipAddress.Equals(IPAddress.IPv6Any)) return false;
            if (ipAddress.IsIPv6LinkLocal) return false;

            byte[] bytes = ipAddress.GetAddressBytes();
            // fc00::/7 unique local
            if ((bytes[0] & 0xFE) == 0xFC) return false;

            return true;
        }

        return false;
    }
    #endregion



    #region SENDREQ

    /// <summary>
    /// Many calls to the Bluesky APIs follow the same pattern. This function implements that pattern.
    /// You'll see this being called in commands like "GetUnreadCount" and "ResolveHandle".
    /// If user specifies an output file, the response is written to that file.
    /// </summary>
    /// <param name="url"></param>
    /// <param name="getOrPut"></param>
    /// <param name="accessJwt"></param>
    /// <param name="contentType"></param>
    /// <param name="content"></param>
    /// <param name="outputFilePath"></param>
    /// <returns></returns>
    public static JsonNode? SendRequest(string url, HttpMethod getOrPut, string? accessJwt = null, string contentType = "application/json", StringContent? content = null, bool parseJsonResponse = true, string? outputFilePath = null, string? acceptHeader = null, string? userAgent = "dnproto", string? labelers = null, string? basicAuth = null, bool writeMetadataFile = false)
    {
        StringBuilder logLine = new StringBuilder($"[SEND REQUEST] {url}");
        DateTime startTime = DateTime.UtcNow;


        try
        {
            using (HttpClient client = new HttpClient())
            {
                //
                // Set up request
                //
                var request = new HttpRequestMessage(getOrPut, url);

                if (content != null)
                {
                    request.Content = content;
                    request.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
                }

                if (accessJwt != null)
                {
                    request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessJwt);
                }

                if (!string.IsNullOrEmpty(basicAuth))
                {
                    request.Headers.Authorization = new AuthenticationHeaderValue("Basic", basicAuth);
                }

                if (!string.IsNullOrEmpty(acceptHeader))
                {
                    request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptHeader));
                }

                if (!string.IsNullOrEmpty(userAgent))
                {
                    request.Headers.UserAgent.TryParseAdd(userAgent);
                }

                if (!string.IsNullOrEmpty(labelers))
                {
                    request.Headers.Add("Atproto-Accept-Labelers", labelers);
                }

                Logger.LogTrace($"REQUEST:\n{request}");
                

                //
                // Send
                //
                HttpResponseMessage? response = null;

                try
                {
                    response = client.Send(request);                

                }
                catch (Exception ex)
                {
                    Logger.LogError($"Exception sending request: {ex.Message}");
                    return null;
                }

                if (response == null)
                {
                    Logger.LogError("In SendRequest, response is null.");
                    return null;
                }

                Logger.LogTrace($"RESPONSE: {response}");

                bool succeeded = response.StatusCode == HttpStatusCode.OK;

                if (!succeeded) 
                {
                    Logger.LogError($"Request failed with status code: {response.StatusCode}  url: {url}");
                }

                //
                // If user wants json, parse that.
                //
                JsonNode? jsonResponse = null;
                if (parseJsonResponse)
                {
                    using (var reader = new StreamReader(response.Content.ReadAsStream()))
                    {
                        var responseText = reader.ReadToEnd();

                        if (string.IsNullOrEmpty(responseText) == false)
                        {
                            try
                            {
                                jsonResponse = JsonNode.Parse(responseText);                            
                            }
                            catch
                            {
                                //
                            }
                        }
                    }
                }

                //
                // If the user has specified an output file, write the response to that file.
                //
                if (string.IsNullOrEmpty(outputFilePath) == false && succeeded)
                {
                    Logger.LogTrace($"writing to: {outputFilePath}");

                    if (parseJsonResponse)
                    {
                        JsonData.WriteJsonToFile(jsonResponse, outputFilePath);
                    }
                    else
                    {
                        using (var responseStream = response.Content.ReadAsStream())
                        {
                            using (var fs = new FileStream(outputFilePath, FileMode.Create))
                            {
                                responseStream.CopyTo(fs);
                            }
                        }
                    }
                }


                //
                // User wants metadata file?
                //
                if (string.IsNullOrEmpty(outputFilePath) == false
                    && writeMetadataFile 
                    && succeeded)
                {
                    string metadataFilePath = outputFilePath + ".metadata.json";
                    Logger.LogTrace($"writing metadata to: {metadataFilePath}");

                    var metadata = new JsonObject
                    {
                        ["statusCode"] = (int)response.StatusCode,
                        ["contentType"] = response.Content.Headers.ContentType?.ToString() ?? "",
                        ["contentLength"] = response.Content.Headers.ContentLength ?? 0,
                    };

                    JsonData.WriteJsonToFile(metadata, metadataFilePath);
                }

                return jsonResponse;
            }
        }
        finally
        {
            DateTime endTime = DateTime.UtcNow;
            TimeSpan duration = endTime - startTime;
            logLine.Append($" [{duration.TotalMilliseconds:F2}ms]");
            Logger.LogInfo(logLine.ToString());            
        }
    }

    /// <summary>
    /// Streaming version of SendRequest that writes to disk as data is received.
    /// Useful for large file downloads where you don't want to buffer the entire response in memory.
    /// </summary>
    /// <param name="url">The URL to send the request to.</param>
    /// <param name="getOrPut">The HTTP method to use.</param>
    /// <param name="outputFilePath">The file path to write the response to.</param>
    /// <param name="accessJwt">Optional access JWT for authentication.</param>
    /// <param name="acceptHeader">Optional Accept header value.</param>
    /// <param name="userAgent">Optional User-Agent header value.</param>
    /// <param name="basicAuth">Optional Basic auth credentials (base64 encoded).</param>
    /// <param name="bufferSize">Size of the buffer for streaming (default 81920 bytes).</param>
    /// <returns>True if the request succeeded and file was written, false otherwise.</returns>
    public static bool SendRequestStreaming(string url, HttpMethod getOrPut, string outputFilePath, string? accessJwt = null, string? acceptHeader = null, string? userAgent = "dnproto", string? basicAuth = null, int bufferSize = 81920)
    {
        StringBuilder logLine = new StringBuilder($"[SEND REQUEST STREAMING] {url}");
        DateTime startTime = DateTime.UtcNow;


        try
        {
            
            if (string.IsNullOrEmpty(outputFilePath))
            {
                Logger.LogError("SendRequestStreaming: outputFilePath is required.");
                return false;
            }

            using (HttpClient client = new HttpClient())
            {
                //
                // Set up request
                //
                var request = new HttpRequestMessage(getOrPut, url);

                if (accessJwt != null)
                {
                    request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessJwt);
                }

                if (!string.IsNullOrEmpty(basicAuth))
                {
                    request.Headers.Authorization = new AuthenticationHeaderValue("Basic", basicAuth);
                }

                if (!string.IsNullOrEmpty(acceptHeader))
                {
                    request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptHeader));
                }

                if (!string.IsNullOrEmpty(userAgent))
                {
                    request.Headers.UserAgent.TryParseAdd(userAgent);
                }

                Logger.LogTrace($"REQUEST:\n{request}");

                //
                // Send request with ResponseHeadersRead to enable streaming
                //
                HttpResponseMessage? response = null;

                try
                {
                    response = client.Send(request, HttpCompletionOption.ResponseHeadersRead);
                }
                catch (Exception ex)
                {
                    Logger.LogError($"Exception sending request: {ex.Message}");
                    return false;
                }

                if (response == null)
                {
                    Logger.LogError("In SendRequestStreaming, response is null.");
                    return false;
                }

                Logger.LogTrace($"RESPONSE: {response}");

                bool succeeded = response.StatusCode == HttpStatusCode.OK;

                if (!succeeded)
                {
                    Logger.LogError($"Request failed with status code: {response.StatusCode}  url: {url}");
                    return false;
                }

                //
                // Stream response directly to file
                //
                try
                {
                    Logger.LogTrace($"Streaming to: {outputFilePath}");

                    long totalBytesRead = 0;
                    long? contentLength = response.Content.Headers.ContentLength;

                    using (var responseStream = response.Content.ReadAsStream())
                    using (var fileStream = new FileStream(outputFilePath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize, FileOptions.SequentialScan))
                    {
                        byte[] buffer = new byte[bufferSize];
                        int bytesRead;

                        while ((bytesRead = responseStream.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            fileStream.Write(buffer, 0, bytesRead);
                            totalBytesRead += bytesRead;

                            if (contentLength.HasValue)
                            {
                                Logger.LogTrace($"Progress: {totalBytesRead} / {contentLength} bytes ({(double)totalBytesRead / contentLength * 100:F1}%)");
                            }
                            else
                            {
                                Logger.LogTrace($"Downloaded: {totalBytesRead} bytes");
                            }
                        }
                    }

                    Logger.LogInfo($"SendRequestStreaming: Completed. Total bytes written: {totalBytesRead}");
                    return true;
                }
                catch (Exception ex)
                {
                    Logger.LogError($"Exception writing to file: {ex.Message}");
                    return false;
                }
            }
        }
        finally
        {
            DateTime endTime = DateTime.UtcNow;
            TimeSpan duration = endTime - startTime;
            logLine.Append($" [{duration.TotalMilliseconds:F2}ms]");
            Logger.LogInfo(logLine.ToString());            
        }
    }

    /// <summary>
    /// Same as above, but just get string.
    /// </summary>
    /// <param name="url"></param>
    /// <param name="getOrPut"></param>
    /// <param name="accessJwt"></param>
    /// <param name="contentType"></param>
    /// <param name="content"></param>
    /// <param name="outputFilePath"></param>
    /// <returns></returns>
    public static string? SendRequestEx(string url, HttpMethod getOrPut, string? accessJwt = null, string contentType = "application/json", StringContent? content = null, string? outputFilePath = null, string? acceptHeader = null, string? userAgent = "dnproto", string? basicAuth = null)
    {
        StringBuilder logLine = new StringBuilder($"[SEND REQUEST EX] {url}");
        DateTime startTime = DateTime.UtcNow;

        try
        {
            using (HttpClient client = new HttpClient())
            {
                //
                // Set up request
                //
                var request = new HttpRequestMessage(getOrPut, url);

                if (content != null)
                {
                    request.Content = content;
                    request.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
                }


                if (accessJwt != null)
                {
                    request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessJwt);
                }

                if (!string.IsNullOrEmpty(basicAuth))
                {
                    request.Headers.Authorization = new AuthenticationHeaderValue("Basic", basicAuth);
                }

                if (!string.IsNullOrEmpty(acceptHeader))
                {
                    request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptHeader));
                }

                if (!string.IsNullOrEmpty(userAgent))
                {
                    request.Headers.UserAgent.TryParseAdd(userAgent);
                }

                Logger.LogTrace($"REQUEST:\n{request}");

                //
                // Send
                //
                var response = client.Send(request);

                if(response == null)
                {
                    Logger.LogTrace("response is null.");
                    return null;
                }

                Logger.LogTrace($"RESPONSE:\n{response}");


                //
                // Get response text.
                //
                string? responseText = null;
                using (var reader = new StreamReader(response.Content.ReadAsStream()))
                {
                    responseText = reader.ReadToEnd();
                }
                
                //
                // If the user has specified an output file, write the response to that file.
                //
                if (string.IsNullOrEmpty(outputFilePath) == false && !string.IsNullOrEmpty(responseText))
                {
                    Logger.LogTrace($"writing to: {outputFilePath}");
                    File.WriteAllText(outputFilePath, responseText);
                }

                return responseText;
            }
        }
        finally
        {
            DateTime endTime = DateTime.UtcNow;
            TimeSpan duration = endTime - startTime;
            logLine.Append($" [{duration.TotalMilliseconds:F2}ms]");
            Logger.LogInfo(logLine.ToString());            
        }
    }
    #endregion



    #region PROFILE

    /// <summary>
    /// Gets the profile of an actor.
    /// https://endpoints.bsky.app/#bluesky-app/tag/appbskyactor/GET/xrpc/app.bsky.actor.getProfile
    /// </summary>
    /// <param name="actor">The actor to get the profile for.</param>
    public static JsonNode? GetProfile(string? actor, string? accessJwt = null, string? hostname = null, string? labelers = null)
    {
        if (string.IsNullOrEmpty(hostname))
        {
            // we were calling "public.api.bsky.app", but the labels weren't returning
            // from that endpoint. Switching to "api.bsky.app" seems to work.
            hostname = "api.bsky.app";
        }
        
        Logger.LogTrace($"GetProfile: actor: {actor}");
        if (string.IsNullOrEmpty(actor))
        {
            Logger.LogError("GetProfile: Actor is null or empty. Exiting.");
            return null;
        }

        string url = $"https://{hostname}/xrpc/app.bsky.actor.getProfile?actor={actor}";
        Logger.LogTrace($"GetProfile: url: {url}");

        JsonNode? profile = BlueskyClient.SendRequest(url, HttpMethod.Get, accessJwt: accessJwt, labelers: labelers);

        return profile;
    }

    #endregion

    #region REPO

    /// <summary>
    /// Get repo for did.
    /// https://endpoints.bsky.app/#bluesky-app/tag/comatprotosync/GET/xrpc/com.atproto.sync.getRepo
    /// </summary>
    /// <param name="pds"></param>
    /// <param name="did"></param>
    /// <param name="repoFile"></param>
    public static void GetRepo(string? pds, string? did, string? repoFile)
    {
        Logger.LogTrace($"GetRepo: pds: {pds}, did: {did}, repoFile: {repoFile}");

        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(did) || string.IsNullOrEmpty(repoFile))
        {
            Logger.LogError("GetRepo: Invalid arguments. Exiting.");
            return;
        }

        string url = $"https://{pds}/xrpc/com.atproto.sync.getRepo?did={did}";
        Logger.LogTrace($"GetRepo: url: {url}");

        BlueskyClient.SendRequestStreaming(url,
            HttpMethod.Get,
            outputFilePath: repoFile);

    }
    #endregion


    #region RECORD
    public static void GetRecordSync(string? pds, string? did, string? collection, string? rkey, string? recordFile)
    {
        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(did) || string.IsNullOrEmpty(recordFile))
        {
            Logger.LogError("GetRecordSync: Invalid arguments. Exiting.");
            return;
        }

        string url = $"https://{pds}/xrpc/com.atproto.sync.getRecord?did={did}&collection={collection}&rkey={rkey}";
        Logger.LogTrace($"GetRecordSync: url: {url}");

        BlueskyClient.SendRequestStreaming(url,
            HttpMethod.Get,
            outputFilePath: recordFile);

    }


    
    /// <summary>
    /// Deletes a record.
    /// </summary>
    /// <param name="handleInfo"></param>
    /// <param name="accessJwt"></param>
    /// <param name="postUri"></param>
    public static void DeleteRecord(string? pds, string? did, string? accessJwt, string? rkey, string? collection = "app.bsky.feed.post")
    {
        //
        // Check args
        //
        Logger.LogTrace($"DeleteRecord: pds: {pds}, did: {did}, collection: {collection}, rkey: {rkey}");

        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(did) || string.IsNullOrEmpty(accessJwt) || string.IsNullOrEmpty(collection) || string.IsNullOrEmpty(rkey))
        {
            Logger.LogError("DeleteRecord: Invalid arguments. Exiting.");
            return;
        }

        //
        // Call pds to delete
        //
        string url = $"https://{pds}/xrpc/com.atproto.repo.deleteRecord";
        Logger.LogTrace($"DeleteRecord: url: {url}");

        var response = BlueskyClient.SendRequest(url,
            HttpMethod.Post,
            accessJwt: accessJwt,
            content: new StringContent(JsonSerializer.Serialize(new
            {
                repo = did,
                collection = collection,
                rkey = rkey
            }))
        );

        if (response == null)
        {
            Logger.LogError("DeletePost: response returned null.");
            return;
        }

        BlueskyClient.LogTraceJsonResponse(response);
    }


    #endregion

    #region REPO

    /// <summary>
    /// List repos.
    /// https://endpoints.bsky.app/#bluesky-app/tag/comatprotosync/GET/xrpc/com.atproto.sync.listRepos
    /// </summary>
    /// <param name="pds"></param>
    /// <param name="limit"></param>
    /// <param name="sleepMilliseconds"></param>
    /// <returns></returns>
    public static List<JsonNode> ListRepos(string? pds, int limit = 100, int sleepMilliseconds = 1000)
    {
        List<JsonNode> repos = new List<JsonNode>();
        Logger.LogTrace($"ListRepos: pds: {pds}");

        if (string.IsNullOrEmpty(pds))
        {
            Logger.LogError("ListRepos: Invalid arguments. Exiting.");
            return repos;
        }

        bool keepGoing = true;
        string? cursor = null;

        // We call the api in batches of 100 (or whatever limit is set).
        while (keepGoing)
        {
            string? url = null;

            if (cursor != null)
            {
                url = $"https://{pds}/xrpc/com.atproto.sync.listRepos?limit={limit}&cursor={cursor}";
            }
            else
            {
                url = $"https://{pds}/xrpc/com.atproto.sync.listRepos?limit={limit}";
            }

            Logger.LogTrace($"ListRepos: url: {url}");

            JsonNode? response = BlueskyClient.SendRequest(url, HttpMethod.Get);

            var reposArray = response?["repos"]?.AsArray();

            keepGoing = reposArray != null && reposArray.Count == limit;

            cursor = response?["cursor"]?.ToString();

            if (reposArray != null)
            {
                Logger.LogTrace($"ListRepos: Count: {reposArray.Count}");
                Logger.LogTrace($"ListRepos: Cursor: {cursor}");

                foreach (var repo in reposArray)
                {
                    if (repo == null) continue;
                    repos.Add(repo);
                }
            }

            if (keepGoing)
            {
                Thread.Sleep(sleepMilliseconds);
            }
        }

        return repos;
    }
    #endregion

    #region PDS

    public static JsonNode? PdsHealth(string? pds)
    {
        Logger.LogTrace($"PdsHealth: pds: {pds}");

        if (string.IsNullOrEmpty(pds))
        {
            Logger.LogError("PdsHealth: Invalid arguments. Exiting.");
            return null;
        }

        string url = $"https://{pds}/xrpc/_health";
        Logger.LogTrace($"PdsHealth: url: {url}");

        return BlueskyClient.SendRequest(url,
            HttpMethod.Get);

    }

    public static JsonNode? PdsDescribeServer(string? pds)
    {
        Logger.LogTrace($"PdsDescribeServer: pds: {pds}");

        if (string.IsNullOrEmpty(pds))
        {
            Logger.LogError("PdsDescribeServer: Invalid arguments. Exiting.");
            return null;
        }

        string url = $"https://{pds}/xrpc/com.atproto.server.describeServer";
        Logger.LogTrace($"PdsDescribeServer: url: {url}");

        return BlueskyClient.SendRequest(url,
            HttpMethod.Get);

    }
    
    #endregion


    #region BLOB

    /// <summary>
    /// List blobs for did.
    /// https://endpoints.bsky.app/#bluesky-app/tag/comatprotosync/GET/xrpc/com.atproto.sync.listBlobs
    /// </summary>
    /// <param name="pds"></param>
    /// <param name="did"></param>
    /// <returns></returns>
    public static List<string> ListBlobs(string? pds, string? did, string? blobsFile = null, int limit = 100, int sleepMilliseconds = 1000, string? accessJwt = null)
    {
        List<string> blobs = new List<string>();
        Logger.LogTrace($"ListBlobs: pds: {pds}, did: {did}");
        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(did))
        {
            Logger.LogError("ListBlobs: Invalid arguments. Exiting.");
            return blobs;
        }

        bool keepGoing = true;
        string? cursor = null;

        // We call the api in batches of 100 (or whatever limit is set).
        while (keepGoing)
        {
            string? url = null;

            if (cursor != null)
            {
                url = $"https://{pds}/xrpc/com.atproto.sync.listBlobs?did={did}&limit={limit}&cursor={cursor}";
            }
            else
            {
                url = $"https://{pds}/xrpc/com.atproto.sync.listBlobs?did={did}&limit={limit}";
            }

            Logger.LogTrace($"ListBlobs: url: {url}");

            JsonNode? response = BlueskyClient.SendRequest(url, HttpMethod.Get, accessJwt: accessJwt);

            Logger.LogTrace($"ListBlobs: response: {response?.ToJsonString(new JsonSerializerOptions { WriteIndented = true })}");

            var cids = response?["cids"]?.AsArray();

            keepGoing = cids != null && cids.Count == limit;

            cursor = response?["cursor"]?.ToString();

            if (cids != null)
            {
                Logger.LogTrace($"ListBlobs: Count: {cids.Count}");
                Logger.LogTrace($"ListBlobs: Cursor: {cursor}");

                foreach (var cid in cids)
                {
                    if (cid == null) continue;
                    blobs.Add(cid.ToString());
                }
            }

            if (keepGoing)
            {
                Thread.Sleep(sleepMilliseconds);
            }
        }

        if (blobsFile != null)
        {
            Logger.LogTrace($"ListBlobs: Writing blobs to file: {blobsFile}");
            File.WriteAllLines(blobsFile, blobs);
        }

        return blobs;
    }

    /// <summary>
    /// Get blob for did, by cid.
    /// </summary>
    /// <param name="pds"></param>
    /// <param name="did"></param>
    /// <param name="cid"></param>
    /// <param name="blobFile"></param>
    public static void GetBlob(string? pds, string? did, string? cid, string? blobFile)
    {
        Logger.LogTrace($"GetBlob: pds: {pds}, did: {did}, cid: {cid}, blobFile: {blobFile}");

        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(did) || string.IsNullOrEmpty(cid) || string.IsNullOrEmpty(blobFile))
        {
            Logger.LogError("GetBlob: Invalid arguments. Exiting.");
            return;
        }

        string url = $"https://{pds}/xrpc/com.atproto.sync.getBlob?did={did}&cid={cid}";
        Logger.LogTrace($"GetBlob: url: {url}");

        BlueskyClient.SendRequest(url,
            HttpMethod.Get,
            outputFilePath: blobFile,
            parseJsonResponse: false,
            writeMetadataFile: true);

    }



    /// <summary>
    /// Upload a blob to the PDS.
    /// https://docs.bsky.app/docs/api/com-atproto-repo-upload-blob
    /// </summary>
    /// <param name="pds">The PDS hostname</param>
    /// <param name="accessJwt">The access JWT token for authentication</param>
    /// <param name="fileBytes">The file content as a byte array</param>
    /// <param name="mimeType">The MIME type of the file</param>
    /// <returns>JSON response containing blob reference with CID, mimeType, and size</returns>
    public static JsonNode? UploadBlob(string? pds, string? accessJwt, byte[] fileBytes, string? mimeType)
    {
        Logger.LogTrace($"UploadBlob: pds: {pds}, mimeType: {mimeType}, size: {fileBytes.Length}");

        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(accessJwt) || string.IsNullOrEmpty(mimeType))
        {
            Logger.LogError("UploadBlob: Invalid arguments (pds or accessJwt is null). Exiting.");
            return null;
        }

        if (fileBytes == null || fileBytes.Length == 0)
        {
            Logger.LogError("UploadBlob: File content is empty. Exiting.");
            return null;
        }

        string url = $"https://{pds}/xrpc/com.atproto.repo.uploadBlob";
        Logger.LogTrace($"UploadBlob: url: {url}");

        // Send raw bytes using the specialized blob request method
        return SendBlobRequest(url, accessJwt, fileBytes, mimeType);
    }

    /// <summary>
    /// Send a blob upload request with raw binary data.
    /// </summary>
    private static JsonNode? SendBlobRequest(string url, string accessJwt, byte[] fileBytes, string mimeType)
    {
        Logger.LogInfo($"SendBlobRequest: {url}");

        using (HttpClient client = new HttpClient())
        {
            var request = new HttpRequestMessage(HttpMethod.Post, url);
            
            // Set the content as ByteArrayContent
            request.Content = new ByteArrayContent(fileBytes);
            request.Content.Headers.ContentType = new MediaTypeHeaderValue(mimeType);
            request.Content.Headers.ContentLength = fileBytes.Length;

            // Add authorization header
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessJwt);
            request.Headers.UserAgent.TryParseAdd("dnproto");

            Logger.LogTrace($"REQUEST:\n{request}");
            Logger.LogTrace($"Content-Type: {mimeType}");
            Logger.LogTrace($"Content-Length: {fileBytes.Length}");

            HttpResponseMessage? response = null;

            try
            {
                response = client.Send(request);
            }
            catch (Exception ex)
            {
                Logger.LogError($"Exception sending blob request: {ex.Message}");
                return null;
            }

            if (response == null)
            {
                Logger.LogError("In SendBlobRequest, response is null.");
                return null;
            }

            Logger.LogTrace($"RESPONSE: {response}");

            bool succeeded = response.StatusCode == HttpStatusCode.OK;

            if (!succeeded)
            {
                Logger.LogError($"Blob upload failed with status code: {response.StatusCode}");
                return null;
            }

            // Parse JSON response
            JsonNode? jsonResponse = null;
            using (var reader = new StreamReader(response.Content.ReadAsStream()))
            {
                var responseText = reader.ReadToEnd();

                if (!string.IsNullOrEmpty(responseText))
                {
                    try
                    {
                        jsonResponse = JsonNode.Parse(responseText);
                    }
                    catch (Exception ex)
                    {
                        Logger.LogError($"Failed to parse JSON response: {ex.Message}");
                    }
                }
            }

            return jsonResponse;
        }
    }

    #endregion


    #region ACCOUNT

    public static JsonNode? CreateAccount(string? pds, string? handle, string? did, string? inviteCode, string? password)
    {
        string url = $"https://{pds}/xrpc/com.atproto.server.createAccount";

        var response = BlueskyClient.SendRequest(url,
            HttpMethod.Post,
            content: new StringContent(JsonSerializer.Serialize(new
            {
                handle = handle,
                did = did,
                inviteCode = inviteCode,
                password = password
            }))
        );

        return response;        
    }
    #endregion

    #region BOOKMARKS

    /// <summary>
    /// Return set of bookmarks for the user.
    /// </summary>
    /// <param name="pds"></param>
    /// <param name="accessJwt"></param>
    /// <returns></returns>
    public static List<(string createdAt, AtUri uri)> GetBookmarks(string? pds, string? accessJwt)
    {
        List<(string createdAt, AtUri uri)> ret = new List<(string createdAt, AtUri uri)>();

        if (string.IsNullOrEmpty(pds) || string.IsNullOrEmpty(accessJwt))
        {
            Logger.LogError("GetBookmarks: Invalid arguments. Exiting.");
            return ret;
        }

        bool keepGoing = true;
        string? cursor = null;
        while (keepGoing)
        {
            keepGoing = false;
            string? url = null;

            if (cursor != null)
            {
                url = $"https://{pds}/xrpc/app.bsky.bookmark.getBookmarks?cursor={cursor}";
            }
            else
            {
                url = $"https://{pds}/xrpc/app.bsky.bookmark.getBookmarks";
            }

            Logger.LogTrace($"GetBookmarks: url: {url}");

            var response = BlueskyClient.SendRequest(url,
                HttpMethod.Get,
                accessJwt: accessJwt
            );

            if (response == null)
            {
                Logger.LogError("GetBookmarks: response returned null.");
                return ret;
            }

            BlueskyClient.LogTraceJsonResponse(response);

            var bookmarks = response["bookmarks"]?.AsArray();
            if (bookmarks != null)
            {
                foreach (var bookmark in bookmarks)
                {
                    keepGoing = true;
                    var uri = bookmark?["item"]?["uri"]?.ToString();
                    var createdAt = bookmark?["item"]?["record"]?["createdAt"]?.ToString();

                    if (!string.IsNullOrEmpty(uri))
                    {
                        var atUri = AtUri.FromAtUri(uri);
                        if (atUri != null && !string.IsNullOrEmpty(createdAt))
                        {
                            ret.Add(((string)createdAt, atUri));
                        }
                    }
                }
            }

            cursor = response?["cursor"]?.ToString();

            if (keepGoing)
            {
                Thread.Sleep(1000);
            }
        }


        return ret;
    }
    #endregion


    /// <summary>
    /// Currently most of the commands just print the response to the console.
    /// </summary>
    /// <param name="response"></param>
    public static void PrintJsonResponseToConsole(JsonNode? response)
    {
        if(response == null)
        {
            Logger.LogError("response returned null.");
            return;
        }

        var options = new JsonSerializerOptions { WriteIndented = true };
        Logger.LogInfo($"\nRESPONSE:\n{response.ToJsonString(options)}");
    }

    public static void LogTraceJsonResponse(JsonNode? response)
    {
        if(response == null)
        {
            Logger.LogError("response returned null.");
            return;
        }

        var options = new JsonSerializerOptions { WriteIndented = true };
        Logger.LogTrace(response.ToJsonString(options));
    }
}