Skip to content

armgit / peel

Public Imported from GitHub
0

Uninstall Mac apps with every file they leave behind, and see why each belongs. Free up space, fine-tune macOS, and set up Terminal.

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.swift
index 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.swift
index 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.swift
index 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.swift
index 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")