Now we fetch the mini did doc from slingshot

AtProtoBackup/ATProtocolService.swift

···
+//
+//  ATProtocolService.swift
+//  AtProtoBackup
+//
+//  Created by Assistant on 8/26/25.
+//
+
+import Foundation
+
+struct DIDResponse: Codable {
+  let did: String
+}
+
+class ATProtocolService {
+  static let shared = ATProtocolService()
+  
+  private init() {}
+  
+  func lookupDID(for handle: String) async throws -> (did: String, 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 {
+      print("[ATProtocolService] Failed to create URL")
+      throw ATProtocolError.invalidURL
+    }
+    
+    print("[ATProtocolService] Making request to: \(url)")
+    let (data, response) = try await URLSession.shared.data(from: url)
+    
+    print("[ATProtocolService] Received response")
+    
+    guard let httpResponse = response as? HTTPURLResponse else {
+      print("[ATProtocolService] Response is not HTTPURLResponse")
+      throw ATProtocolError.invalidResponse
+    }
+    
+    print("[ATProtocolService] HTTP Status Code: \(httpResponse.statusCode)")
+    
+    guard httpResponse.statusCode == 200 else {
+      print("[ATProtocolService] Non-200 status code")
+      throw ATProtocolError.invalidResponse
+    }
+    
+    print("[ATProtocolService] Response data length: \(data.count) bytes")
+    print("[ATProtocolService] Raw response: \(String(data: data, encoding: .utf8) ?? "Unable to decode as UTF-8")")
+    
+    do {
+      let didResponse = try JSONDecoder().decode(DIDResponse.self, from: data)
+      print("[ATProtocolService] Successfully decoded - DID: \(didResponse.did)")
+      return (did: didResponse.did, jsonData: data)
+    } catch {
+      print("[ATProtocolService] Decoding error: \(error)")
+      throw ATProtocolError.decodingError
+    }
+  }
+}
+
+enum ATProtocolError: LocalizedError {
+  case invalidURL
+  case invalidResponse
+  case decodingError
+  
+  var errorDescription: String? {
+    switch self {
+    case .invalidURL:
+      return "Invalid URL"
+    case .invalidResponse:
+      return "Invalid response from server"
+    case .decodingError:
+      return "Failed to decode response"
+    }
+  }
+}

AtProtoBackup/Account.swift

···
 @Model
 final class Account {
     var did: String
+    var handle: String
+    var jsonResponse: Data?
     
-    init(did: String) {
+    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
     }
 }

AtProtoBackup/AtProtoBackup.entitlements

···
 	<true/>
 	<key>com.apple.security.files.user-selected.read-only</key>
 	<true/>
+	<key>com.apple.security.network.client</key>
+	<true/>
 </dict>
 </plist>

AtProtoBackup/AtProtoBackupApp.swift

···
         let schema = Schema([
             Account.self,
         ])
-        let modelConfiguration = ModelConfiguration(schema: schema, isStoredInMemoryOnly: false)
+        let modelConfiguration = ModelConfiguration(schema: schema, isStoredInMemoryOnly: true)
 
         do {
             return try ModelContainer(for: schema, configurations: [modelConfiguration])

AtProtoBackup/ContentView.swift

···
   @Query private var items: [Account]
   @State private var showingAlert = false
   @State private var inputText = ""
+  @State private var isLoading = false
+  @State private var errorMessage: String?
   
   var body: some View {
     NavigationSplitView {
       List {
         ForEach(items) { item in
           NavigationLink {
-            Text("Item at \(item.did)")
+            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)
           } label: {
-            Text(item.did)
+            VStack(alignment: .leading) {
+              Text(item.handle)
+                .font(.headline)
+              Text(item.did)
+                .font(.caption)
+                .foregroundColor(.secondary)
+            }
           }
         }
         .onDelete(perform: deleteItems)
···
       
     } detail: {
       Text("Select an item")
-    }.alert("Test", isPresented: $showingAlert, actions:  {
-      TextField("Type something...", text: $inputText)
-      Button("OK") {
-        print("User entered: \(inputText)")
-        showingAlert = false
-        withAnimation {
-          modelContext.insert(Account(did:  inputText))
+    }.alert("Add AT Protocol Account", isPresented: $showingAlert, actions:  {
+      TextField("Enter handle (e.g., user.bsky.social)", text: $inputText)
+      Button("Add") {
+        print("[ContentView] Add button in alert pressed")
+        Task {
+          await lookupAndAddAccount()
         }
       }
-      Button("Cancel", role: .cancel) { }
+      Button("Cancel", role: .cancel) {
+        inputText = ""
+        errorMessage = nil
+      }
+    }, message: {
+      if let errorMessage = errorMessage {
+        Text(errorMessage)
+      } else if isLoading {
+        Text("Looking up DID...")
+      } else {
+        Text("Enter your AT Protocol handle")
+      }
     })
     
   }
   
   
   private func addItem() {
+    print("[ContentView] Add button clicked")
+    inputText = ""
+    errorMessage = nil
     showingAlert = true
+  }
+  
+  private func lookupAndAddAccount() async {
+    print("[ContentView] lookupAndAddAccount called with handle: '\(inputText)'")
+    isLoading = true
+    errorMessage = nil
     
-    
-    
+    do {
+      print("[ContentView] Starting API lookup...")
+      let (did, jsonData) = try await ATProtocolService.shared.lookupDID(for: inputText)
+      print("[ContentView] API lookup successful - DID: \(did)")
+      
+      await MainActor.run {
+        print("[ContentView] Creating and inserting Account object")
+        withAnimation {
+          let account = Account(did: did, handle: inputText, jsonResponse: jsonData)
+          modelContext.insert(account)
+          print("[ContentView] Account inserted into modelContext")
+        }
+        showingAlert = false
+        inputText = ""
+        isLoading = false
+        print("[ContentView] Alert dismissed, operation complete")
+      }
+    } catch {
+      print("[ContentView] Error during lookup: \(error)")
+      await MainActor.run {
+        errorMessage = "Error: \(error.localizedDescription)"
+        isLoading = false
+      }
+    }
   }
   
   private func deleteItems(offsets: IndexSet) {