Experimental firmware update features

Meshtastic/API/Helpers/URL+fetch.swift

@@ -0,0 +1,99 @@
+//
+//  URL+fetch.swift
+//  Meshtastic
+//
+//  Created by jake on 12/6/25.
+//
+
+import Foundation
+
+extension URL {
+
+	/// Custom error type for the URL extension
+	enum TimeoutError: Error, LocalizedError {
+		case timedOut(TimeInterval)
+
+		var errorDescription: String? {
+			switch self {
+			case .timedOut(let seconds):
+				return "The operation timed out after \(seconds) seconds."
+			}
+		}
+	}
+
+	/// Fetches data from the URL (local or remote) with a strict timeout.
+	/// - Parameter timeout: The duration in seconds to wait before throwing an error.
+	/// - Returns: The `Data` retrieved.
+	func data(timeout: TimeInterval) async throws -> Data {
+
+		return try await withThrowingTaskGroup(of: Data.self) { group in
+
+			// Task 1: The Fetch Operation
+			group.addTask {
+				if self.isFileURL {
+					// Handle Local Files
+					// Note: Data(contentsOf:) is synchronous (blocking).
+					// Running it inside a Task allows it to be raced, though
+					// the underlying thread may remain blocked until OS IO completes
+					// if cancellation occurs.
+					return try Data(contentsOf: self)
+				} else {
+					// Handle Remote Network Requests
+					let (data, _) = try await URLSession.shared.data(from: self)
+					return data
+				}
+			}
+
+			// Task 2: The Timer
+			group.addTask {
+				// Convert seconds to nanoseconds
+				let nanoseconds = UInt64(timeout * 1_000_000_000)
+				try await Task.sleep(nanoseconds: nanoseconds)
+
+				// If we wake up, it means the fetch hasn't finished yet
+				throw TimeoutError.timedOut(timeout)
+			}
+
+			// Race Handling
+
+			// Wait for the first task to finish (either success or error)
+			guard let result = try await group.next() else {
+				// Should not be reachable, but required by compiler
+				throw URLError(.unknown)
+			}
+
+			// If we are here, one task finished successfully.
+			// Cancel the other task immediately.
+			group.cancelAll()
+
+			return result
+		}
+	}
+
+	/// Performs a HEAD request to fetch the ETag header for the URL.
+	/// - Parameter session: The URLSession to use (defaults to .shared).
+	/// - Returns: The ETag string if found and the request is successful, otherwise nil.
+	func eTag(using session: URLSession = .shared) async throws -> String? {
+		var request = URLRequest(url: self)
+		request.httpMethod = "HEAD"
+
+		// Ensure we don't use the local cache so we get the real ETag from the server
+		request.cachePolicy = .reloadIgnoringLocalCacheData
+
+		let (_, response) = try await session.data(for: request)
+
+		guard let httpResponse = response as? HTTPURLResponse else {
+			return nil
+		}
+
+		// Optional: Check for success status codes (200-299)
+		guard (200...299).contains(httpResponse.statusCode) else {
+			// You might want to return nil or throw a specific error here
+			// depending on your requirements (e.g. 404 Not Found)
+			return nil
+		}
+
+		// Header lookup is case-insensitive
+		return httpResponse.value(forHTTPHeaderField: "ETag")
+	}
+}

Meshtastic/API/Helpers/UTI+UF2.swift

@@ -0,0 +1,41 @@
+//
+//  UTI+UF2.swift
+//  Meshtastic
+//
+//  Created by jake on 12/12/25.
+//
+
+import UniformTypeIdentifiers
+import SwiftUI
+
+extension UTType {
+	// Define a custom type for your firmware
+	// Identifier: Use your bundle ID prefix (e.g., com.yourcompany.firmware)
+	static let UF2Firmware = UTType("com.meshtastic.uf2-firmware")!
+	static let ZIPFirmware = UTType(importedAs: "com.pkware.zip-firmware")
+	static let BINFirmware = UTType(importedAs: "com.meshtastic.bin-firmware")
+}
+
+struct FirmwareDocument: FileDocument {
+	// 1. Tell the system this document supports your custom UTType
+	static var readableContentTypes: [UTType] { [.UF2Firmware] }
+
+	var firmwareData: Data
+
+	init(data: Data) {
+		self.firmwareData = data
+	}
+
+	// Initialize from an existing file (Read)
+	init(configuration: ReadConfiguration) throws {
+		guard let data = configuration.file.regularFileContents else {
+			throw CocoaError(.fileReadCorruptFile)
+		}
+		self.firmwareData = data
+	}
+
+	// Prepare data for saving (Write)
+	func fileWrapper(configuration: WriteConfiguration) throws -> FileWrapper {
+		return FileWrapper(regularFileWithContents: firmwareData)
+	}
+}