Backup is working now

AtProtoBackup.xcodeproj/project.pbxproj

···
 	objectVersion = 77;
 	objects = {
 
+/* Begin PBXBuildFile section */
+		16A25DB92E5FE9060070BFFD /* ZIPFoundation in Frameworks */ = {isa = PBXBuildFile; productRef = 16A25DB82E5FE9060070BFFD /* ZIPFoundation */; };
+		16A25DBE2E5FED820070BFFD /* ATProtoKit in Frameworks */ = {isa = PBXBuildFile; productRef = 16A25DBD2E5FED820070BFFD /* ATProtoKit */; };
+/* End PBXBuildFile section */
+
 /* Begin PBXContainerItemProxy section */
 		16A25D8A2E5CA47B0070BFFD /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
···
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				16A25DB92E5FE9060070BFFD /* ZIPFoundation in Frameworks */,
+				16A25DBE2E5FED820070BFFD /* ATProtoKit in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
···
 			);
 			name = AtProtoBackup;
 			packageProductDependencies = (
+				16A25DB82E5FE9060070BFFD /* ZIPFoundation */,
+				16A25DBD2E5FED820070BFFD /* ATProtoKit */,
 			);
 			productName = AtProtoBackup;
 			productReference = 16A25D782E5CA4790070BFFD /* AtProtoBackup.app */;
···
 			);
 			mainGroup = 16A25D6F2E5CA4790070BFFD;
 			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				16A25DB72E5FE9060070BFFD /* XCRemoteSwiftPackageReference "ZIPFoundation" */,
+				16A25DBC2E5FED820070BFFD /* XCRemoteSwiftPackageReference "ATProtoKit" */,
+			);
 			preferredProjectObjectVersion = 77;
 			productRefGroup = 16A25D792E5CA4790070BFFD /* Products */;
 			projectDirPath = "";
···
 			defaultConfigurationName = Release;
 		};
 /* End XCConfigurationList section */
+
+/* Begin XCRemoteSwiftPackageReference section */
+		16A25DB72E5FE9060070BFFD /* XCRemoteSwiftPackageReference "ZIPFoundation" */ = {
+			isa = XCRemoteSwiftPackageReference;
+			repositoryURL = "https://github.com/weichsel/ZIPFoundation.git";
+			requirement = {
+				kind = upToNextMajorVersion;
+				minimumVersion = 0.9.19;
+			};
+		};
+		16A25DBC2E5FED820070BFFD /* XCRemoteSwiftPackageReference "ATProtoKit" */ = {
+			isa = XCRemoteSwiftPackageReference;
+			repositoryURL = "https://github.com/MasterJ93/ATProtoKit";
+			requirement = {
+				kind = upToNextMinorVersion;
+				minimumVersion = 0.31.2;
+			};
+		};
+/* End XCRemoteSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		16A25DB82E5FE9060070BFFD /* ZIPFoundation */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = 16A25DB72E5FE9060070BFFD /* XCRemoteSwiftPackageReference "ZIPFoundation" */;
+			productName = ZIPFoundation;
+		};
+		16A25DBD2E5FED820070BFFD /* ATProtoKit */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = 16A25DBC2E5FED820070BFFD /* XCRemoteSwiftPackageReference "ATProtoKit" */;
+			productName = ATProtoKit;
+		};
+/* End XCSwiftPackageProductDependency section */
 	};
 	rootObject = 16A25D702E5CA4790070BFFD /* Project object */;
 }

AtProtoBackup.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

···
+{
+  "originHash" : "c948a2b2436351963ceafb097737262a5b30543267795a77eac2492601d375be",
+  "pins" : [
+    {
+      "identity" : "atprotokit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/MasterJ93/ATProtoKit",
+      "state" : {
+        "revision" : "5048826586a661168e0a53f6758f562a28b6b0b3",
+        "version" : "0.31.2"
+      }
+    },
+    {
+      "identity" : "swift-log",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-log.git",
+      "state" : {
+        "revision" : "ce592ae52f982c847a4efc0dd881cc9eb32d29f2",
+        "version" : "1.6.4"
+      }
+    },
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftlang/swift-syntax.git",
+      "state" : {
+        "revision" : "0687f71944021d616d34d922343dcef086855920",
+        "version" : "600.0.1"
+      }
+    },
+    {
+      "identity" : "zipfoundation",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/weichsel/ZIPFoundation.git",
+      "state" : {
+        "revision" : "02b6abe5f6eef7e3cbd5f247c5cc24e246efcfe0",
+        "version" : "0.9.19"
+      }
+    }
+  ],
+  "version" : 3
+}

AtProtoBackup/ATProtocolService.swift

···
 
 struct DIDResponse: Codable {
   let did: String
+  let handle: String
+  let pds: String
 }
 
 class ATProtocolService {
···
   
   private init() {}
   
-  func lookupDID(for handle: String) async throws -> (did: String, jsonData: Data) {
+  func lookupDID(for handle: String) async throws -> (parsed: DIDResponse, jsonData: Data) {
     print("[ATProtocolService] lookupDID called with handle: '\(handle)'")
     
     guard let url = URL(string: "https://slingshot.microcosm.blue/xrpc/com.bad-example.identity.resolveMiniDoc?identifier=\(handle)") else {
···
     do {
       let didResponse = try JSONDecoder().decode(DIDResponse.self, from: data)
       print("[ATProtocolService] Successfully decoded - DID: \(didResponse.did)")
-      return (did: didResponse.did, jsonData: data)
+      return (parsed: didResponse,  jsonData: data)
     } catch {
       print("[ATProtocolService] Decoding error: \(error)")
       throw ATProtocolError.decodingError

AtProtoBackup/Account.swift

···
 
 @Model
 final class Account {
-    var did: String
-    var handle: String
-    var jsonResponse: Data?
-    
-    init(did: String, handle: String, jsonResponse: Data? = nil) {
-        print("[Account] Creating new Account - DID: \(did), Handle: \(handle)")
-        self.did = did
-        self.handle = handle
-        self.jsonResponse = jsonResponse
-    }
+  var did: String
+  var handle: String
+  var pds: String
+  var jsonResponse: Data?
+  
+  init(did: String, handle: String, pds: String, jsonResponse: Data? = nil) {
+    print("[Account] Creating new Account - DID: \(did), Handle: \(handle)")
+    self.did = did
+    self.handle = handle
+    self.pds = pds
+    self.jsonResponse = jsonResponse
+  }
 }

AtProtoBackup/AccountDetailView.swift

···
+//
+//  AccountDetailView.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/25/25.
+//
+
+import SwiftUI
+
+struct AccountDetailView: View {
+    let account: Account
+    @StateObject private var downloadManager = DownloadManager()
+    
+    var body: some View {
+        VStack(alignment: .leading, spacing: 16) {
+            Text("Account Details")
+                .font(.title2)
+                .fontWeight(.bold)
+            
+            AccountInfoSection(account: account)
+            
+            DownloadSection(account: account, downloadManager: downloadManager)
+            
+            JSONResponseSection(jsonData: account.jsonResponse)
+            
+            Spacer()
+        }
+        .padding()
+        .navigationTitle(account.handle)
+    }
+}
+
+struct AccountInfoSection: View {
+    let account: Account
+    
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            HStack {
+                Text("Handle:")
+                    .fontWeight(.semibold)
+                Text(account.handle)
+            }
+            
+            HStack {
+                Text("DID:")
+                    .fontWeight(.semibold)
+                Text(account.did)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+            }
+        }
+    }
+}
+
+#Preview {
+    AccountDetailView(
+        account: Account(
+            did: "did:plc:example",
+            handle: "user.bsky.social",
+            pds: "https://bsky.network"
+        )
+    )
+}

AtProtoBackup/AccountListItemView.swift

···
+//
+//  AccountListItemView.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/25/25.
+//
+
+import SwiftUI
+
+struct AccountListItemView: View {
+    let account: Account
+    
+    var body: some View {
+        VStack(alignment: .leading) {
+            Text(account.handle)
+                .font(.headline)
+            Text(account.did)
+                .font(.caption)
+                .foregroundColor(.secondary)
+        }
+    }
+}
+
+#Preview {
+    AccountListItemView(
+        account: Account(
+            did: "did:plc:example",
+            handle: "user.bsky.social",
+            pds: "https://bsky.network"
+        )
+    )
+}

AtProtoBackup/BlobDownloader.swift

···
+//
+//  BlobDownloader.swift
+//  shortcut
+//
+//  Created by Bailey Townsend on 7/14/25.
+//
+
+import Foundation
+import UniformTypeIdentifiers
+import ZIPFoundation
+
+// Progress event types
+public enum DownloadProgress {
+  case started(totalCIDs: Int)
+  case progressUpdate(currentCount: Int, totalCount: Int)
+  case completed(totalDownloaded: Int, zipURL: URL)
+  case failed(error: Error)
+}
+
+public actor BlobDownloader {
+  private var maxConcurrentDownloads: Int = 1
+  private var activeTasks = 0
+  private var continuation: CheckedContinuation<Void, Never>?
+  //    private var atProtocolManger: AtProtocolManager
+  
+  // Add these for task management
+  private var activeDownloadTasks: Set<Task<URL?, Error>> = []
+  private var currentDownloadTask: Task<[URL], Error>?
+  
+  // Progress tracking
+  //    private var progressContinuation: AsyncStream<DownloadProgress>.Continuation?
+  
+  // Actor for thread-safe archive writes
+  
+  //    init(maxConcurrentDownloads: Int = 2) {
+  //        self.maxConcurrentDownloads = maxConcurrentDownloads
+  //    }
+  
+  private func waitForAvailableSlot() async {
+    while activeTasks >= maxConcurrentDownloads {
+      await withCheckedContinuation { cont in
+        continuation = cont
+      }
+    }
+    activeTasks += 1
+  }
+  
+  private func releaseSlot() {
+    activeTasks -= 1
+    if let cont = continuation {
+      continuation = nil
+      cont.resume()
+    }
+  }
+  
+  // Modified downloadBlobs method with proper cleanup
+  func downloadBlobs(
+    repo: String,
+    pdsURL: String,
+    cids: [String],
+    saveLocationBookmark: Data? = nil,
+    maxConcurrentDownloads: Int = 1
+  ) async throws -> [URL] {
+    self.maxConcurrentDownloads = maxConcurrentDownloads
+    // Cancel any existing download task
+    cancelAllActiveTasks()
+    
+    // Create new download task and store reference
+    
+    //        guard let self = self else { throw BlobDownloadError.noData }
+    
+    // Check for cancellation at the start
+    try Task.checkCancellation()
+    
+    do {
+      var totalProcessed = 0
+      var totalCIDs = 0
+      var successfulDownloads = 0
+      
+      var saveLocation: URL
+      if let override = saveLocationBookmark {
+        var isStale = false
+        guard
+          let saveUrl = try? URL(
+            resolvingBookmarkData: override,
+            options: .withoutUI,
+            relativeTo: nil,
+            bookmarkDataIsStale: &isStale
+          )
+        else {
+          throw GenericIntentError.message("Failed to resolve bookmark data")
+        }
+        saveLocation = saveUrl
+      } else {
+        let tempDirectory = FileManager.default.temporaryDirectory
+        saveLocation = tempDirectory.appendingPathComponent(repo)
+        
+        do {
+          try FileManager.default.createDirectory(
+            at: saveLocation, withIntermediateDirectories: true, attributes: nil)
+        } catch CocoaError.fileWriteFileExists {
+          print("Folder already exists at: \(saveLocation.path)")
+        } catch {
+          throw error
+        }
+      }
+      
+      // Check for cancellation before processing
+      //                try Task.checkCancellation()
+      if Task.isCancelled {
+        throw CancellationError()
+      }
+      
+      totalCIDs += cids.count
+      var urls = [URL]()
+      let chunkSize = maxConcurrentDownloads
+      
+      for chunk in cids.chunked(into: chunkSize) {
+        // Check for cancellation before each chunk
+        try Task.checkCancellation()
+        
+        let newUrls = try await downloadBlobsConcurrently(
+          repo: repo,
+          pdsURL: pdsURL,
+          cids: chunk,
+          fileManager: FileManager.default,
+          saveToDirectory: saveLocation
+        )
+        urls.append(contentsOf: newUrls)
+        totalProcessed += chunk.count
+        successfulDownloads += chunk.count
+        
+        if Task.isCancelled {
+          print("Download cancelled early")
+        }
+        print("Downloaded \(totalProcessed) of \(totalCIDs) blobs")
+      }
+      
+      return urls
+      
+    } catch {
+      // Clean up on any error (including cancellation)
+      self.cancelAllActiveTasks()
+      throw error
+    }
+    
+    // Store the task reference
+    //        currentDownloadTask = downloadTask
+    //
+    //        defer {
+    //            // Clean up task reference when done
+    //            Task { [weak self] in
+    //                await self?.clearCurrentTask()
+    //            }
+    //        }
+    
+    //        return try await downloadTask.value
+  }
+  
+  public func CancelAll() {
+    self.cancelAllActiveTasks()
+  }
+  
+  // Method to cancel all active tasks
+  private func cancelAllActiveTasks() {
+    print("Cancelling all active download tasks...")
+    
+    // Cancel all individual download tasks
+    for task in activeDownloadTasks {
+      task.cancel()
+    }
+    activeDownloadTasks.removeAll()
+    
+    // Cancel current download task
+    currentDownloadTask?.cancel()
+    currentDownloadTask = nil
+    
+    // Reset active task counter
+    activeTasks = 0
+    
+    // Resume any waiting continuations
+    if let cont = continuation {
+      continuation = nil
+      cont.resume()
+    }
+  }
+  
+  private func clearCurrentTask() {
+    currentDownloadTask = nil
+  }
+  
+  // Add task tracking to downloadBlobsConcurrently
+  private func downloadBlobsConcurrently(
+    repo: String,
+    pdsURL: String,
+    cids: [String],
+    fileManager: FileManager,
+    saveToDirectory: URL
+  ) async throws -> [URL] {
+    var successCount = 0
+    var urls: [URL] = []
+    
+    try await withThrowingTaskGroup(of: URL?.self) { group in
+      for cid in cids {
+        // Check for cancellation before adding each task
+        try Task.checkCancellation()
+        
+        group.addTask { [weak self] in
+          // Create a cancellable task and track it
+          let downloadTask = Task<URL?, Error> {
+            do {
+              // Check for cancellation at start of each download
+              try Task.checkCancellation()
+              
+              let checkForUrl = findFile(
+                withBaseName: cid, inDirectory: saveToDirectory)
+              if let checkForUrl {
+                return checkForUrl
+              }
+              
+              let url = try await self?.downloadBlobWithRetry(
+                repo: repo,
+                pdsURL: pdsURL,
+                cid: cid,
+                maxRetries: 3,
+                fileManger: fileManager,
+                saveToDirectory: saveToDirectory
+              )
+              return url
+            } catch let downloadError as BlobDownloadError {
+              throw downloadError
+              
+            } catch {
+              if error is CancellationError {
+                print("Download cancelled for blob \(cid)")
+                throw error
+              } else {
+                print("Failed to download blob \(cid): \(error)")
+              }
+              return nil
+            }
+          }
+          
+          // Track the task
+          await self?.addActiveTask(downloadTask)
+          
+          let result = try await downloadTask.value
+          
+          // Remove from tracking when done
+          await self?.removeActiveTask(downloadTask)
+          
+          return result
+        }
+      }
+      
+      // Wait for all tasks to complete, but check for cancellation
+      for try await success in group {
+        try Task.checkCancellation()
+        if let url = success {
+          urls.append(url)
+          successCount += 1
+        }
+      }
+    }
+    
+    return urls
+  }
+  
+  // Helper methods for task tracking
+  private func addActiveTask(_ task: Task<URL?, Error>) {
+    activeDownloadTasks.insert(task)
+  }
+  
+  private func removeActiveTask(_ task: Task<URL?, Error>) {
+    activeDownloadTasks.remove(task)
+  }
+  
+  // Public method to cancel downloads from outside
+  //    public func cancelDownloads() async {
+  //        cancelAllActiveTasks()
+  //    }
+  
+  // Alternative: Stream large blobs to temporary files
+  
+  public func streamBlobToDisk(
+    resourceURL: URL,
+    fileManager: FileManager,
+    saveLocation: URL,
+    fileName: String
+  ) async throws -> URL {
+    try Task.checkCancellation()
+    
+    var request = URLRequest(url: resourceURL)
+    request.httpMethod = "GET"
+    request.setValue("*/*", forHTTPHeaderField: "Accept")
+    request.timeoutInterval = 30
+    
+    // Download to file instead of memory
+    let (tempURL, response) = try await URLSession.shared.download(for: request)
+    
+    if let httpResponse = response as? HTTPURLResponse {
+      switch httpResponse.statusCode {
+      case (200...299):
+        let mimeType = httpResponse.value(forHTTPHeaderField: "Content-Type") ?? ""
+        let ending = fileExtension(fromMimeType: mimeType).map { ".\($0)" } ?? ""
+        let newLocation = saveLocation.appendingPathComponent("\(fileName)\(ending)")
+        try fileManager.moveItem(
+          at: tempURL, to: newLocation)
+        return newLocation
+      case 400:
+        let (data, _) = try await URLSession.shared.data(for: request)
+        
+        let errorResponse = try JSONDecoder().decode(
+          ATHTTPResponseError.self, from: data)
+        throw BlobDownloadError.apiError(error: errorResponse)
+        
+      default:
+        try? FileManager.default.removeItem(at: tempURL)
+        throw BlobDownloadError.httpError(
+          statusCode: httpResponse.statusCode)
+      }
+    }
+    throw BlobDownloadError.unknownError
+    //    guard let httpResponse = response as? HTTPURLResponse,
+    //        (200...299).contains(httpResponse.statusCode)
+    //    else {
+    //        try? FileManager.default.removeItem(at: tempURL)
+    //        throw BlobDownloadError.httpError(
+    //            statusCode: (response as? HTTPURLResponse)?.statusCode ?? 0)
+    //    }
+    
+  }
+  
+  public func getBlob(
+    from accountDID: String,
+    cid: String,
+    fileManager: FileManager,
+    saveLocation: URL,
+    pdsURL: String? = nil
+  ) async throws -> URL {
+    let baseUrl = pdsURL ?? "https://bsky.network"
+    
+    // Construct URL with query parameters
+    guard var urlComponents = URLComponents(string: "\(baseUrl)/xrpc/com.atproto.sync.getBlob")
+    else {
+      throw BlobDownloadError.invalidURL
+    }
+    
+    urlComponents.queryItems = [
+      URLQueryItem(name: "did", value: accountDID),
+      URLQueryItem(name: "cid", value: cid),
+    ]
+    
+    guard let url = urlComponents.url else {
+      throw BlobDownloadError.invalidURL
+    }
+    
+    return try await streamBlobToDisk(
+      resourceURL: url, fileManager: fileManager, saveLocation: saveLocation, fileName: cid)
+  }
+  
+  public func getCar(
+    from accountDID: String,
+    since: String?,
+    fileManager: FileManager,
+    saveLocation: URL,
+    fileName: String = "repo.car",
+    pdsURL: String? = nil
+  ) async throws -> URL {
+    
+    let baseUrl = pdsURL ?? "https://bsky.network"
+    // Only ever one file being downloaded
+    self.maxConcurrentDownloads = 1
+    // Construct URL with query parameters
+    guard var urlComponents = URLComponents(string: "\(baseUrl)/xrpc/com.atproto.sync.getRepo")
+    else {
+      throw BlobDownloadError.invalidURL
+    }
+    
+    urlComponents.queryItems = [
+      URLQueryItem(name: "did", value: accountDID)
+      
+    ]
+    
+    if let sinceQuery = since {
+      urlComponents.queryItems?.append(URLQueryItem(name: "since", value: sinceQuery))
+    }
+    
+    guard let url = urlComponents.url else {
+      throw BlobDownloadError.invalidURL
+    }
+    
+    return try await streamBlobToDisk(
+      resourceURL: url, fileManager: fileManager, saveLocation: saveLocation,
+      fileName: fileName)
+  }
+  
+  /// Downloads a single blob with retry logic
+  public func downloadBlobWithRetry(
+    repo: String,
+    pdsURL: String,
+    cid: String,
+    maxRetries: Int,
+    fileManger: FileManager,
+    saveToDirectory: URL
+  ) async throws -> URL {
+    var lastError: Error?
+    
+    for attempt in 0..<maxRetries {
+      // Check for cancellation before each retry
+      try Task.checkCancellation()
+      
+      do {
+        if attempt > 0 {
+          // Exponential backoff
+          let delay = UInt64(pow(2.0, Double(attempt)) * 1_000_000_000)
+          try await Task.sleep(nanoseconds: delay)
+        }
+        return try await getBlob(
+          from: repo, cid: cid, fileManager: fileManger, saveLocation: saveToDirectory,
+          pdsURL: pdsURL)
+      } catch let downloadError as BlobDownloadError {
+        switch downloadError {
+        case .apiError(_):
+          throw downloadError
+        default:
+          lastError = downloadError
+          if attempt < maxRetries - 1 {
+            continue
+          }
+          break
+        }
+      } catch {
+        // If it's a cancellation error, don't retry
+        if error is CancellationError {
+          throw error
+        }
+        
+        lastError = error
+        if attempt < maxRetries - 1 {
+          continue
+        }
+        
+      }
+    }
+    
+    throw lastError
+    ?? GenericIntentError.message("Failed to download blob after \(maxRetries) attempts")
+  }
+  public struct BlobDownloadOutput {
+    public var data: Data
+    public var cid: String
+    public var mimeType: String
+  }
+  
+  // MARK: - Optimized Concurrent Blob Downloader
+  
+  public class ConcurrentBlobDownloader {
+    private let urlSession: URLSession
+    
+    public init() {
+      let config = URLSessionConfiguration.default
+      config.httpMaximumConnectionsPerHost = 10
+      config.timeoutIntervalForRequest = 30
+      config.timeoutIntervalForResource = 300
+      self.urlSession = URLSession(configuration: config)
+    }
+    
+  }
+  
+}
+
+public func fileExtension(fromMimeType mimeType: String) -> String? {
+  guard let utType = UTType(mimeType: mimeType) else { return nil }
+  return utType.preferredFilenameExtension
+}
+
+// MARK: - Helper Extensions
+
+extension Array {
+  /// Splits array into chunks of specified size
+  func chunked(into size: Int) -> [[Element]] {
+    return stride(from: 0, to: count, by: size).map {
+      Array(self[$0..<Swift.min($0 + size, count)])
+    }
+  }
+}
+
+/// An error type related to issues surrounding HTTP responses.
+public struct ATHTTPResponseError: Decodable {
+  
+  /// The name of the error.
+  public let error: String
+  
+  /// The message for the error.
+  public let message: String
+}
+
+func findFile(withBaseName baseName: String, inDirectory directory: URL) -> URL? {
+  let fileManager = FileManager.default
+  
+  do {
+    let contents = try fileManager.contentsOfDirectory(
+      at: directory, includingPropertiesForKeys: nil)
+    
+    // Find the first file that matches the base name
+    return contents.first { fileURL in
+      let fileNameWithoutExtension = fileURL.deletingPathExtension().lastPathComponent
+      return fileNameWithoutExtension == baseName
+    }
+  } catch {
+    print("Error reading directory: \(error)")
+    return nil
+  }
+}
+
+public enum BlobDownloadError: Error {
+  case invalidURL
+  case networkError(Error)
+  case noData
+  case httpError(statusCode: Int)
+  case unknownError
+  case apiError(error: ATHTTPResponseError)
+  
+}

AtProtoBackup/ContentView.swift

···
       List {
         ForEach(items) { item in
           NavigationLink {
-            VStack(alignment: .leading, spacing: 16) {
-              Text("Account Details")
-                .font(.title2)
-                .fontWeight(.bold)
-              
-              VStack(alignment: .leading, spacing: 8) {
-                HStack {
-                  Text("Handle:")
-                    .fontWeight(.semibold)
-                  Text(item.handle)
-                }
-                
-                HStack {
-                  Text("DID:")
-                    .fontWeight(.semibold)
-                  Text(item.did)
-                    .lineLimit(1)
-                    .truncationMode(.middle)
-                }
-              }
-              
-              if let jsonData = item.jsonResponse {
-                VStack(alignment: .leading, spacing: 8) {
-                  Text("JSON Response:")
-                    .font(.headline)
-                  
-                  ScrollView {
-                    if let jsonObject = try? JSONSerialization.jsonObject(with: jsonData),
-                       let prettyData = try? JSONSerialization.data(withJSONObject: jsonObject, options: [.prettyPrinted]),
-                       let prettyString = String(data: prettyData, encoding: .utf8) {
-                      Text(prettyString)
-                        .font(.system(.body, design: .monospaced))
-                        .textSelection(.enabled)
-                        .padding()
-                        .background(Color.gray.opacity(0.1))
-                        .cornerRadius(8)
-                    } else {
-                      Text("Unable to decode JSON data")
-                        .foregroundColor(.secondary)
-                    }
-                  }
-                }
-              } else {
-                Text("No JSON response available")
-                  .foregroundColor(.secondary)
-              }
-              
-              Spacer()
-            }
-            .padding()
-            .navigationTitle(item.handle)
+            AccountDetailView(account: item)
           } label: {
-            VStack(alignment: .leading) {
-              Text(item.handle)
-                .font(.headline)
-              Text(item.did)
-                .font(.caption)
-                .foregroundColor(.secondary)
-            }
+            AccountListItemView(account: item)
           }
         }
         .onDelete(perform: deleteItems)
···
           }
         }
       }
-      
-      
-      
     } detail: {
       Text("Select an item")
-    }.alert("Add AT Protocol Account", isPresented: $showingAlert, actions:  {
+    }
+    .alert("Add AT Protocol Account", isPresented: $showingAlert) {
       TextField("Enter handle (e.g., user.bsky.social)", text: $inputText)
       Button("Add") {
         print("[ContentView] Add button in alert pressed")
···
         inputText = ""
         errorMessage = nil
       }
-    }, message: {
+    } message: {
       if let errorMessage = errorMessage {
         Text(errorMessage)
       } else if isLoading {
···
       } else {
         Text("Enter your AT Protocol handle")
       }
-    })
-    
+    }
   }
   
   
···
     
     do {
       print("[ContentView] Starting API lookup...")
-      let (did, jsonData) = try await ATProtocolService.shared.lookupDID(for: inputText)
-      print("[ContentView] API lookup successful - DID: \(did)")
+      let (parsed, jsonData) = try await ATProtocolService.shared.lookupDID(for: inputText)
+      print("[ContentView] API lookup successful - DID: \(parsed.did)")
       
       await MainActor.run {
         print("[ContentView] Creating and inserting Account object")
         withAnimation {
-          let account = Account(did: did, handle: inputText, jsonResponse: jsonData)
+          let account = Account(did: parsed.did, handle: inputText, pds: parsed.pds, jsonResponse: jsonData)
           modelContext.insert(account)
           print("[ContentView] Account inserted into modelContext")
         }

AtProtoBackup/DownloadManager.swift

···
+//
+//  DownloadManager.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/25/25.
+//
+
+import SwiftUI
+import Combine
+import ATProtoKit
+
+struct DownloadInfo: Identifiable {
+  let id = UUID()
+  let accountID: String
+  var progress: Double = 0
+  var totalBlobs: Int?
+  var isDownloading: Bool = false
+  var blobDownloader: Bool = false
+}
+
+class DownloadManager: ObservableObject {
+  @Published private var downloads: [String: DownloadInfo] = [:]
+  private let blobDownloader = BlobDownloader()
+  
+  func getDownload(for account: Account) -> DownloadInfo? {
+    downloads[account.did]
+  }
+  
+  func startDownload(for account: Account) {
+    let accountDid = account.did
+    if downloads[account.did] == nil {
+      downloads[account.did] = DownloadInfo(accountID: account.did)
+    }
+
+    
+    Task {
+      await MainActor.run {
+        downloads[accountDid]?.isDownloading = true
+      }
+      
+      do {
+        let tempDirectory = FileManager.default.temporaryDirectory
+        let saveLocation = tempDirectory.appendingPathComponent(account.did)
+        
+        print("Saving to \(saveLocation.path)")
+        
+        let date = Date()
+        let formatter = ISO8601DateFormatter()
+        let utcString = formatter.string(from: date)
+        let fileName = "\(account.handle)-\(utcString).car"
+        
+        do {
+          try FileManager.default.createDirectory(
+            at: saveLocation, withIntermediateDirectories: true, attributes: nil)
+        } catch CocoaError.fileWriteFileExists {
+          print("Folder already exists at: \(saveLocation.path)")
+        } catch {
+          throw error
+        }
+        
+        let result = try await blobDownloader.getCar(from: account.did, since: nil, fileManager: FileManager.default, saveLocation: saveLocation, fileName: fileName, pdsURL: account.pds)
+        
+        print("All Done! \(result)")
+        
+        //        let config = ATProtocolConfiguration(pdsURL: account.pds)
+        
+        //        let atProtoKit = await ATProtoKit(sessionConfiguration: config, pdsURL: account.pds)
+        
+        var allBlobCids: [String] = []
+        var cursor: String? = nil
+        
+        repeat {
+          let blobsResponse = try await listBlobs(from: account.did, pds: account.pds, sinceRevision: nil, cursor: cursor)
+          allBlobCids.append(contentsOf: blobsResponse.accountCIDs)
+          cursor = blobsResponse.cursor
+          print("Listed \(blobsResponse.accountCIDs.count) blob cids, total: \(allBlobCids.count)")
+        } while cursor != nil
+        
+        print("List all \(allBlobCids.count) blob cids")
+        let totalCount: Int = allBlobCids.count
+        await MainActor.run {
+          downloads[accountDid]?.totalBlobs = totalCount
+        }
+        
+//        guard let saveUrl = saveLocation.fileURL else {
+//          throw GenericIntentError.message(
+//            "Was not able to get a valid url for the save location")
+//        }
+        let didStartAccessing = saveLocation.startAccessingSecurityScopedResource()
+        defer {
+          if didStartAccessing {
+            saveLocation.stopAccessingSecurityScopedResource()
+          }
+        }
+        var bookmarkData: Data?
+        if didStartAccessing {
+          do {
+            bookmarkData = try saveLocation.bookmarkData(
+              options: .minimalBookmark,
+              includingResourceValuesForKeys: nil,
+              relativeTo: nil
+            )
+          } catch {
+            print("Failed to create bookmark: \(error)")
+          }
+        }
+        
+        let _ = try await blobDownloader.downloadBlobs(repo: account.did, pdsURL: account.pds, cids: allBlobCids, saveLocationBookmark: bookmarkData)
+        
+      } catch {
+        print("Download error: \(error)")
+        await MainActor.run {
+          downloads[accountDid]?.isDownloading = false
+        }
+      }
+    }
+    
+    func listBlobs(
+      from repositoryDID: String,
+      pds: String,
+      sinceRevision: String?,
+      limit: Int? = 500,
+      cursor: String? = nil
+    ) async throws -> ComAtprotoLexicon.Sync.ListBlobsOutput {
+      guard let requestURL = URL(string: pds + "/xrpc/com.atproto.sync.listBlobs") else {
+        throw ATProtocolError.invalidURL
+      }
+      
+      var queryItems = [(String, String)]()
+      
+      queryItems.append(("did", repositoryDID))
+      
+      if let sinceRevision {
+        queryItems.append(("since", sinceRevision))
+      }
+      
+      if let limit {
+        let finalLimit = max(1, min(limit, 1_000))
+        queryItems.append(("limit", "\(finalLimit)"))
+      }
+      
+      if let cursor {
+        queryItems.append(("cursor", cursor))
+      }
+      
+      var components = URLComponents(url: requestURL, resolvingAgainstBaseURL: true)!
+      components.queryItems = queryItems.map { URLQueryItem(name: $0.0, value: $0.1) }
+      
+      guard let queryURL = components.url else {
+        throw ATProtocolError.invalidURL
+      }
+      
+      var request = URLRequest(url: queryURL)
+      request.httpMethod = "GET"
+      request.setValue("application/vnd.ipld.car", forHTTPHeaderField: "Accept")
+      
+      let (data, response) = try await URLSession.shared.data(for: request)
+      
+      guard let httpResponse = response as? HTTPURLResponse,
+            (200...299).contains(httpResponse.statusCode) else {
+        throw ATProtocolError.invalidResponse
+      }
+      
+      let decoder = JSONDecoder()
+      return try decoder.decode(ComAtprotoLexicon.Sync.ListBlobsOutput.self, from: data)
+    }
+  }
+}

AtProtoBackup/DownloadSection.swift

···
+//
+//  DownloadSection.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/25/25.
+//
+
+import SwiftUI
+
+struct DownloadSection: View {
+    let account: Account
+    @ObservedObject var downloadManager: DownloadManager
+
+    var body: some View {
+        VStack(spacing: 12) {
+            Button(action: {
+                downloadManager.startDownload(for: account)
+            }) {
+                HStack {
+                    Image(systemName: "arrow.down.circle.fill")
+                    Text("Download Backup")
+                }
+                .padding(.horizontal, 16)
+                .padding(.vertical, 8)
+                .background(Color.blue)
+                .foregroundColor(.white)
+                .cornerRadius(8)
+            }
+            .buttonStyle(PlainButtonStyle())
+
+            if let download = downloadManager.getDownload(for: account) {
+                DownloadStatusView(download: download, account: account, downloadManager: downloadManager)
+            }
+        }
+    }
+}
+
+struct DownloadStatusView: View {
+    let download: DownloadInfo
+    let account: Account
+    @ObservedObject var downloadManager: DownloadManager
+
+    var body: some View {
+        VStack(spacing: 8) {
+            if download.isDownloading {
+                ProgressView(value: download.progress) {
+                    Text("Downloading... \(Int(download.progress * 100))%")
+                        .font(.caption)
+                }
+                .progressViewStyle(LinearProgressViewStyle())
+            } else if download.progress > 0 && download.progress < 1.0 {
+                HStack {
+                    Text("Download paused at \(Int(download.progress * 100))%")
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+
+                    Button("Resume") {
+                        downloadManager.startDownload(for: account)
+                    }
+                    .buttonStyle(BorderedButtonStyle())
+                }
+            } else if download.progress >= 1.0 {
+                HStack {
+                    Image(systemName: "checkmark.circle.fill")
+                        .foregroundColor(.green)
+                    Text("Download complete")
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                }
+            }
+        }
+    }
+}

AtProtoBackup/ErrorHandling.swift

···
+//
+//  ErrorHandling.swift
+//  shortcut
+//
+//  Created by Bailey Townsend on 6/29/25.
+//
+import Foundation
+
+enum GenericIntentError: Error, CustomLocalizedStringResourceConvertible, LocalizedError {
+    case general
+    case message(_ message: String)
+    case notFound(_ lostItem: String)
+
+    var localizedStringResource: LocalizedStringResource {
+        switch self {
+            case let .message(message): return "\(message)"
+            case .general: return "There was an error making the post."
+            case let .notFound(lostItem): return "\(lostItem) could not be found"
+        }
+    }
+}

AtProtoBackup/JSONResponseSection.swift

···
+//
+//  JSONResponseSection.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/25/25.
+//
+
+import SwiftUI
+
+struct JSONResponseSection: View {
+    let jsonData: Data?
+    
+    var body: some View {
+        if let jsonData = jsonData {
+            VStack(alignment: .leading, spacing: 8) {
+                Text("JSON Response:")
+                    .font(.headline)
+                
+                ScrollView {
+                    if let jsonObject = try? JSONSerialization.jsonObject(with: jsonData),
+                       let prettyData = try? JSONSerialization.data(withJSONObject: jsonObject, options: [.prettyPrinted]),
+                       let prettyString = String(data: prettyData, encoding: .utf8) {
+                        Text(prettyString)
+                            .font(.system(.body, design: .monospaced))
+                            .textSelection(.enabled)
+                            .padding()
+                            .background(Color.gray.opacity(0.1))
+                            .cornerRadius(8)
+                    } else {
+                        Text("Unable to decode JSON data")
+                            .foregroundColor(.secondary)
+                    }
+                }
+            }
+        } else {
+            Text("No JSON response available")
+                .foregroundColor(.secondary)
+        }
+    }
+}