Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.
Swift cache-cleanercleanerclideveloper-toolsdisk-cleanupdisk-spaceduplicate-finderhomebrewliquid-glassmac-cleanermacosmacos-appmacos-golden-gatemacos-tahoemacos-tweaksswiftswiftuiterminal-themesuninstalluninstaller
Don't show an Electron app's release its own updater won't offer this Mac
Țugui Dragoșddfc37b2cb66
diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/ElectronUpdater.swift b/Packages/PeelCore/Sources/PeelCore/Updates/ElectronUpdater.swiftindex 9df21ea1..55855eb1 100644--- a/Packages/PeelCore/Sources/PeelCore/Updates/ElectronUpdater.swift+++ b/Packages/PeelCore/Sources/PeelCore/Updates/ElectronUpdater.swift@@ -48,6 +48,83 @@ enum ElectronUpdater {topLevelFields(in: text)["version"]}+ /// Whether electron-updater offers the release `text` describes to this Mac, as its `AppUpdater` decides unless+ /// the app replaces the rule: not when the Darwin release (`os.release()`) is below the feed's+ /// `minimumSystemVersion` as semver compares them, a version semver can't read deciding nothing, and with a+ /// `stagingPercentage`, only when the app's own `updaterID` falls within it. With no id yet, the app's first+ /// check makes one at random, so Peel can't tell, and says it is offered.+ static func isOffered(fromFeed text: String, darwinRelease: String, updaterID: UUID?) -> Bool {+ let fields = topLevelFields(in: text)+ if let minimum = fields["minimumSystemVersion"].flatMap(SemanticVersion.init),+ let current = SemanticVersion(darwinRelease), current < minimum {+ return false+ }+ guard let staging = fields["stagingPercentage"].flatMap({ Double($0) }), staging.isFinite, let updaterID else {+ return true+ }+ let bytes = withUnsafeBytes(of: updaterID.uuid) { Array($0) }+ let value = bytes[12...].reduce(UInt32(0)) { $0 << 8 | UInt32($1) }+ return Double(value) / Double(UInt32.max) < staging / 100+ }++ /// The id electron-updater keeps for an app's staged releases, in `.updaterId` in the app's own data folder, or nil+ /// until it has made one.+ static func updaterID(of app: InstalledApp, home: URL) -> UUID? {+ guard let name = app.bundleName, !name.isEmpty, !name.contains("/"), name != ".", name != ".." else { return nil }+ let file = home.appending(path: "Library/Application Support/\(name)/.updaterId")+ return BoundedRead.data(at: file, maximum: 1_024).flatMap {+ UUID(uuidString: String(decoding: $0, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines))+ }+ }++ /// The Darwin release, which electron-updater reads with `os.release()`, such as 25.6.0.+ static var darwinRelease: String {+ var system = utsname()+ guard uname(&system) == 0 else { return "" }+ return withUnsafeBytes(of: system.release) { String(decoding: $0.prefix { $0 != 0 }, as: UTF8.self) }+ }++ /// A version as semver reads it strictly: three numbers with no leading zero, after an optional `v`, then an+ /// optional prerelease, which comes before the release, and build metadata, which counts for nothing.+ private struct SemanticVersion: Comparable {+ let numbers: [Int]+ let prerelease: [Substring]++ init?(_ text: String) {+ let pattern = #/+ v? (?<major> 0|[1-9][0-9]* ) \. (?<minor> 0|[1-9][0-9]* ) \. (?<patch> 0|[1-9][0-9]* )+ (?: - (?<prerelease>+ (?: 0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]* )+ (?: \. (?: 0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]* ) )*+ ) )?+ (?: \+ [0-9A-Za-z-]+ (?: \. [0-9A-Za-z-]+ )* )?+ /#+ guard let match = text.trimmingCharacters(in: .whitespaces).wholeMatch(of: pattern),+ let major = Int(match.major), let minor = Int(match.minor), let patch = Int(match.patch)+ else { return nil }+ numbers = [major, minor, patch]+ prerelease = match.prerelease.map { $0.split(separator: ".") } ?? []+ }++ static func < (lhs: Self, rhs: Self) -> Bool {+ if lhs.numbers != rhs.numbers { return lhs.numbers.lexicographicallyPrecedes(rhs.numbers) }+ switch (lhs.prerelease.isEmpty, rhs.prerelease.isEmpty) {+ case (true, _): return false+ case (false, true): return true+ case (false, false):+ for (left, right) in zip(lhs.prerelease, rhs.prerelease) where left != right {+ switch (Int(left), Int(right)) {+ case let (left?, right?): return left < right+ case (.some, nil): return true+ case (nil, .some): return false+ case (nil, nil): return left < right+ }+ }+ return lhs.prerelease.count < rhs.prerelease.count+ }+ }+ }+/// What is new in the release: the feed's top-level `releaseNotes`, which electron-builder writes from the app's/// release notes, in Markdown, as a plain, quoted or block scalar. The list it writes instead when told to keep/// every version's notes is not read.diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swiftindex b9bcfb7f..c252dae3 100644--- a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift+++ b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift@@ -232,7 +232,7 @@ public struct UpdateChecker: Sendable {return switch app.updateFeed {case nil: UpdateAnswer(status: .unsupported)case .sparkle(let url): await sparkleAnswer(for: app, installed: installed, at: url)- case .electron(let url): await electronAnswer(installed: installed, at: url)+ case .electron(let url): await electronAnswer(for: app, installed: installed, at: url)case .appStore: await appStoreAnswer(for: app, earlier: earlier, notListedBefore: notListedBefore)}}@@ -260,12 +260,18 @@ public struct UpdateChecker: Sendable {)}- private func electronAnswer(installed: String, at url: URL) async -> UpdateAnswer {+ private func electronAnswer(for app: InstalledApp, installed: String, at url: URL) async -> UpdateAnswer {let reply = await fetchReply(url)guard let data = reply.data else { return UpdateAnswer(status: .failed, wasOffline: reply.wasOffline) }let feed = String(decoding: data, as: UTF8.self)guard let latest = ElectronUpdater.version(fromFeed: feed) else { return UpdateAnswer(status: .failed) }guard VersionComparison.isNewer(latest, than: installed) else { return UpdateAnswer(status: .upToDate) }+ // A release the app's own updater won't offer this Mac is no update to wait for here, as the app says too.+ let updaterID = ElectronUpdater.updaterID(of: app, home: .homeDirectory)+ let release = ElectronUpdater.darwinRelease+ guard ElectronUpdater.isOffered(fromFeed: feed, darwinRelease: release, updaterID: updaterID) else {+ return UpdateAnswer(status: .upToDate)+ }return UpdateAnswer(status: .updateAvailable(version: latest, source: .developer, releaseNotes: nil),notes: ElectronUpdater.releaseNotes(fromFeed: feed)diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swiftindex 5345e610..b783e4bb 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift@@ -634,6 +634,18 @@ private final class OfflineProtocol: URLProtocol, @unchecked Sendable {#expect(await checker.answer(for: sparkleApp()).notes == nil, "nothing waits for an app that is up to date")}+ @Test func anElectronReleaseTheAppWontOfferThisMacIsNoUpdate() async {+ let chat = InstalledApp(+ url: URL(filePath: "/Applications/Chat.app"), bundleIdentifier: "com.example.chat", name: "Chat",+ version: "1.0", updateFeed: .electron(URL(string: "https://updates.example.com/latest-mac.yml")!)+ )+ reply("updates.example.com", "version: 2.0.0\nminimumSystemVersion: 99.0.0\nfiles:\n - url: a.zip\n")+ #expect(await checker.status(for: chat) == .upToDate)++ reply("updates.example.com", "version: 2.0.0\nminimumSystemVersion: 20.0.0\nfiles:\n - url: a.zip\n")+ #expect(await checker.status(for: chat) == .updateAvailable(version: "2.0.0", source: .developer))+ }+@Test func asksTheAppsOwnFeedForTheNotesOfAnUpdateHomebrewFound() async throws {let cask = HomebrewPackage(name: "editor", kind: .cask, installedVersion: "1.0", latestVersion: "2.0,200", isOutdated: true,diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swiftindex bf417590..1d8041f0 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift@@ -260,6 +260,26 @@ struct ElectronUpdaterTests {#expect(ElectronUpdater.feedURL(fromConfiguration: "provider: github\nhost: github.com\nowner: example\nrepo: tool\n") != nil)}+ @Test func offersOnlyWhatElectronUpdaterWouldOfferThisMac() throws {+ let darwin = "25.6.0"+ func offered(_ fields: String, id: String? = nil) -> Bool {+ ElectronUpdater.isOffered(+ fromFeed: "version: 2.0.0\n\(fields)files:\n - url: a.zip\n", darwinRelease: darwin,+ updaterID: id.flatMap(UUID.init(uuidString:))+ )+ }+ #expect(!offered("minimumSystemVersion: 99.0.0\n"))+ #expect(!offered("minimumSystemVersion: '26.0.0'\n"), "compared with the Darwin release, as os.release() is")+ #expect(offered("minimumSystemVersion: 20.0.0\n"))+ #expect(offered("minimumSystemVersion: 13.0\n"), "semver can't read it, and the exception lets the update through")+ #expect(offered("minimumSystemVersion: 25.6.0-beta.2\n"), "a release comes after its prereleases")+ #expect(!offered("minimumSystemVersion: v25.6.1-beta.1\n"))+ #expect(offered("stagingPercentage: 10\n", id: "00000000-0000-0000-0000-00000ccccccc"))+ #expect(!offered("stagingPercentage: 10\n", id: "00000000-0000-0000-0000-000080000000"))+ #expect(offered("stagingPercentage: 10\n"), "with no id yet, the app's first check decides")+ #expect(offered("stagingPercentage: lots\n", id: "00000000-0000-0000-0000-000080000000"))+ }+@Test func readsVersionFromFeed() {let feed = "version: 1.33.0\nfiles:\n - url: TuneIn-1.33.0-universal-mac.zip\n version: 9.9.9\nreleaseDate: '2026-03-30T19:23:16.416Z'\n"#expect(ElectronUpdater.version(fromFeed: feed) == "1.33.0")