Project Structure

@main
struct R2VaultApp: App {
    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    @State private var viewModel: AppViewModel
    @State private var menuBarManager: MenuBarManager
    
    init() {
        let vm = AppViewModel()
        _viewModel = State(initialValue: vm)
        _menuBarManager = State(initialValue: MenuBarManager(viewModel: vm))
    }
    
    var body: some Scene {
        WindowGroup(id: "main") {
            ContentView()
                .environment(viewModel)
        }
        .defaultSize(width: 800, height: 560)
        .windowResizability(.contentMinSize)
        
        Settings {
            SettingsView()
                .environment(viewModel)
        }
    }
}

struct R2Credentials: Sendable, Codable, Equatable, Identifiable {
    var id: UUID
    var accountId: String
    var accessKeyId: String
    var secretAccessKey: String
    var bucketName: String
    var customDomain: String?
    
    var endpoint: URL {
        URL(string: "https://\(accountId).r2.cloudflarestorage.com")!
    }
    
    func publicURL(forKey key: String) -> URL {
        if let customDomain, !customDomain.isEmpty,
           let base = URL(string: customDomain) {
            return base.appendingPathComponent(key)
        }
        return endpoint
            .appendingPathComponent(bucketName)
            .appendingPathComponent(key)
    }
}

struct R2Object: Identifiable, Sendable {
    let id: UUID
    let key: String           // Full path: "photos/vacation/image.jpg"
    let size: Int64           // Bytes
    let lastModified: Date?
    let isFolder: Bool
    
    var name: String {
        // Extract filename/folder name from key
        let components = key.split(separator: "/")
        return String(components.last ?? "")
    }
}

@Observable
final class FileUploadTask: Identifiable {
    let id: UUID
    let fileName: String
    let fileSize: Int64
    let fileURL: URL
    
    var progress: Double = 0
    var status: Status = .pending
    var errorMessage: String?
    var resultURL: URL?
    var uploadKey: String?              // Target R2 key
    var parentFolderBookmark: Data?     // Security-scoped bookmark
    var fileBookmark: Data?
    var uploadTask: Task<Void, Never>?  // For cancellation
    
    enum Status: Sendable {
        case pending, uploading, completed, failed, cancelled
    }
}

struct UploadItem: Identifiable, Codable, Sendable {
    let id: UUID
    let timestamp: Date
    let fileName: String
    let fileSize: Int64
    let r2Key: String
    let publicURL: URL
}

nonisolated enum AWSV4Signer {
    static func sign(
        request: URLRequest,
        credentials: R2Credentials,
        payloadHash: String = "UNSIGNED-PAYLOAD",
        date: Date = Date()
    ) -> URLRequest {
        // 1. Build canonical request
        // 2. Create string to sign
        // 3. Derive signing key (HMAC chain)
        // 4. Compute signature
        // 5. Add Authorization header
    }
    
    static func presignedURL(
        for key: String,
        credentials: R2Credentials,
        expiresIn: Int = 3600
    ) -> URL? {
        // Generates signed URL valid for expiresIn seconds
    }
}

nonisolated enum R2UploadService {
    static func upload(
        fileURL: URL,
        credentials: R2Credentials,
        key: String,
        contentType: String,
        onProgress: @MainActor @escaping @Sendable (Int64, Int64) -> Void
    ) async throws -> UploadResult {
        // 1. Build PUT request
        // 2. Sign with AWSV4Signer
        // 3. Upload with progress tracking
        // 4. Return HTTP status + body
    }
}

nonisolated enum R2BrowseService {
    // List files and folders at a prefix
    static func listObjects(
        credentials: R2Credentials, 
        prefix: String = ""
    ) async throws -> ListResult
    
    // Create a virtual folder (zero-byte object with trailing slash)
    static func createFolder(
        credentials: R2Credentials, 
        folderKey: String
    ) async throws
    
    // Delete a single object
    static func deleteObject(
        credentials: R2Credentials, 
        key: String
    ) async throws
    
    // Recursively list all keys under a prefix
    static func listAllKeys(
        credentials: R2Credentials, 
        prefix: String
    ) async throws -> [String]
}

@MainActor
final class MenuBarManager: NSObject {
    private var statusItem: NSStatusItem!
    private var popover: NSPopover!
    private let viewModel: AppViewModel
    
    init(viewModel: AppViewModel) {
        self.viewModel = viewModel
        super.init()
        setupStatusItem()    // Create menu bar icon
        setupPopover()       // Create popover with SwiftUI content
    }
}

actor ThumbnailCache {
    static let shared = ThumbnailCache()
    
    private let memoryCache = NSCache<NSString, NSImage>()
    private let diskCacheURL: URL
    private var inFlight: [String: Task<NSImage?, Never>] = [:]
    
    func thumbnail(
        for key: String, 
        credentials: R2Credentials
    ) async -> NSImage? {
        // 1. Check memory cache
        // 2. Check disk cache
        // 3. Fetch from R2 via presigned URL
        // 4. Generate thumbnail (image resize or video frame)
        // 5. Cache in memory + disk
    }
}

enum KeychainService {
    private static let storageKey = "fiaxe.r2credentials"
    
    static func saveAll(_ credentials: [R2Credentials]) throws {
        let data = try JSONEncoder().encode(credentials)
        UserDefaults.standard.set(data, forKey: storageKey)
    }
    
    static func loadAll() throws -> [R2Credentials] {
        guard let data = UserDefaults.standard.data(forKey: storageKey) 
        else { return [] }
        return try JSONDecoder().decode([R2Credentials].self, from: data)
    }
}

@Observable
final class UploadHistoryStore {
    var items: [UploadItem] = []
    
    func add(_ item: UploadItem) {
        items.insert(item, at: 0)  // newest first
        save()
    }
    
    private func save() {
        // Encode to JSON and save to UserDefaults
    }
}