Initial scaffold — NASBackup iOS app

Full project scaffold: XcodeGen project.yml, Core models/protocols/errors,
SMBService (kishikawakatsumi/SMBClient), SFTPService (Citadel 0.9.2),
PhotoLibraryService, LANMonitor, BackupEngine, BackgroundTaskManager,
all feature UIs (Login, Connect, Browse, Backup, History, Settings),
Shared components and theme. Builds clean with zero errors.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Services/BackupEngine.swift

@@ -0,0 +1,153 @@
+import Foundation
+import UserNotifications
+
+@MainActor
+final class BackupEngine: ObservableObject {
+    static let shared = BackupEngine()
+
+    @Published private(set) var job: BackupJob = BackupJob()
+
+    private let photoService: PhotoLibraryProtocol = PhotoLibraryService()
+    private var activeTransfer: (any NASTransferProtocol)?
+    private var isCancelled = false
+
+    private init() {}
+
+    func run(
+        connection: NASConnection,
+        filter: BackupFilter,
+        triggeredByLAN: Bool = false
+    ) async throws -> BackupResult {
+        isCancelled = false
+        let startDate = Date()
+
+        // 1. Fetch assets
+        job.prepare()
+        let assets = photoService.fetchAssets(filter: filter)
+
+        // 2. Connect to NAS
+        let transfer: any NASTransferProtocol
+        switch connection.nasProtocol {
+        case .smb:  transfer = SMBService()
+        case .sftp: transfer = SFTPService()
+        }
+
+        try await transfer.connect(
+            to: connection.host,
+            port: connection.port,
+            username: connection.username,
+            password: connection.password
+        )
+        activeTransfer = transfer
+
+        defer {
+            transfer.disconnect()
+            activeTransfer = nil
+        }
+
+        // 3. Start job tracking
+        job.start(totalFiles: assets.count, totalBytes: 0)
+
+        var uploaded = 0
+        var skipped = 0
+        var failed = 0
+        var totalBytes: Int64 = 0
+        var speedTracker = SpeedTracker()
+
+        // 4. Transfer loop
+        for asset in assets {
+            if isCancelled { break }
+            while case .paused = job.status {
+                try await Task.sleep(nanoseconds: 500_000_000)
+            }
+
+            let remotePath = "\(connection.remotePath)/\(asset.filename)"
+
+            // Skip if exists (newFilesOnly = true in filter)
+            if filter.newFilesOnly, (try? await transfer.fileExists(at: remotePath)) == true {
+                job.fileCompleted(skipped: true)
+                skipped += 1
+                continue
+            }
+
+            do {
+                let localURL = try await photoService.exportAsset(asset)
+                defer { try? FileManager.default.removeItem(at: localURL) }
+
+                let fileSize = (try? localURL.resourceValues(forKeys: [.fileSizeKey]).fileSize).flatMap { Int64($0) } ?? 0
+
+                try await transfer.upload(localURL: localURL, remotePath: remotePath) { sent, total in
+                    let speed = speedTracker.update(bytesSent: sent)
+                    Task { @MainActor [weak self] in
+                        self?.job.updateProgress(
+                            fileName: asset.filename,
+                            fileSize: total,
+                            bytesTransferred: totalBytes + sent,
+                            speed: speed
+                        )
+                    }
+                }
+
+                totalBytes += fileSize
+                job.fileCompleted(skipped: false)
+                uploaded += 1
+            } catch {
+                job.fileFailed()
+                failed += 1
+            }
+        }
+
+        let duration = Date().timeIntervalSince(startDate)
+        let result = BackupResult(
+            uploadedCount: uploaded,
+            skippedCount: skipped,
+            failedCount: failed,
+            duration: duration,
+            totalBytes: totalBytes,
+            date: startDate
+        )
+
+        job.finish(result: result)
+
+        // 5. Persist history
+        let entry = BackupHistoryEntry(result: result, nasHost: connection.host, triggeredByLAN: triggeredByLAN)
+        ConnectionStore.shared.appendHistoryEntry(entry)
+
+        // 6. Push notification
+        await sendCompletionNotification(result: result)
+
+        return result
+    }
+
+    func cancel() {
+        isCancelled = true
+        job.cancel()
+    }
+
+    func pause() { job.pause() }
+    func resume() { job.resume() }
+
+    private func sendCompletionNotification(result: BackupResult) async {
+        let content = UNMutableNotificationContent()
+        content.title = result.hasErrors ? "Backup completed with errors" : "Backup complete"
+        content.body = "\(result.uploadedCount) uploaded · \(result.skippedCount) skipped · \(result.failedCount) errors"
+        content.sound = .default
+        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
+        try? await UNUserNotificationCenter.current().add(request)
+    }
+}
+
+private struct SpeedTracker {
+    private var lastBytes: Int64 = 0
+    private var lastTime: Date = Date()
+
+    mutating func update(bytesSent: Int64) -> Double {
+        let now = Date()
+        let elapsed = now.timeIntervalSince(lastTime)
+        guard elapsed > 0.1 else { return 0 }
+        let speed = Double(bytesSent - lastBytes) / elapsed
+        lastBytes = bytesSent
+        lastTime = now
+        return max(0, speed)
+    }
+}