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
Count Homebrew's "up to date" only within a day of its last check
Țugui Dragoș97e792f40d21
diff --git a/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift b/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swiftindex fcd5c370..e7174d22 100644--- a/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift+++ b/Packages/PeelCore/Sources/PeelCommandLine/Commands/AppCommands.swift@@ -805,8 +805,11 @@ struct UpdatesCommand: AsyncParsableCommand {let preferences = UpdatePreferences.asTheAppSeesThem()let homebrew = await CaskLookup.installed()let toCheck = apps.filter { !preferences.isIgnored($0) }+ let checker = UpdateChecker()let statuses = await ProgressLine.reporting { show in- await Self.statuses(for: toCheck, preference: preferences.source, casks: homebrew.casks) { answered in+ await Self.statuses(+ for: toCheck, checker: checker, preference: preferences.source, casks: homebrew.casks+ ) { answered inshow(Self.progress(checked: answered, of: toCheck.count))}}@@ -827,6 +830,12 @@ struct UpdatesCommand: AsyncParsableCommand {if let note = homebrew.note {Output.note(note)}+ let notCheckedRecently = toCheck.filter { statuses[$0.id] == .unsupported }.compactMap { app in+ checker.caskNotCheckedRecently(for: app, preference: preferences.source, casks: homebrew.casks)+ }+ if let note = Self.note(aboutCasksNotCheckedRecently: notCheckedRecently) {+ Output.note(note)+ }if report.ignored > 0 {Output.note("\(Output.count(report.ignored, "app is", "apps are")) set to be left alone in Peel and \(report.ignored == 1 ? "wasn't" : "weren't") checked.")}@@ -839,6 +848,17 @@ struct UpdatesCommand: AsyncParsableCommand {}}+ /// Says why the apps these casks installed got no answer: Homebrew's last check for new versions is too old to+ /// tell (`UpdateChecker.caskNotCheckedRecently`).+ static func note(aboutCasksNotCheckedRecently casks: [HomebrewPackage], timeZone: TimeZone = .current) -> String? {+ guard !casks.isEmpty else { return nil }+ let apps = "\(Output.count(casks.count, "app", "apps")) it installed \(casks.count == 1 ? "is" : "are")"+ guard let checked = casks.compactMap(\.lastUpdateCheck).max() else {+ return "Homebrew doesn't say when it last checked for new versions, so whether \(apps) up to date isn't known."+ }+ return "Homebrew last checked for new versions on \(Output.day(checked, timeZone: timeZone)), so whether \(apps) up to date isn't known. Run `brew update`, then check again."+ }+static func progress(checked: Int, of total: Int) -> String {"Checked \(Output.number(checked)) of \(Output.count(total, "app", "apps"))"}@@ -856,12 +876,12 @@ struct UpdatesCommand: AsyncParsableCommand {private static func statuses(for apps: [InstalledApp],+ checker: UpdateChecker,preference: UpdateSource,casks: [HomebrewPackage],answered: (Int) -> Void) async -> [InstalledApp.ID: UpdateStatus] {- let checker = UpdateChecker()- return await withTaskGroup(of: (InstalledApp.ID, UpdateStatus).self) { group in+ await withTaskGroup(of: (InstalledApp.ID, UpdateStatus).self) { group invar pending = apps.makeIterator()var statuses: [InstalledApp.ID: UpdateStatus] = [:]for _ in 0..<concurrentChecks {diff --git a/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift b/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swiftindex f88d622b..b9d3239b 100644--- a/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift+++ b/Packages/PeelCore/Sources/PeelCore/Homebrew/Homebrew.swift@@ -56,6 +56,9 @@ public struct HomebrewPackage: Sendable, Hashable, Identifiable {/// True for an installed cask that left nothing on this Mac: every app gone from where Homebrew put it, or, for a/// cask with no app, every package it installed, as their receipts say. Set by `checkingWhatItInstalled`.public private(set) var isMissingWhatItInstalled = false+ /// When Homebrew last checked for new versions, read before this package was (`Homebrew.lastUpdateCheck()`), or+ /// nil when Peel couldn't tell. What `isOutdated` says is no more recent than that check.+ public private(set) var lastUpdateCheck: Date?public var id: String { "\(kind.rawValue)/\(name)" }@@ -115,6 +118,12 @@ public struct HomebrewPackage: Sendable, Hashable, Identifiable {return noted}+ public func noting(lastUpdateCheck: Date?) -> HomebrewPackage {+ var noted = self+ noted.lastUpdateCheck = lastUpdateCheck+ return noted+ }+public func kept(inCaskroom caskroom: URL) -> HomebrewPackage {var kept = selfkept.caskroomFolder = caskroom.appending(path: name, directoryHint: .isDirectory)@@ -426,6 +435,9 @@ public enum Homebrew {/// The command brew.sh gives for installing Homebrew. Its script says what it will do and waits before doing it.public static let installCommand = "/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\""public static let website = URL(string: "https://brew.sh")!+ /// How long Homebrew lets its last check for new versions stand before it checks again on its own: the default of+ /// `HOMEBREW_AUTO_UPDATE_SECS` (`man brew`).+ public static let autoUpdateInterval: TimeInterval = 24 * 60 * 60public struct CommandFailure: Error, Sendable, Hashable {public let output: String@@ -529,14 +541,33 @@ public enum Homebrew {}}+ /// When Homebrew last checked for new versions: when `brew update` last touched `.git/FETCH_HEAD` in Homebrew's+ /// repository, the file Homebrew itself compares with `HOMEBREW_AUTO_UPDATE_SECS` before it updates on its own.+ /// Nil when Homebrew doesn't say where its repository is, or the file isn't there.+ @concurrent+ public static func lastUpdateCheck() async -> Date? {+ guard let answer = try? await answer(["--repository"]), let repository = folder(answering: answer) else {+ return nil+ }+ return lastUpdateCheck(inRepository: repository)+ }++ /// Homebrew reads the file only as a regular file (`find -type f` in `utils/auto-update.sh`), never through a link.+ static func lastUpdateCheck(inRepository repository: URL) -> Date? {+ FileIdentity.of(repository.appending(path: ".git/FETCH_HEAD"))?.modificationDate+ }+@concurrentpublic static func installedPackages() async throws(CommandFailure) -> [HomebrewPackage] {+ // Read first, so a check made while the packages are read leaves them dated older than they are, never newer.+ let checked = await lastUpdateCheck()let output = try await answer(["info", "--json=v2", "--installed"])- let caskroom = (try? await answer(["--caskroom"])).flatMap(caskroom(answering:))+ let caskroom = (try? await answer(["--caskroom"])).flatMap(folder(answering:))guard let packages = parseInstalled(Data(output.utf8), caskroom: caskroom) else {throw CommandFailure(output: output)}- return await checkedOnThisMac(packages, pkgutil: PackageReceipts.pkgutil)+ let dated = packages.map { $0.noting(lastUpdateCheck: checked) }+ return await checkedOnThisMac(dated, pkgutil: PackageReceipts.pkgutil)}/// The installed packages with what this Mac says of them: the receipts their casks name, where those packages@@ -833,7 +864,8 @@ public enum Homebrew {return Set(line.dropFirst(prefix.count).split(separator: ",").map { $0.trimmingCharacters(in: .whitespaces) })}- static func caskroom(answering answer: String) -> URL? {+ /// The one folder `brew --caskroom` or `brew --repository` answers with.+ static func folder(answering answer: String) -> URL? {let lines = answer.split(whereSeparator: \.isNewline)guard lines.count == 1, let path = lines.first.map(String.init), path.hasPrefix("/") else { return nil }return URL(filePath: path, directoryHint: .isDirectory)diff --git a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swiftindex f441c2c4..c47f976d 100644--- a/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift+++ b/Packages/PeelCore/Sources/PeelCore/Updates/UpdateChecker.swift@@ -30,9 +30,14 @@ public struct UpdateChecker: Sendable {private let country: Stringprivate let systemVersion: Stringprivate let isAppleSilicon = HostArchitecture.isAppleSilicon+ /// The time a check is made at, which decides whether what Homebrew says is recent enough to count.+ private let clock: @Sendable () -> Date- public init(session: URLSession? = nil, locale: Locale = .current) {+ public init(+ session: URLSession? = nil, locale: Locale = .current, clock: @escaping @Sendable () -> Date = { .now }+ ) {self.session = session ?? URLSession(configuration: Self.configuration)+ self.clock = clockcountry = Self.storefront(of: locale)let version = ProcessInfo.processInfo.operatingSystemVersionsystemVersion = "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"@@ -66,24 +71,20 @@ public struct UpdateChecker: Sendable {casks: [HomebrewPackage] = [],earlier: UpdateStatus? = nil) async -> UpdateAnswer {+ let homebrew = homebrewStatus(for: app, casks: casks)+ if let status = Self.statusWithoutAsking(for: app, preference: preference, homebrew: homebrew) {+ return UpdateAnswer(status: status)+ }switch preference {- case .homebrew:- // A cask Homebrew knows but never installed says nothing about this app's version, so the- // app's own feed answers instead of a false "up to date".- if let homebrew = homebrewStatus(for: app, casks: casks) { return UpdateAnswer(status: homebrew) }+ case .homebrew, .developer:return await feedAnswer(for: app, earlier: earlier)case .appStore:// Even with this preference, Apple is asked only about apps from the App Store. Any other app is// checked through its own feed, or not at all.return app.isFromAppStore? await appStoreAnswer(for: app, earlier: earlier) : await feedAnswer(for: app, earlier: earlier)- case .developer:- return await feedAnswer(for: app, earlier: earlier)case .automatic:- let homebrew = homebrewStatus(for: app, casks: casks)- if case .updateAvailable = homebrew { return UpdateAnswer(status: homebrew ?? .unsupported) }- // An app from a cask may have no feed of its own, and a feed can be down. In both cases what Homebrew- // knows is used rather than "Can't check for updates".+ // A feed can be down, and the App Store may not sell the app here: what Homebrew knows is used then.let feed = await feedAnswer(for: app, earlier: earlier)if let homebrew, feed.status == .unsupported || feed.status == .failed {return UpdateAnswer(status: homebrew, developer: feed.developer)@@ -92,16 +93,65 @@ public struct UpdateChecker: Sendable {}}- /// Homebrew's answer for `app`, found without a network request, or nil when Homebrew did not install this- /// copy. For a cask it did not install, Homebrew has a definition but no installed version to compare.+ /// The status `answer(for:preference:casks:earlier:)` gives `app` without asking any server, from Homebrew's+ /// casks and the app's own files alone, or nil when the app's own feed or the App Store has to be asked.+ public func statusWithoutAsking(+ for app: InstalledApp, preference: UpdateSource, casks: [HomebrewPackage]+ ) -> UpdateStatus? {+ Self.statusWithoutAsking(for: app, preference: preference, homebrew: homebrewStatus(for: app, casks: casks))+ }++ private static func statusWithoutAsking(+ for app: InstalledApp, preference: UpdateSource, homebrew: UpdateStatus?+ ) -> UpdateStatus? {+ // An app whose bundle names no version, or no feed, has nothing to ask.+ let hasNobodyToAsk = app.version == nil || app.updateFeed == nil+ switch preference {+ case .homebrew:+ // A cask Homebrew knows but never installed says nothing about this app's version, and neither does one+ // Homebrew can't tell about, so the app's own feed answers then instead of a false "up to date".+ return homebrew ?? (hasNobodyToAsk ? .unsupported : nil)+ case .automatic:+ if case .updateAvailable = homebrew { return homebrew }+ // An app from a cask may have no feed of its own: what Homebrew knows is used rather than "Can't check+ // for updates".+ return hasNobodyToAsk ? homebrew ?? .unsupported : nil+ case .developer:+ return hasNobodyToAsk ? .unsupported : nil+ case .appStore:+ return hasNobodyToAsk && !app.isFromAppStore ? .unsupported : nil+ }+ }++ /// Homebrew's answer for `app`, found without a network request, or nil when Homebrew did not install this copy+ /// or can't tell (`homebrewStatus(of:at:)`). For a cask it did not install, Homebrew has a definition but no+ /// installed version to compare.public func homebrewStatus(for app: InstalledApp, casks: [HomebrewPackage]) -> UpdateStatus? {- CaskEvidence.installedCask(for: app, in: casks).map(Self.homebrewStatus(of:))+ CaskEvidence.installedCask(for: app, in: casks).flatMap { Self.homebrewStatus(of: $0, at: clock()) }+ }++ /// The status Homebrew reports at `now` for `cask`, which is already known to be the app's, or nil when it can't+ /// tell. A cask it doesn't mark outdated is up to date only while Homebrew's last check for new versions is less+ /// than `Homebrew.autoUpdateInterval` old, the longest Homebrew itself waits before it checks again.+ static func homebrewStatus(of cask: HomebrewPackage, at now: Date) -> UpdateStatus? {+ if cask.isOutdated, let latest = cask.latestVersion {+ return .updateAvailable(version: latest, source: .homebrew, releaseNotes: cask.homepage)+ }+ guard let checked = cask.lastUpdateCheck, now.timeIntervalSince(checked) < Homebrew.autoUpdateInterval else {+ return nil+ }+ return .upToDate}- /// The status Homebrew reports for `cask`, which is already known to be the app's.- public static func homebrewStatus(of cask: HomebrewPackage) -> UpdateStatus {- guard cask.isOutdated, let latest = cask.latestVersion else { return .upToDate }- return .updateAvailable(version: latest, source: .homebrew, releaseNotes: cask.homepage)+ /// The cask `app` came from when only Homebrew could say whether it is up to date and Homebrew's last check for+ /// new versions is too old to tell (`homebrewStatus(of:at:)`), which is why a check has no answer for it.+ public func caskNotCheckedRecently(+ for app: InstalledApp, preference: UpdateSource, casks: [HomebrewPackage]+ ) -> HomebrewPackage? {+ guard preference == .automatic || preference == .homebrew, app.version == nil || app.updateFeed == nil,+ let cask = CaskEvidence.installedCask(for: app, in: casks)+ else { return nil }+ return Self.homebrewStatus(of: cask, at: clock()) == nil ? cask : nil}private func feedAnswer(for app: InstalledApp, earlier: UpdateStatus?) async -> UpdateAnswer {diff --git a/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swiftindex 7dbbed9b..f49c2a00 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/CommandLineTests.swift@@ -995,6 +995,16 @@ struct CommandLineTests {#expect(!some.nothingAnswered)}+ @Test func saysWhyAppsHomebrewInstalledGotNoAnswer() {+ let cask = HomebrewPackage(name: "example", kind: .cask, installedVersion: "1.0")+ let checked = cask.noting(lastUpdateCheck: Date(timeIntervalSince1970: 1_792_315_250))+ let utc = TimeZone(identifier: "UTC")!++ #expect(UpdatesCommand.note(aboutCasksNotCheckedRecently: [], timeZone: utc) == nil)+ #expect(UpdatesCommand.note(aboutCasksNotCheckedRecently: [checked], timeZone: utc) == "Homebrew last checked for new versions on 2026-10-18, so whether 1 app it installed is up to date isn't known. Run `brew update`, then check again.")+ #expect(UpdatesCommand.note(aboutCasksNotCheckedRecently: [cask, cask], timeZone: utc) == "Homebrew doesn't say when it last checked for new versions, so whether 2 apps it installed are up to date isn't known.")+ }+/// `--all` lists an app Peel can't check as the app does. "No update feed" was wrong for an app that came with/// macOS, an App Store app with no Mac version to read, and an app whose bundle names no version.@Test func saysAnAppItCannotCheckCannotBeChecked() {diff --git a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swiftindex 1ca503d8..fd14fae2 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewReceiptTests.swift@@ -22,11 +22,11 @@ struct HomebrewReceiptTests {}@Test func readsTheCaskroomHomebrewNames() {- #expect(Homebrew.caskroom(answering: "/opt/homebrew/Caskroom\n")?.path(percentEncoded: false)+ #expect(Homebrew.folder(answering: "/opt/homebrew/Caskroom\n")?.path(percentEncoded: false)== "/opt/homebrew/Caskroom/")- #expect(Homebrew.caskroom(answering: "") == nil)- #expect(Homebrew.caskroom(answering: "Caskroom\n") == nil)- #expect(Homebrew.caskroom(answering: "/opt/homebrew/Caskroom\n/usr/local/Caskroom\n") == nil)+ #expect(Homebrew.folder(answering: "") == nil)+ #expect(Homebrew.folder(answering: "Caskroom\n") == nil)+ #expect(Homebrew.folder(answering: "/opt/homebrew/Caskroom\n/usr/local/Caskroom\n") == nil)}@Test func everyCaskInstalledOnThisMacIsReadAsItIsOnTheDisk() async throws {diff --git a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swiftindex 245f44a4..fae1b2a0 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/HomebrewTests.swift@@ -51,6 +51,47 @@ struct HomebrewTests {#expect(read.standardError == "Error: It seems the App source is not there.\n")}+ @Test func readsWhenHomebrewLastCheckedForNewVersions() throws {+ let repository = try TemporaryDirectory()+ let fetchHead = try repository.file(".git/FETCH_HEAD", contents: Data("main of https://github.com/Homebrew/brew\n".utf8))+ let checked = Date(timeIntervalSince1970: 1_792_315_250)+ let path = fetchHead.path(percentEncoded: false)+ try FileManager.default.setAttributes([.modificationDate: checked], ofItemAtPath: path)+ #expect(Homebrew.lastUpdateCheck(inRepository: repository.url) == checked)++ let linked = try TemporaryDirectory()+ try linked.directory(".git")+ try FileManager.default.createSymbolicLink(at: linked.url.appending(path: ".git/FETCH_HEAD"), withDestinationURL: fetchHead)+ #expect(Homebrew.lastUpdateCheck(inRepository: linked.url) == nil, "Homebrew's `find -type f` passes over a link")++ let folder = try TemporaryDirectory()+ try folder.directory(".git/FETCH_HEAD")+ #expect(Homebrew.lastUpdateCheck(inRepository: folder.url) == nil)+ let empty = try TemporaryDirectory()+ #expect(Homebrew.lastUpdateCheck(inRepository: empty.url) == nil)+ }++ @Test func readsTheLastCheckOfTheHomebrewOnThisMac() async throws {+ guard Homebrew.executableURL != nil else {+ #expect(await Homebrew.lastUpdateCheck() == nil)+ return+ }+ let answer = try await Homebrew.execute(["--repository"], autoUpdate: false, timeout: 30).answer()+ let repository = try #require(Homebrew.folder(answering: answer))+ let fetchHead = repository.appending(path: ".git/FETCH_HEAD").path(percentEncoded: false)+ let attributes = try? FileManager.default.attributesOfItem(atPath: fetchHead)+ let isAFile = attributes?[.type] as? FileAttributeType == .typeRegular+ let expected = isAFile ? attributes?[.modificationDate] as? Date : nil+ let read = await Homebrew.lastUpdateCheck()++ #expect((read == nil) == (expected == nil))+ if let read, let expected {+ #expect(abs(read.timeIntervalSince(expected)) < 0.001)+ }+ guard await Homebrew.hasLocalDefinitions() else { return }+ #expect(try await Homebrew.installedPackages().allSatisfy { $0.lastUpdateCheck == read })+ }+@Test func anUpgradeNeverWaitsForAnAnswer() {for autoUpdate in [true, false] {#expect(Homebrew.environment(autoUpdate: autoUpdate)["HOMEBREW_NO_ASK"] == "1")diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swiftindex 499a35ef..b3423ad1 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateCheckerTests.swift@@ -130,18 +130,38 @@ private final class CannedProtocol: URLProtocol, @unchecked Sendable {#expect(await checker.status(for: sparkleApp()) == expected)}+ private let homebrewChecked = Date(timeIntervalSince1970: 1_792_315_250)++ private func checking(at now: Date) -> UpdateChecker {+ let configuration = URLSessionConfiguration.ephemeral+ configuration.protocolClasses = [CannedProtocol.self]+ return UpdateChecker(session: URLSession(configuration: configuration), clock: { now })+ }++ private var feedlessApp: InstalledApp {+ InstalledApp(url: URL(filePath: "/Applications/Example.app"), bundleIdentifier: "com.example.app", name: "Example", version: "1.0")+ }++ private var fedApp: InstalledApp {+ InstalledApp(+ url: feedlessApp.url, bundleIdentifier: feedlessApp.bundleIdentifier, name: feedlessApp.name,+ version: "1.0", buildVersion: "100", updateFeed: sparkleApp().updateFeed+ )+ }++ private func cask(latest: String = "1.0", checked: Date?) -> HomebrewPackage {+ HomebrewPackage(+ name: "example", kind: .cask, installedVersion: "1.0", latestVersion: latest, isOutdated: latest != "1.0",+ appNames: ["Example.app"]+ ).noting(lastUpdateCheck: checked)+ }+/// Many apps installed with Homebrew carry no update feed of their own. In the automatic mode, Homebrew's/// answer is used for them rather than "Can't check for updates".@Test func automaticFallsBackToWhatHomebrewKnows() async {- let app = InstalledApp(url: URL(filePath: "/Applications/Example.app"), bundleIdentifier: "com.example.app", name: "Example", version: "1.0")- let current = HomebrewPackage(- name: "example",- kind: .cask,- installedVersion: "1.0",- latestVersion: "1.0",- isOutdated: false,- appNames: ["Example.app"]- )+ let app = feedlessApp+ let current = cask(checked: homebrewChecked)+ let checker = checking(at: homebrewChecked + 60 * 60)reply("nowhere.example.com", "")#expect(await checker.status(for: app, preference: .automatic, casks: [current]) == .upToDate)@@ -161,6 +181,84 @@ private final class CannedProtocol: URLProtocol, @unchecked Sendable {#expect(await checker.status(for: fed, preference: .automatic, casks: [current]) == .upToDate)}+ @Test func homebrewCanNotSayAnAppIsUpToDateADayAfterItChecked() async {+ let later = checking(at: homebrewChecked + 2 * Homebrew.autoUpdateInterval)+ let current = [cask(checked: homebrewChecked)]+ reply("nowhere.example.com", "")++ #expect(await later.status(for: feedlessApp, preference: .automatic, casks: current) == .unsupported)+ #expect(await later.status(for: feedlessApp, preference: .homebrew, casks: current) == .unsupported)+ #expect(+ await later.status(for: feedlessApp, preference: .automatic, casks: [cask(checked: nil)]) == .unsupported,+ "no check known"+ )+ #expect(+ await later.status(for: feedlessApp, casks: [cask(latest: "2.0", checked: nil)])+ == .updateAvailable(version: "2.0", source: .homebrew, releaseNotes: nil)+ )+ #expect(CannedProtocol.asked.withLock { $0 }.isEmpty)++ reply("feed.example.com", appcast("<item><enclosure url=\"https://feed.example.com/a.zip\" sparkle:version=\"200\" sparkle:shortVersionString=\"2.0\" /></item>"))+ #expect(+ await later.status(for: fedApp, preference: .homebrew, casks: current)+ == .updateAvailable(version: "2.0", source: .developer, releaseNotes: nil)+ )+ #expect(CannedProtocol.asked.withLock { $0 } == ["feed.example.com"])++ reply("feed.example.com", status: 500, "")+ #expect(await later.status(for: fedApp, preference: .automatic, casks: current) == .failed)+ }++ @Test func answersWithoutAServerWhatHomebrewAndTheAppAloneDecide() async {+ let recent = checking(at: homebrewChecked + 60 * 60)+ let later = checking(at: homebrewChecked + 2 * Homebrew.autoUpdateInterval)+ let current = [cask(checked: homebrewChecked)]+ let outdated = [cask(latest: "2.0", checked: nil)]+ let update = UpdateStatus.updateAvailable(version: "2.0", source: .homebrew, releaseNotes: nil)+ reply("nowhere.example.com", "")++ for preference in UpdateSource.allCases {+ for casks in [outdated, current, []] {+ for checker in [recent, later] {+ let decided = checker.statusWithoutAsking(for: feedlessApp, preference: preference, casks: casks)+ #expect(decided != nil)+ #expect(await decided == checker.status(for: feedlessApp, preference: preference, casks: casks))+ }+ }+ }+ #expect(CannedProtocol.asked.withLock { $0 }.isEmpty)++ #expect(recent.statusWithoutAsking(for: feedlessApp, preference: .automatic, casks: current) == .upToDate)+ #expect(later.statusWithoutAsking(for: feedlessApp, preference: .automatic, casks: current) == .unsupported)+ #expect(later.statusWithoutAsking(for: feedlessApp, preference: .developer, casks: outdated) == .unsupported)+ #expect(later.statusWithoutAsking(for: fedApp, preference: .automatic, casks: outdated) == update)+ #expect(recent.statusWithoutAsking(for: fedApp, preference: .automatic, casks: current) == nil, "feed first")+ #expect(recent.statusWithoutAsking(for: fedApp, preference: .homebrew, casks: current) == .upToDate)+ #expect(later.statusWithoutAsking(for: fedApp, preference: .homebrew, casks: current) == nil, "its feed answers")+ #expect(recent.statusWithoutAsking(for: fedApp, preference: .developer, casks: outdated) == nil)+ }++ @Test func namesTheCaskHomebrewHasNotCheckedForADay() {+ let recent = checking(at: homebrewChecked + 60 * 60)+ let later = checking(at: homebrewChecked + 2 * Homebrew.autoUpdateInterval)+ let current = [cask(checked: homebrewChecked)]+ let unknown = [cask(checked: nil)]+ let outdated = [cask(latest: "2.0", checked: homebrewChecked)]++ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: current)?.name == "example")+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .homebrew, casks: current)?.name == "example")+ #expect(recent.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: unknown)?.name == "example")+ #expect(recent.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: current) == nil)+ #expect(+ later.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: outdated) == nil,+ "an update Homebrew knows of is an answer"+ )+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .developer, casks: current) == nil)+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .appStore, casks: current) == nil)+ #expect(later.caskNotCheckedRecently(for: fedApp, preference: .automatic, casks: current) == nil, "its feed")+ #expect(later.caskNotCheckedRecently(for: feedlessApp, preference: .automatic, casks: []) == nil)+ }+@Test func aMacAppReadsNoIPhoneRecord() async {let sold = InstalledApp(url: URL(filePath: "/Applications/Notes Pro.app"),diff --git a/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swiftindex 7e803643..36db28a0 100644--- a/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift+++ b/Packages/PeelCore/Tests/PeelCoreTests/UpdateTests.swift@@ -644,6 +644,28 @@ struct UpdateSourceTests {#expect(CaskEvidence.cask(for: firefox, in: casks)?.name == "firefox@esr")}+ @Test func homebrewSaysAnAppIsUpToDateOnlyWithinADayOfItsLastCheck() {+ let checked = Date(timeIntervalSince1970: 1_792_315_250)+ let day = Homebrew.autoUpdateInterval+ let unknown = HomebrewPackage(name: "example", kind: .cask, installedVersion: "1.0", latestVersion: "1.0")+ let current = unknown.noting(lastUpdateCheck: checked)+ let behind = HomebrewPackage(+ name: "example", kind: .cask, installedVersion: "1.0", latestVersion: "2.0", isOutdated: true+ )+ let update = UpdateStatus.updateAvailable(version: "2.0", source: .homebrew, releaseNotes: nil)+ let status = { (cask: HomebrewPackage, now: Date) in UpdateChecker.homebrewStatus(of: cask, at: now) }++ #expect(day == 86_400)+ #expect(status(current, checked + 60) == .upToDate)+ #expect(status(current, checked + day - 1) == .upToDate)+ #expect(status(current, checked + day) == nil, "Homebrew's own `find -newermt` wants it newer than a day")+ #expect(status(current, checked + 4 * day) == nil)+ #expect(status(unknown.noting(lastUpdateCheck: checked + day), checked) == .upToDate, "as for Homebrew")+ #expect(status(unknown, checked) == nil, "no check known")+ #expect(status(behind.noting(lastUpdateCheck: checked), checked + 4 * day) == update)+ #expect(status(behind, checked) == update)+ }+@Test func anUpdateHomebrewReportedHoldsOnlyWhileTheAppIsHomebrews() {let homebrew = UpdateStatus.updateAvailable(version: "2.0", source: .homebrew)#expect(homebrew.holds(whileHomebrews: true))diff --git a/Peel/Model/AppLibrary.swift b/Peel/Model/AppLibrary.swiftindex 47a434ba..78054600 100644--- a/Peel/Model/AppLibrary.swift+++ b/Peel/Model/AppLibrary.swift@@ -532,13 +532,12 @@ final class AppLibrary {// Read here, where every caller passes. Settings promises that with this off, Peel contacts nothing on// its own, so even Rescan on an app's page only rescans files.guard defaults.isOn(SettingsKey.checksForAppUpdates, whenNeverSet: true) else { return }+ // What Homebrew says lasts only a day after its last check, so its casks decide again in every round.+ applyHomebrewStatuses()let now = Date.now// An app is checked on a schedule kept by its identifier, so an app with none is left to Homebrew's answer.- // Peel's own copies are left to Sparkle, which checks the one running and is the only way it updates.let wanted = targets.filter { app in- guard let identifier = app.bundleIdentifier, !app.isPeelItself, !isIgnored(app),- !appsInATrash.contains(app.id)- else { return false }+ guard let identifier = app.bundleIdentifier, isAskedAboutUpdates(app) else { return false }guard !force else { return true }// Already being checked by another round: a second answer could double the wait for the next check.guard !appsCheckingForUpdates.contains(app.id) else { return false }@@ -569,7 +568,6 @@ final class AppLibrary {}}while case let (id, answer)? = await group.next() {- let status = answer.status// The update source changed since this round began, and the round that change started answers now.guard updateRounds.answered(id, in: round) else {group.cancelAll()@@ -582,6 +580,10 @@ final class AppLibrary {guard let app = asked[id], apps.contains(where: { $0.id == id && $0.isTheSameBuild(as: app) }) else {continue}+ // Homebrew may have been read again while this answer was on its way: its casks decide where they can.+ let status = casks == self.casks+ ? answer.status+ : checker.statusWithoutAsking(for: app, preference: preference, casks: self.casks) ?? answer.statuslet kept = status.following(updateStatuses[id])// Any write redraws the whole Applications list, so an answer that changes nothing is not written.if updateStatuses[id] != kept {@@ -792,20 +794,35 @@ final class AppLibrary {UpdateMemoryStore.save(memory, to: defaults)}- /// Records an update for each app whose cask Homebrew marks outdated. Reading Homebrew costs no network- /// request, so this doesn't wait for the update schedule, and Applications agrees with the Homebrew page.- /// It applies only to an app with no answer of its own, or whose own check failed or had no feed to ask:- /// an answer from the app's own feed wins.+ /// Shows for each app Homebrew installed what a check would answer now without asking any server, from Homebrew's+ /// casks and the app's own files. Reading Homebrew costs no network request, so this doesn't wait for the update+ /// schedule, and Applications agrees with the Homebrew page. A check never asks Homebrew while the app's own feed+ /// or the App Store is preferred: then only an update Homebrew knows of fills in for an app whose own check has+ /// nothing, a failure, or no feed to ask.private func applyHomebrewStatuses() {- for (id, cask) in homebrewApps {- let homebrew = UpdateChecker.homebrewStatus(of: cask)- guard case .updateAvailable = homebrew else { continue }- let known = updateStatuses[id]- guard known == nil || known == .failed || known == .unsupported else { continue }- updateStatuses[id] = homebrew+ let preference = updateSource+ for app in apps where homebrewApps[app.id] != nil && isAskedAboutUpdates(app) {+ let known = updateStatuses[app.id]+ let decided: UpdateStatus?+ switch preference {+ case .automatic, .homebrew:+ decided = updateChecker.statusWithoutAsking(for: app, preference: preference, casks: casks)+ case .developer, .appStore:+ let homebrew = updateChecker.homebrewStatus(for: app, casks: casks)+ let hasNoAnswer = known == nil || known == .failed || known == .unsupported+ decided = hasNoAnswer && homebrew?.version != nil ? homebrew : nil+ }+ guard let decided, decided != known else { continue }+ updateStatuses[app.id] = decided}}+ /// Whether update checks ask about `app`. Never about Peel's own copies, which Sparkle keeps current, checking+ /// the one running, nor about an app the user told Peel never to check or a copy in a Trash.+ private func isAskedAboutUpdates(_ app: InstalledApp) -> Bool {+ !app.isPeelItself && !isIgnored(app) && !appsInATrash.contains(app.id)+ }+private func matchHomebrewApps() {let casks = caskshomebrewApps = Dictionary(uniqueKeysWithValues: apps.compactMap { app indiff --git a/PeelTests/AppLibraryTests.swift b/PeelTests/AppLibraryTests.swiftindex 2d316e54..8734ede7 100644--- a/PeelTests/AppLibraryTests.swift+++ b/PeelTests/AppLibraryTests.swift@@ -22,6 +22,44 @@ private nonisolated final class AppcastProtocol: URLProtocol, @unchecked Sendabl}}+/// Holds every request until the test lets it through, so a round of checks can be caught while it waits.+private nonisolated final class HeldProtocol: URLProtocol, @unchecked Sendable {+ static let body = Mutex(Data())+ static let arrived = Mutex<AsyncStream<Void>.Continuation?>(nil)+ static let gate = DispatchSemaphore(value: 0)++ override class func canInit(with request: URLRequest) -> Bool { true }+ override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }+ override func stopLoading() {}++ override func startLoading() {+ _ = Self.arrived.withLock { $0?.yield() }+ _ = Self.gate.wait(timeout: .now() + 10)+ guard let url = request.url,+ let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: nil)+ else { return }+ client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)+ client?.urlProtocol(self, didLoad: Self.body.withLock { $0 })+ client?.urlProtocolDidFinishLoading(self)+ }+}++private nonisolated final class TestClock: Sendable {+ private let moment: Mutex<Date>++ init(_ moment: Date) {+ self.moment = Mutex(moment)+ }++ func now() -> Date {+ moment.withLock { $0 }+ }++ func set(_ moment: Date) {+ self.moment.withLock { $0 = moment }+ }+}+@Suite(.serialized) struct AppLibraryTests {@Test func aRoundRemembersItsAnswerInTheStoresItWasGiven() async throws {let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")@@ -84,16 +122,47 @@ private nonisolated final class AppcastProtocol: URLProtocol, @unchecked Sendablreturn bundle}- private func library(with defaults: UserDefaults, notesIn folder: URL) -> AppLibrary {+ private func library(+ with defaults: UserDefaults,+ notesIn folder: URL,+ clock: TestClock? = nil,+ answeredBy answering: URLProtocol.Type = AppcastProtocol.self+ ) -> AppLibrary {let configuration = URLSessionConfiguration.ephemeral- configuration.protocolClasses = [AppcastProtocol.self]+ configuration.protocolClasses = [answering]+ let session = URLSession(configuration: configuration)return AppLibrary(defaults: defaults,- updateChecker: UpdateChecker(session: URLSession(configuration: configuration)),+ updateChecker: clock.map { clock in UpdateChecker(session: session, clock: { clock.now() }) }+ ?? UpdateChecker(session: session),releaseNotesStore: ReleaseNotesStore(url: folder.appending(path: "release-notes.json")))}+ private let homebrewChecked = Date(timeIntervalSince1970: 1_792_315_250)++ private func caskApp(_ name: String, in folder: URL, feed: String? = nil) throws -> URL {+ let bundle = folder.appending(path: "\(name).app", directoryHint: .isDirectory)+ try FileManager.default.createDirectory(+ at: bundle.appending(path: "Contents"), withIntermediateDirectories: true+ )+ var info: [String: Any] = [+ "CFBundleIdentifier": "org.example.\(name.lowercased())", "CFBundleName": name,+ "CFBundlePackageType": "APPL", "CFBundleShortVersionString": "1.0", "CFBundleVersion": "100",+ ]+ info["SUFeedURL"] = feed+ try PropertyListSerialization.data(fromPropertyList: info, format: .xml, options: 0)+ .write(to: bundle.appending(path: "Contents/Info.plist"))+ return bundle+ }++ private func cask(_ name: String, latest: String = "1.0", checked: Date?) -> HomebrewPackage {+ HomebrewPackage(+ name: name.lowercased(), kind: .cask, installedVersion: "1.0", latestVersion: latest,+ isOutdated: latest != "1.0", appNames: ["\(name).app"]+ ).noting(lastUpdateCheck: checked)+ }+private func listing(_ version: String) -> Data {Data(#"{"resultCount":1,"results":[{"kind":"mac-software","version":"\#(version)"}]}"#.utf8)}@@ -139,4 +208,107 @@ private nonisolated final class AppcastProtocol: URLProtocol, @unchecked Sendablawait library.recheck?.value#expect(library.shownUpdateStatus(of: app)?.version == "1.1")}++ @Test func showsWhatHomebrewSaysOfAnAppWithNoFeedAsSoonAsHomebrewIsRead() async throws {+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")+ let bundle = try caskApp("Tool", in: folder)+ defer { try? FileManager.default.removeItem(at: folder) }+ let made = try MadeUpDefaults()+ defer { made.forget() }+ let clock = TestClock(homebrewChecked + 60 * 60)+ let library = library(with: made.defaults, notesIn: folder, clock: clock)++ #expect(await library.reveal([bundle]))+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)+ #expect(library.shownUpdateStatus(of: app) == .upToDate)++ library.loadHomebrewCasks([cask("Tool", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0")++ clock.set(homebrewChecked + 2 * Homebrew.autoUpdateInterval)+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)+ #expect(library.shownUpdateStatus(of: app) == .unsupported)+ }++ @Test func anUpdateHomebrewLearnsOfReplacesTheUpToDateItGaveBefore() async throws {+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")+ let bundle = try caskApp("Tool", in: folder)+ defer { try? FileManager.default.removeItem(at: folder) }+ let made = try MadeUpDefaults()+ defer { made.forget() }+ let library = library(with: made.defaults, notesIn: folder, clock: TestClock(homebrewChecked + 60 * 60))++ #expect(await library.reveal([bundle]))+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)+ await library.checkForUpdates([app], force: true)+ #expect(library.shownUpdateStatus(of: app) == .upToDate)++ library.loadHomebrewCasks([cask("Tool", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0")+ }++ @Test func aRoundTakesBackHomebrewsUpToDateOnceItsCheckIsADayOld() async throws {+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")+ let bundle = try caskApp("Tool", in: folder)+ defer { try? FileManager.default.removeItem(at: folder) }+ let made = try MadeUpDefaults()+ defer { made.forget() }+ let clock = TestClock(homebrewChecked + 60 * 60)+ let library = library(with: made.defaults, notesIn: folder, clock: clock)++ #expect(await library.reveal([bundle]))+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })+ library.loadHomebrewCasks([cask("Tool", checked: homebrewChecked)], knowsItsOwnApps: true)+ await library.checkForUpdates([app], force: true)+ #expect(library.shownUpdateStatus(of: app) == .upToDate)++ clock.set(homebrewChecked + 2 * Homebrew.autoUpdateInterval)+ await library.checkForUpdates([app])+ #expect(library.shownUpdateStatus(of: app) == .unsupported, "not due, yet Homebrew can no longer tell")+ }++ @Test func anAppPeelNeverChecksGetsNothingFromHomebrew() async throws {+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")+ let bundle = try caskApp("Tool", in: folder)+ defer { try? FileManager.default.removeItem(at: folder) }+ let made = try MadeUpDefaults()+ defer { made.forget() }+ let library = library(with: made.defaults, notesIn: folder, clock: TestClock(homebrewChecked + 60 * 60))++ #expect(await library.reveal([bundle]))+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.tool" })+ library.setIgnored(true, for: app)+ library.loadHomebrewCasks([cask("Tool", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)+ #expect(library.updateStatuses[app.id] == nil)+ }++ @Test func anAnswerThatCrossedANewReadingOfHomebrewGivesWayToItsCasks() async throws {+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")+ let bundle = try caskApp("Fed", in: folder, feed: "https://feed.example.com/appcast.xml")+ defer { try? FileManager.default.removeItem(at: folder) }+ let made = try MadeUpDefaults()+ defer { made.forget() }+ HeldProtocol.body.withLock {+ $0 = Data(#"<rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"><channel><item><enclosure url="https://feed.example.com/u.zip" sparkle:version="100" sparkle:shortVersionString="1.0" /></item></channel></rss>"#.utf8)+ }+ let (arrivals, arrival) = AsyncStream.makeStream(of: Void.self)+ HeldProtocol.arrived.withLock { $0 = arrival }+ defer { HeldProtocol.arrived.withLock { $0 = nil } }+ let clock = TestClock(homebrewChecked + 60 * 60)+ let library = library(with: made.defaults, notesIn: folder, clock: clock, answeredBy: HeldProtocol.self)++ #expect(await library.reveal([bundle]))+ let app = try #require(library.apps.first { $0.bundleIdentifier == "org.example.fed" })+ library.loadHomebrewCasks([cask("Fed", checked: homebrewChecked)], knowsItsOwnApps: true)+ let round = Task { await library.checkForUpdates([app], force: true) }+ for await _ in arrivals { break }+ library.loadHomebrewCasks([cask("Fed", latest: "2.0", checked: homebrewChecked)], knowsItsOwnApps: true)+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0")++ HeldProtocol.gate.signal()+ await round.value+ #expect(library.shownUpdateStatus(of: app)?.version == "2.0", "the feed was asked with what Homebrew said before")+ }}