523 lines
17 KiB
Swift
523 lines
17 KiB
Swift
import Foundation
|
||
import AppKit
|
||
import SwiftUI
|
||
import Sparkle
|
||
|
||
class UpdateViewModel: ObservableObject {
|
||
@Published var state: UpdateState = .idle
|
||
@Published var overrideState: UpdateState?
|
||
|
||
var effectiveState: UpdateState {
|
||
overrideState ?? state
|
||
}
|
||
|
||
var text: String {
|
||
switch effectiveState {
|
||
case .idle:
|
||
return ""
|
||
case .permissionRequest:
|
||
return "Enable Automatic Updates?"
|
||
case .checking:
|
||
return "Checking for Updates…"
|
||
case .updateAvailable(let update):
|
||
let version = update.appcastItem.displayVersionString
|
||
if !version.isEmpty {
|
||
return "Update Available: \(version)"
|
||
}
|
||
return "Update Available"
|
||
case .downloading(let download):
|
||
if let expectedLength = download.expectedLength, expectedLength > 0 {
|
||
let progress = Double(download.progress) / Double(expectedLength)
|
||
return String(format: "Downloading: %.0f%%", progress * 100)
|
||
}
|
||
return "Downloading…"
|
||
case .extracting(let extracting):
|
||
return String(format: "Preparing: %.0f%%", extracting.progress * 100)
|
||
case .installing(let install):
|
||
return install.isAutoUpdate ? "Restart to Complete Update" : "Installing…"
|
||
case .notFound:
|
||
return "No Updates Available"
|
||
case .error(let err):
|
||
return Self.userFacingErrorTitle(for: err.error)
|
||
}
|
||
}
|
||
|
||
var maxWidthText: String {
|
||
switch effectiveState {
|
||
case .downloading:
|
||
return "Downloading: 100%"
|
||
case .extracting:
|
||
return "Preparing: 100%"
|
||
default:
|
||
return text
|
||
}
|
||
}
|
||
|
||
var iconName: String? {
|
||
switch effectiveState {
|
||
case .idle:
|
||
return nil
|
||
case .permissionRequest:
|
||
return "questionmark.circle"
|
||
case .checking:
|
||
return "arrow.triangle.2.circlepath"
|
||
case .updateAvailable:
|
||
return "shippingbox.fill"
|
||
case .downloading:
|
||
return "arrow.down.circle"
|
||
case .extracting:
|
||
return "shippingbox"
|
||
case .installing:
|
||
return "power.circle"
|
||
case .notFound:
|
||
return "info.circle"
|
||
case .error:
|
||
return "exclamationmark.triangle.fill"
|
||
}
|
||
}
|
||
|
||
var description: String {
|
||
switch effectiveState {
|
||
case .idle:
|
||
return ""
|
||
case .permissionRequest:
|
||
return "Configure automatic update preferences"
|
||
case .checking:
|
||
return "Please wait while we check for available updates"
|
||
case .updateAvailable(let update):
|
||
return update.releaseNotes?.label ?? "Download and install the latest version"
|
||
case .downloading:
|
||
return "Downloading the update package"
|
||
case .extracting:
|
||
return "Extracting and preparing the update"
|
||
case let .installing(install):
|
||
return install.isAutoUpdate ? "Restart to Complete Update" : "Installing update and preparing to restart"
|
||
case .notFound:
|
||
return "You are running the latest version"
|
||
case .error(let err):
|
||
return Self.userFacingErrorMessage(for: err.error)
|
||
}
|
||
}
|
||
|
||
var badge: String? {
|
||
switch effectiveState {
|
||
case .updateAvailable(let update):
|
||
let version = update.appcastItem.displayVersionString
|
||
return version.isEmpty ? nil : version
|
||
case .downloading(let download):
|
||
if let expectedLength = download.expectedLength, expectedLength > 0 {
|
||
let percentage = Double(download.progress) / Double(expectedLength) * 100
|
||
return String(format: "%.0f%%", percentage)
|
||
}
|
||
return nil
|
||
case .extracting(let extracting):
|
||
return String(format: "%.0f%%", extracting.progress * 100)
|
||
default:
|
||
return nil
|
||
}
|
||
}
|
||
|
||
var iconColor: Color {
|
||
switch effectiveState {
|
||
case .idle:
|
||
return .secondary
|
||
case .permissionRequest:
|
||
return .white
|
||
case .checking:
|
||
return .secondary
|
||
case .updateAvailable:
|
||
return .accentColor
|
||
case .downloading, .extracting, .installing:
|
||
return .secondary
|
||
case .notFound:
|
||
return .secondary
|
||
case .error:
|
||
return .orange
|
||
}
|
||
}
|
||
|
||
var backgroundColor: Color {
|
||
switch effectiveState {
|
||
case .permissionRequest:
|
||
return Color(nsColor: NSColor.systemBlue.blended(withFraction: 0.3, of: .black) ?? .systemBlue)
|
||
case .updateAvailable:
|
||
return .accentColor
|
||
case .notFound:
|
||
return Color(nsColor: NSColor.systemBlue.blended(withFraction: 0.5, of: .black) ?? .systemBlue)
|
||
case .error:
|
||
return .orange.opacity(0.2)
|
||
default:
|
||
return Color(nsColor: .controlBackgroundColor)
|
||
}
|
||
}
|
||
|
||
var foregroundColor: Color {
|
||
switch effectiveState {
|
||
case .permissionRequest:
|
||
return .white
|
||
case .updateAvailable:
|
||
return .white
|
||
case .notFound:
|
||
return .white
|
||
case .error:
|
||
return .orange
|
||
default:
|
||
return .primary
|
||
}
|
||
}
|
||
|
||
static func userFacingErrorTitle(for error: Swift.Error) -> String {
|
||
let nsError = error as NSError
|
||
if let networkError = networkError(from: nsError) {
|
||
switch networkError.code {
|
||
case NSURLErrorNotConnectedToInternet:
|
||
return "No Internet Connection"
|
||
case NSURLErrorTimedOut:
|
||
return "Update Timed Out"
|
||
case NSURLErrorCannotFindHost:
|
||
return "Server Not Found"
|
||
case NSURLErrorCannotConnectToHost:
|
||
return "Server Unreachable"
|
||
case NSURLErrorNetworkConnectionLost:
|
||
return "Connection Lost"
|
||
case NSURLErrorSecureConnectionFailed,
|
||
NSURLErrorServerCertificateUntrusted,
|
||
NSURLErrorServerCertificateHasBadDate,
|
||
NSURLErrorServerCertificateHasUnknownRoot,
|
||
NSURLErrorServerCertificateNotYetValid:
|
||
return "Secure Connection Failed"
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
if nsError.domain == SUSparkleErrorDomain {
|
||
switch nsError.code {
|
||
case 2001:
|
||
return "Couldn't Download Update"
|
||
case 1000, 1002:
|
||
return "Update Feed Error"
|
||
case 4:
|
||
return "Invalid Update Feed"
|
||
case 3:
|
||
return "Insecure Update Feed"
|
||
case 1, 2, 3001, 3002:
|
||
return "Update Signature Error"
|
||
case 1003, 1005:
|
||
return "App Location Issue"
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
return "Update Failed"
|
||
}
|
||
|
||
static func userFacingErrorMessage(for error: Swift.Error) -> String {
|
||
let nsError = error as NSError
|
||
if let networkError = networkError(from: nsError) {
|
||
switch networkError.code {
|
||
case NSURLErrorNotConnectedToInternet:
|
||
return "cmuxterm can’t reach the update server. Check your internet connection and try again."
|
||
case NSURLErrorTimedOut:
|
||
return "The update server took too long to respond. Try again in a moment."
|
||
case NSURLErrorCannotFindHost:
|
||
return "The update server can’t be found. Check your connection or try again later."
|
||
case NSURLErrorCannotConnectToHost:
|
||
return "cmuxterm couldn’t connect to the update server. Check your connection or try again later."
|
||
case NSURLErrorNetworkConnectionLost:
|
||
return "The network connection was lost while checking for updates. Try again."
|
||
case NSURLErrorSecureConnectionFailed,
|
||
NSURLErrorServerCertificateUntrusted,
|
||
NSURLErrorServerCertificateHasBadDate,
|
||
NSURLErrorServerCertificateHasUnknownRoot,
|
||
NSURLErrorServerCertificateNotYetValid:
|
||
return "A secure connection to the update server couldn’t be established. Try again later."
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
if nsError.domain == SUSparkleErrorDomain {
|
||
switch nsError.code {
|
||
case 2001:
|
||
return "cmuxterm couldn’t download the update feed. Check your connection and try again."
|
||
case 1000, 1002:
|
||
return "The update feed could not be read. Please try again later."
|
||
case 4:
|
||
return "The update feed URL is invalid. Please contact support."
|
||
case 3:
|
||
return "The update feed is insecure. Please contact support."
|
||
case 1, 2, 3001, 3002:
|
||
return "The update’s signature could not be verified. Please try again later."
|
||
case 1003, 1005:
|
||
return "Move cmuxterm into Applications and relaunch to enable updates."
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
return nsError.localizedDescription
|
||
}
|
||
|
||
static func errorDetails(for error: Swift.Error, technicalDetails: String?, feedURLString: String?) -> String {
|
||
let nsError = error as NSError
|
||
var lines: [String] = []
|
||
lines.append("Message: \(nsError.localizedDescription)")
|
||
lines.append("Domain: \(nsError.domain)")
|
||
if nsError.domain == SUSparkleErrorDomain,
|
||
let sparkleName = sparkleErrorCodeName(for: nsError.code) {
|
||
lines.append("Code: \(sparkleName) (\(nsError.code))")
|
||
} else {
|
||
lines.append("Code: \(nsError.code)")
|
||
}
|
||
|
||
if let url = nsError.userInfo[NSURLErrorFailingURLErrorKey] as? URL {
|
||
lines.append("URL: \(url.absoluteString)")
|
||
} else if let urlString = nsError.userInfo[NSURLErrorFailingURLStringErrorKey] as? String {
|
||
lines.append("URL: \(urlString)")
|
||
}
|
||
|
||
if let failure = nsError.userInfo[NSLocalizedFailureReasonErrorKey] as? String,
|
||
!failure.isEmpty {
|
||
lines.append("Failure: \(failure)")
|
||
}
|
||
if let recovery = nsError.userInfo[NSLocalizedRecoverySuggestionErrorKey] as? String,
|
||
!recovery.isEmpty {
|
||
lines.append("Recovery: \(recovery)")
|
||
}
|
||
|
||
if let feedURLString, !feedURLString.isEmpty {
|
||
lines.append("Feed: \(feedURLString)")
|
||
}
|
||
|
||
if let technicalDetails, !technicalDetails.isEmpty {
|
||
lines.append("Debug: \(technicalDetails)")
|
||
}
|
||
|
||
lines.append("Log: \(UpdateLogStore.shared.logPath())")
|
||
return lines.joined(separator: "\n")
|
||
}
|
||
|
||
private static func networkError(from error: NSError) -> NSError? {
|
||
if error.domain == NSURLErrorDomain {
|
||
return error
|
||
}
|
||
if let underlying = error.userInfo[NSUnderlyingErrorKey] as? NSError,
|
||
underlying.domain == NSURLErrorDomain {
|
||
return underlying
|
||
}
|
||
return nil
|
||
}
|
||
|
||
private static func sparkleErrorCodeName(for code: Int) -> String? {
|
||
switch code {
|
||
case 1: return "SUNoPublicDSAFoundError"
|
||
case 2: return "SUInsufficientSigningError"
|
||
case 3: return "SUInsecureFeedURLError"
|
||
case 4: return "SUInvalidFeedURLError"
|
||
case 1000: return "SUAppcastParseError"
|
||
case 1001: return "SUNoUpdateError"
|
||
case 1002: return "SUAppcastError"
|
||
case 1003: return "SURunningFromDiskImageError"
|
||
case 1005: return "SURunningTranslocated"
|
||
case 2001: return "SUDownloadError"
|
||
case 3001: return "SUSignatureError"
|
||
case 3002: return "SUValidationError"
|
||
default:
|
||
return nil
|
||
}
|
||
}
|
||
}
|
||
|
||
enum UpdateState: Equatable {
|
||
case idle
|
||
case permissionRequest(PermissionRequest)
|
||
case checking(Checking)
|
||
case updateAvailable(UpdateAvailable)
|
||
case notFound(NotFound)
|
||
case error(Error)
|
||
case downloading(Downloading)
|
||
case extracting(Extracting)
|
||
case installing(Installing)
|
||
|
||
var isIdle: Bool {
|
||
if case .idle = self { return true }
|
||
return false
|
||
}
|
||
|
||
var isInstallable: Bool {
|
||
switch self {
|
||
case .checking,
|
||
.updateAvailable,
|
||
.downloading,
|
||
.extracting,
|
||
.installing:
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func cancel() {
|
||
switch self {
|
||
case .checking(let checking):
|
||
checking.cancel()
|
||
case .updateAvailable(let available):
|
||
available.reply(.dismiss)
|
||
case .downloading(let downloading):
|
||
downloading.cancel()
|
||
case .notFound(let notFound):
|
||
notFound.acknowledgement()
|
||
case .error(let err):
|
||
err.dismiss()
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
|
||
func confirm() {
|
||
switch self {
|
||
case .updateAvailable(let available):
|
||
available.reply(.install)
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
|
||
static func == (lhs: UpdateState, rhs: UpdateState) -> Bool {
|
||
switch (lhs, rhs) {
|
||
case (.idle, .idle):
|
||
return true
|
||
case (.permissionRequest, .permissionRequest):
|
||
return true
|
||
case (.checking, .checking):
|
||
return true
|
||
case (.updateAvailable(let lUpdate), .updateAvailable(let rUpdate)):
|
||
return lUpdate.appcastItem.displayVersionString == rUpdate.appcastItem.displayVersionString
|
||
case (.notFound, .notFound):
|
||
return true
|
||
case (.error(let lErr), .error(let rErr)):
|
||
return lErr.error.localizedDescription == rErr.error.localizedDescription
|
||
case (.downloading(let lDown), .downloading(let rDown)):
|
||
return lDown.progress == rDown.progress && lDown.expectedLength == rDown.expectedLength
|
||
case (.extracting(let lExt), .extracting(let rExt)):
|
||
return lExt.progress == rExt.progress
|
||
case (.installing(let lInstall), .installing(let rInstall)):
|
||
return lInstall.isAutoUpdate == rInstall.isAutoUpdate
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
struct NotFound {
|
||
let acknowledgement: () -> Void
|
||
}
|
||
|
||
struct PermissionRequest {
|
||
let request: SPUUpdatePermissionRequest
|
||
let reply: @Sendable (SUUpdatePermissionResponse) -> Void
|
||
}
|
||
|
||
struct Checking {
|
||
let cancel: () -> Void
|
||
}
|
||
|
||
struct UpdateAvailable {
|
||
let appcastItem: SUAppcastItem
|
||
let reply: @Sendable (SPUUserUpdateChoice) -> Void
|
||
|
||
var releaseNotes: ReleaseNotes? {
|
||
ReleaseNotes(displayVersionString: appcastItem.displayVersionString)
|
||
}
|
||
}
|
||
|
||
enum ReleaseNotes {
|
||
case commit(URL)
|
||
case tagged(URL)
|
||
|
||
init?(displayVersionString: String) {
|
||
let version = displayVersionString
|
||
|
||
if let semver = Self.extractSemanticVersion(from: version) {
|
||
let tag = semver.hasPrefix("v") ? semver : "v\(semver)"
|
||
if let url = URL(string: "https://github.com/manaflow-ai/cmuxterm/releases/tag/\(tag)") {
|
||
self = .tagged(url)
|
||
return
|
||
}
|
||
}
|
||
|
||
guard let newHash = Self.extractGitHash(from: version) else {
|
||
return nil
|
||
}
|
||
|
||
if let url = URL(string: "https://github.com/manaflow-ai/cmuxterm/commit/\(newHash)") {
|
||
self = .commit(url)
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
private static func extractSemanticVersion(from version: String) -> String? {
|
||
let pattern = #"v?\d+\.\d+\.\d+"#
|
||
if let range = version.range(of: pattern, options: .regularExpression) {
|
||
return String(version[range])
|
||
}
|
||
return nil
|
||
}
|
||
|
||
private static func extractGitHash(from version: String) -> String? {
|
||
let pattern = #"[0-9a-f]{7,40}"#
|
||
if let range = version.range(of: pattern, options: .regularExpression) {
|
||
return String(version[range])
|
||
}
|
||
return nil
|
||
}
|
||
|
||
var url: URL {
|
||
switch self {
|
||
case .commit(let url): return url
|
||
case .tagged(let url): return url
|
||
}
|
||
}
|
||
|
||
var label: String {
|
||
switch self {
|
||
case .commit: return "View GitHub Commit"
|
||
case .tagged: return "View Release Notes"
|
||
}
|
||
}
|
||
}
|
||
|
||
struct Error {
|
||
let error: any Swift.Error
|
||
let retry: () -> Void
|
||
let dismiss: () -> Void
|
||
let technicalDetails: String?
|
||
let feedURLString: String?
|
||
|
||
init(error: any Swift.Error,
|
||
retry: @escaping () -> Void,
|
||
dismiss: @escaping () -> Void,
|
||
technicalDetails: String? = nil,
|
||
feedURLString: String? = nil) {
|
||
self.error = error
|
||
self.retry = retry
|
||
self.dismiss = dismiss
|
||
self.technicalDetails = technicalDetails
|
||
self.feedURLString = feedURLString
|
||
}
|
||
}
|
||
|
||
struct Downloading {
|
||
let cancel: () -> Void
|
||
let expectedLength: UInt64?
|
||
let progress: UInt64
|
||
}
|
||
|
||
struct Extracting {
|
||
let progress: Double
|
||
}
|
||
|
||
struct Installing {
|
||
var isAutoUpdate = false
|
||
let retryTerminatingApplication: () -> Void
|
||
let dismiss: () -> Void
|
||
}
|
||
}
|