crossmate

DiagnosticsView.swift (14186B)

---

 import CloudKit
 import LinkPresentation
 import SwiftUI
 import UIKit
 import UniformTypeIdentifiers
 
 private enum TimestampTimeZone {
     case local
     case utc
 }
 
 private enum TimestampFormatter {
     private static let localFormatter: DateFormatter = {
         let formatter = DateFormatter()
         formatter.dateStyle = .none
         formatter.timeStyle = .medium
         return formatter
     }()
 
     private static let utcFormatter: DateFormatter = {
         let formatter = DateFormatter()
         formatter.dateStyle = .none
         formatter.timeStyle = .medium
         formatter.dateFormat = "h:mm:ss a 'UTC'"
         formatter.timeZone = TimeZone(secondsFromGMT: 0)
         return formatter
     }()
 
     static func string(from date: Date, in timeZone: TimestampTimeZone) -> String {
         switch timeZone {
         case .local:
             return localFormatter.string(from: date)
         case .utc:
             return utcFormatter.string(from: date)
         }
     }
 }
 
 struct DiagnosticsView: View {
     @Environment(\.syncEngine) private var syncEngine
     @Environment(SyncMonitor.self) private var syncMonitor
     @Environment(EventLog.self) private var eventLog
 
     @State private var isSyncing = false
     @State private var isAuditingStorage = false
 
     /// The on-screen list is a quick glance, not the archive — the buffer now
     /// spans a full day (tens of thousands of entries during a co-solve), and
     /// rendering it all just buries the tail. The shared file keeps everything.
     private let visibleEventLimit = 50
 
     var body: some View {
         List {
             Section("Status") {
                 row("Version", versionText)
                 row("Account Status", accountStatusText)
                 row("Engine Running", boolText(syncMonitor.snapshot?.engineRunning))
                 row("Pending Changes", syncMonitor.snapshot.map { String($0.pendingChangesCount) } ?? "Unknown")
                 row("Sharing Health", sharingHealthText)
                 row(
                     "Last Success",
                     syncMonitor.lastSuccessAt.map { TimestampFormatter.string(from: $0, in: .local) } ?? "None"
                 )
                 row("Last Error Phase", syncMonitor.lastErrorPhase ?? "None")
                 row("Last Error Domain", syncMonitor.lastErrorDomain ?? "None")
                 row(
                     "Last Error Code",
                     syncMonitor.lastErrorCode.map(String.init) ?? "None"
                 )
                 row("Last Error Description", syncMonitor.lastErrorDescription ?? "None")
             }
 
             Section("Actions") {
                 Button {
                     Task { await runFullSync() }
                 } label: {
                     HStack {
                         Text("Sync Now")
                         if isSyncing {
                             Spacer()
                             ProgressView()
                         }
                     }
                 }
                 .disabled(isSyncing || isAuditingStorage)
 
                 Button("Probe Container") {
                     Task { await probeContainer() }
                 }
                 .disabled(isSyncing || isAuditingStorage)
 
                 Button {
                     Task { await auditCloudStorage() }
                 } label: {
                     HStack {
                         Text("Audit Cloud Storage")
                         if isAuditingStorage {
                             Spacer()
                             ProgressView()
                         }
                     }
                 }
                 .disabled(isSyncing || isAuditingStorage)
 
                 Button("Reset Sync State", role: .destructive) {
                     Task { await resetSyncState() }
                 }
                 .disabled(isSyncing || isAuditingStorage)
             }
 
             Section {
                 if eventLog.entries.isEmpty {
                     Text("No events captured yet.")
                         .foregroundStyle(.secondary)
                 } else {
                     ForEach(eventLog.entries.suffix(visibleEventLimit).reversed()) { entry in
                         VStack(alignment: .leading, spacing: 4) {
                             Text(
                                 "\(TimestampFormatter.string(from: entry.timestamp, in: .local)) [\(entry.level.uppercased())]"
                             )
                             .font(.caption.monospaced())
                             .foregroundStyle(.secondary)
 
                             Text(entry.message)
                                 .font(.caption.monospaced())
                                 .textSelection(.enabled)
                         }
                         .padding(.vertical, 2)
                     }
                 }
             } header: {
                 Text("Recent Events")
             } footer: {
                 if eventLog.entries.count > visibleEventLimit {
                     Text("Showing the last \(visibleEventLimit) of \(eventLog.entries.count) events. Share Full Log includes the complete history.")
                 }
             }
         }
         .navigationTitle("Diagnostics Log")
         .navigationBarTitleDisplayMode(.inline)
         .toolbar {
             ToolbarItemGroup(placement: .topBarTrailing) {
                 DiagnosticsShareButton(snapshot: { diagnosticDump })
             }
         }
         .task {
             guard let syncEngine else { return }
             let snapshot = await syncEngine.diagnosticSnapshot()
             syncMonitor.updateSnapshot(snapshot)
         }
     }
 
     // MARK: - Actions
 
     private func resetSyncState() async {
         guard let syncEngine else { return }
         await syncEngine.resetSyncState()
         syncMonitor.note("Sync state reset (zone/subscription flags and tokens cleared)")
         let snapshot = await syncEngine.diagnosticSnapshot()
         syncMonitor.updateSnapshot(snapshot)
     }
 
     private func probeContainer() async {
         guard let syncEngine else { return }
         syncMonitor.note("starting container probe")
         let results = await syncEngine.probeContainer()
         for (name, result) in results {
             syncMonitor.note("probe[\(name)]: \(result)")
         }
         syncMonitor.note("Container probe complete")
     }
 
     private func auditCloudStorage() async {
         guard !isAuditingStorage, let syncEngine else { return }
         isAuditingStorage = true
         defer { isAuditingStorage = false }
 
         await syncEngine.auditPrivateCloudStorage { message in
             syncMonitor.note(message)
         }
     }
 
     private func runFullSync() async {
         guard !isSyncing, let syncEngine else { return }
         isSyncing = true
         defer { isSyncing = false }
 
         await syncMonitor.run("manual fetch") {
             try await syncEngine.fetchChanges()
         }
         await syncMonitor.run("manual private ping fetch") {
             _ = try await syncEngine.fetchPushPingsDirect(scope: .private)
         }
         await syncMonitor.run("manual shared ping fetch") {
             _ = try await syncEngine.fetchPushPingsDirect(scope: .shared)
         }
         await syncMonitor.run("manual push") {
             try await syncEngine.pushChanges()
         }
         let snapshot = await syncEngine.diagnosticSnapshot()
         syncMonitor.updateSnapshot(snapshot)
     }
 
     // MARK: - Subviews
 
     @ViewBuilder
     private func row(_ title: String, _ value: String) -> some View {
         VStack(alignment: .leading, spacing: 4) {
             Text(title)
                 .font(.caption)
                 .foregroundStyle(.secondary)
             Text(value)
                 .font(.body.monospaced())
                 .textSelection(.enabled)
         }
         .padding(.vertical, 2)
     }
 
     private var accountStatusText: String { DiagnosticsReport.accountStatusText(syncMonitor) }
 
     private func boolText(_ value: Bool?) -> String { DiagnosticsReport.boolText(value) }
 
     private var sharingHealthText: String {
         guard let snapshot = syncMonitor.snapshot else { return "Unknown" }
         guard snapshot.engineRunning, snapshot.accountStatus == .available else {
             return "Unavailable"
         }
         let count = snapshot.pendingInvitationCount
         return count == 0
             ? "Ready"
             : "\(count) invitation\(count == 1 ? "" : "s") waiting for CloudKit"
     }
 
     private var versionText: String { DiagnosticsReport.versionText }
 
     private var diagnosticDump: DiagnosticsDump {
         DiagnosticsReport.dump(syncMonitor: syncMonitor, eventLog: eventLog)
     }
 }
 
 /// The share button, in UIKit deliberately. SwiftUI's `ShareLink` resolves its
 /// item — for a file, render *and* disk write — before it will present the
 /// sheet, which put a count-the-seconds stall between the tap and the menu.
 /// `UIActivityViewController` + a promised `NSItemProvider` has the semantics
 /// the button needs: the sheet presents instantly (the configuration's
 /// metadata provider titles the header without loading the item), and the
 /// promised representation is loaded on a background queue only once the user
 /// picks an activity — the render cost lands inside the chosen activity's own
 /// progress UI, where a wait reads as normal instead of broken.
 ///
 /// The button must be the UIKit view itself (a presentation anchor hidden
 /// behind a native toolbar Button never gets installed in the window —
 /// toolbars drop button backgrounds), so it mimics the toolbar's native
 /// styling instead: intrinsic sizing via `sizeThatFits` and the label-colour
 /// tint the surrounding monochrome toolbar items use.
 private struct DiagnosticsShareButton: UIViewRepresentable {
     /// Runs at tap time on the main actor; must stay cheap (header strings
     /// plus a copy-on-write take of the entries buffer).
     let snapshot: @MainActor () -> DiagnosticsDump
 
     func makeUIView(context: Context) -> UIButton {
         let button = UIButton(type: .system)
         button.setImage(UIImage(systemName: "square.and.arrow.up"), for: .normal)
         button.tintColor = .label
         button.accessibilityLabel = "Share Full Log"
         button.addAction(
             UIAction { [snapshot, weak button] _ in
                 MainActor.assumeIsolated {
                     guard let button else { return }
                     let configuration = DiagnosticsShareItem.configuration(for: snapshot())
                     let controller = UIActivityViewController(activityItemsConfiguration: configuration)
                     // iPad presents the share sheet as a popover and traps
                     // without an anchor.
                     if let popover = controller.popoverPresentationController {
                         popover.sourceView = button
                         popover.sourceRect = button.bounds
                     }
                     var presenter = button.window?.rootViewController
                     while let presented = presenter?.presentedViewController {
                         presenter = presented
                     }
                     presenter?.present(controller, animated: true)
                 }
             },
             for: .touchUpInside
         )
         return button
     }
 
     func updateUIView(_ uiView: UIButton, context: Context) {}
 
     func sizeThatFits(
         _ proposal: ProposedViewSize,
         uiView: UIButton,
         context: Context
     ) -> CGSize? {
         uiView.intrinsicContentSize
     }
 }
 
 /// Renders the diagnostics dump only after the user picks an activity in the
 /// share sheet — the promised data representation is not loaded before then.
 /// The dump inputs are snapshotted at tap time, so the file reflects the log
 /// as the user saw it.
 ///
 /// The item is a promise rather than a concrete `file:` URL on purpose:
 /// Save to Files treats a raw URL item as "copy this exact file" and pins its
 /// name, whereas a promised representation is a file the destination creates,
 /// so the sheet's rename field works, with `suggestedName` carrying the name.
 ///
 /// The promise must be *data*, not a file. The share sheet fails to grant
 /// consumers a sandbox extension for a promised file's URL (Apple DTS,
 /// developer.apple.com/forums/thread/714354), so a promised file
 /// representation makes Save to Files dismiss without saving and share
 /// extensions fail to load the attachment. A data promise crosses to the
 /// consumer directly and the consumer writes its own file, so no sandbox
 /// handoff is involved.
 private enum DiagnosticsShareItem {
     private static let fileName = "crossmate-diagnostics.txt"
 
     static func configuration(for dump: DiagnosticsDump) -> UIActivityItemsConfiguration {
         let provider = NSItemProvider()
         provider.suggestedName = fileName
         // Registered as generic data, not .plainText: messaging apps classify
         // a plain-text item as message text — Signal loads it as a string and
         // packages an oversize-text attachment under its own name, ignoring
         // suggestedName. A generic-data item routes through their file path,
         // where the materialised file keeps the suggested name. The .txt in
         // suggestedName still types the file at its destination.
         provider.registerDataRepresentation(for: .data, visibility: .all) { completion in
             completion(Data(dump.rendered().utf8), nil)
             return nil
         }
 
         let configuration = UIActivityItemsConfiguration(itemProviders: [provider])
         // Without metadata the sheet has nothing to title its header with
         // until the promise is loaded; supply it up front so presenting stays
         // instant and the header never shows a placeholder name.
         configuration.metadataProvider = { key in
             switch key {
             case .title:
                 return fileName
             case .linkPresentationMetadata:
                 let metadata = LPLinkMetadata()
                 metadata.title = fileName
                 return metadata
             default:
                 return nil
             }
         }
         return configuration
     }
 }