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.

Keep saying what is wrong with the Not Moved list, and let it start over

Țugui Dragoș6a933233e783
diff --git a/AGENTS.md b/AGENTS.md
index 4a2216a0..7b6f3b41 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -77,8 +77,8 @@ checked by hand. If a change makes one of them fail, the rule is right and the c
them the user's: the empty placeholder `TrashMover` makes to hold a name on a disk that can't rename without
replacing (exFAT), once the move it was made for has failed; the folder `PreferenceBackup` makes for a reset's saved
settings, when saving fails while it is still empty; and the empty file cfprefsd writes back where a moved settings
- file was, when `PreferenceCleanup` forgets a domain cfprefsd still holds. Peel's list of refusals goes to the Trash
- when `peel history --refused --clear` asks.
+ file was, when `PreferenceCleanup` forgets a domain cfprefsd still holds. Peel's list of refusals, with any copy of it
+ set aside because it couldn't be read, goes to the Trash when `peel history --refused --clear` asks.
- **What History can't undo says so where the person confirms it**: Homebrew's own uninstall and its cleanups,
resetting an app's privacy permissions, and Force Quit for an app that is still open 10 seconds after Peel asked
it to quit. `defaults delete` for an app's preferences runs only once their file is in the Trash, and a reset
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index eca55b54..ef50f919 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -196,8 +196,9 @@ A handful of ideas carry most of the weight. Each is enforced in one place and t
settings, when saving fails while it is still empty; the folders Put Back makes on the way back
(`DirectoryHandle.child(_:makingIfMissing:)`), when the item then stays in the Trash and each is still the empty
folder it made; and the empty file cfprefsd writes back where a moved settings file was when `PreferenceCleanup`
- forgets a domain it still holds, which would keep History from putting that file back. Peel's list of refusals goes
- to the Trash when `peel history --refused --clear` asks. Four actions can't be undone by History, and each says so
+ forgets a domain it still holds, which would keep History from putting that file back. Peel's list of refusals, with
+ any copy of it set aside because it couldn't be read, goes to the Trash when `peel history --refused --clear` asks.
+ Four actions can't be undone by History, and each says so
where it is confirmed: Homebrew's own uninstall and cleanups, resetting an app's privacy permissions, and Force Quit
for an app that is still open 10 seconds after Peel asked it to quit (`QuitBeforeRemoving`). Moving Mullvad VPN,
Citrix Workspace, or TeamViewer starts that app's own uninstaller, which deletes what History can't bring back, and
diff --git a/Localization/Peel/Localizable.xcstrings b/Localization/Peel/Localizable.xcstrings
index d062388e..76740868 100644
--- a/Localization/Peel/Localizable.xcstrings
+++ b/Localization/Peel/Localizable.xcstrings
@@ -123008,112 +123008,6 @@
}
}
},
- "Peel leaves the file as it is and adds nothing to it, since it is the only record of what stayed." : {
- "localizations" : {
- "cs" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel soubor ponechává tak, jak je, a nic do něj nepřidává, protože je to jediný záznam o tom, co zůstalo."
- }
- },
- "de" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel lässt die Datei, wie sie ist, und fügt ihr nichts hinzu, da sie die einzige Aufzeichnung dessen ist, was geblieben ist."
- }
- },
- "es" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel deja el archivo tal como está y no le añade nada, ya que es el único registro de lo que se quedó sin trasladar."
- }
- },
- "fr" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel laisse le fichier tel quel et n’y ajoute rien, car c’est la seule trace de ce qui est resté en place."
- }
- },
- "it" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel lascia il file com’è e non vi aggiunge nulla, perché è l’unico registro di ciò che è rimasto."
- }
- },
- "ja" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "このファイルは残った項目の唯一の記録であるため、Peelはファイルをそのままにし、何も書き加えません。"
- }
- },
- "ko" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel은 파일을 그대로 두고 아무것도 추가하지 않습니다. 이 파일이 그대로 남은 항목에 대한 유일한 기록이기 때문입니다."
- }
- },
- "nl" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel laat het bestand zoals het is en voegt er niets aan toe, omdat het de enige registratie is van wat er is blijven staan."
- }
- },
- "pl" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel zostawia plik bez zmian i nic do niego nie dopisuje, bo to jedyny zapis tego, co zostało na miejscu."
- }
- },
- "pt" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "O Peel deixa o arquivo como está e não acrescenta nada a ele, pois é o único registro do que permaneceu."
- }
- },
- "ro" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel lasă fișierul așa cum este și nu adaugă nimic în el, deoarece este singura evidență a ceea ce a rămas pe loc."
- }
- },
- "ru" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel оставляет файл как есть и ничего в него не добавляет, поскольку это единственная запись о том, что осталось на месте."
- }
- },
- "sv" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel lämnar filen som den är och lägger inte till något i den, eftersom den är den enda förteckningen över det som blev kvar."
- }
- },
- "tr" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel dosyayı olduğu gibi bırakır ve ona hiçbir şey eklemez, çünkü yerinde kalanların tek kaydı odur."
- }
- },
- "uk" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel лишає файл без змін і нічого до нього не додає, бо лише в ньому записано те, що лишилося на місці."
- }
- },
- "zh-Hans" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel会保持该文件原样,不向其中添加任何内容,因为它是哪些项目留在原处的唯一记录。"
- }
- },
- "zh-Hant" : {
- "stringUnit" : {
- "state" : "translated",
- "value" : "Peel會保持檔案原樣,不會加入任何內容,因為這是留在原處之項目的唯一記錄。"
- }
- }
- }
- },
"Peel lists at most ^[%lld file](inflect: true), yours first and largest first. Narrow the search to see the rest." : {
"localizations" : {
"cs" : {
@@ -191307,6 +191201,112 @@
}
}
},
+ "Until you start the list over, Peel adds nothing to it, since it is the only record of what stayed. Starting over keeps the old file beside a new one." : {
+ "localizations" : {
+ "cs" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Dokud nezačnete seznam znovu, Peel do něj nic nepřidá, protože je to jediný záznam o tom, co zůstalo. Když začnete znovu, starý soubor se ponechá vedle nového."
+ }
+ },
+ "de" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Bis du die Liste neu beginnst, fügt Peel ihr nichts hinzu, da sie die einzige Aufzeichnung dessen ist, was geblieben ist. Wenn du neu beginnst, bleibt die alte Datei neben einer neuen erhalten."
+ }
+ },
+ "es" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Hasta que vuelvas a empezar la lista, Peel no le añade nada, ya que es el único registro de lo que se quedó sin trasladar. Al volver a empezar, el archivo antiguo se conserva junto a uno nuevo."
+ }
+ },
+ "fr" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Tant que vous n’avez pas recommencé la liste, Peel n’y ajoute rien, car c’est la seule trace de ce qui est resté en place. Si vous recommencez, l’ancien fichier est conservé à côté d’un nouveau."
+ }
+ },
+ "it" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Finché non ricominci l’elenco da capo, Peel non vi aggiunge nulla, perché è l’unico registro di ciò che è rimasto. Se ricominci da capo, il vecchio file viene conservato accanto a uno nuovo."
+ }
+ },
+ "ja" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "リストを最初からやり直すまで、Peelはリストに何も書き加えません。残った項目の唯一の記録であるためです。最初からやり直すと、古いファイルは新しいファイルの横に保管されます。"
+ }
+ },
+ "ko" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "사용자가 목록을 처음부터 다시 시작하기 전까지, Peel은 이 목록에 아무것도 추가하지 않습니다. 이 목록이 그대로 남은 항목에 대한 유일한 기록이기 때문입니다. 처음부터 다시 시작하면 이전 파일은 새 파일 옆에 보관됩니다."
+ }
+ },
+ "nl" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Totdat je opnieuw begint met de lijst, voegt Peel er niets aan toe, omdat het de enige registratie is van wat er is blijven staan. Als je opnieuw begint, wordt het oude bestand naast een nieuw bestand bewaard."
+ }
+ },
+ "pl" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Dopóki nie zaczniesz listy od nowa, Peel nic do niej nie dopisuje, bo to jedyny zapis tego, co zostało na miejscu. Gdy zaczniesz od nowa, stary plik zostanie zachowany obok nowego."
+ }
+ },
+ "pt" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Até você recomeçar a lista, o Peel não acrescenta nada a ela, pois ela é o único registro do que permaneceu. Ao recomeçar, o arquivo antigo é guardado ao lado de um novo."
+ }
+ },
+ "ro" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Până când reîncepeți lista, Peel nu adaugă nimic în ea, deoarece este singura evidență a ceea ce a rămas pe loc. Dacă o reîncepeți, fișierul vechi este păstrat lângă unul nou."
+ }
+ },
+ "ru" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Пока Вы не начнете список заново, Peel ничего в него не добавляет, поскольку это единственная запись о том, что осталось на месте. Если начать заново, старый файл сохранится рядом с новым."
+ }
+ },
+ "sv" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Tills du börjar om listan lägger Peel inte till något i den, eftersom den är den enda förteckningen över det som blev kvar. När du börjar om sparas den gamla filen bredvid en ny."
+ }
+ },
+ "tr" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Siz listeyi baştan başlatana kadar Peel ona hiçbir şey eklemez, çünkü yerinde kalanların tek kaydı odur. Baştan başladığınızda eski dosya yeni bir dosyanın yanında saklanır."
+ }
+ },
+ "uk" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "Доки ви не почнете список наново, Peel нічого до нього не додає, бо лише в ньому записано те, що лишилося на місці. Коли ви починаєте наново, старий файл зберігається поруч із новим."
+ }
+ },
+ "zh-Hans" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "在你重新开始建立该列表之前,Peel不会向其中添加任何内容,因为它是哪些项目留在原处的唯一记录。重新开始会将旧文件保留在新文件旁边。"
+ }
+ },
+ "zh-Hant" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "在你重新開始此列表之前,Peel不會在其中加入任何內容,因為這是留在原處之項目的唯一記錄。重新開始時,舊檔案會保留在新檔案旁邊。"
+ }
+ }
+ }
+ },
"Until you start the record over, Peel can’t warn you when an app’s signer changes. Starting over keeps the old file beside a new one." : {
"localizations" : {
"cs" : {
diff --git a/Packages/PeelCore/Sources/PeelCommandLine/Commands/HistoryCommands.swift b/Packages/PeelCore/Sources/PeelCommandLine/Commands/HistoryCommands.swift
index 7528029c..890643d3 100644
--- a/Packages/PeelCore/Sources/PeelCommandLine/Commands/HistoryCommands.swift
+++ b/Packages/PeelCore/Sources/PeelCommandLine/Commands/HistoryCommands.swift
@@ -239,7 +239,7 @@ struct HistoryCommand: AsyncParsableCommand {
private func listRefusals(in log: RefusalLog, trash: TrashService) async throws {
guard !clear else {
- guard await log.load().records?.isEmpty != true else {
+ guard await !log.holdsNothing() else {
Output.line("Peel hasn't refused anything it was asked to move.")
return
}
diff --git a/Packages/PeelCore/Sources/PeelCommandLine/Support/Output.swift b/Packages/PeelCore/Sources/PeelCommandLine/Support/Output.swift
index d74a6785..8164a27f 100644
--- a/Packages/PeelCore/Sources/PeelCommandLine/Support/Output.swift
+++ b/Packages/PeelCore/Sources/PeelCommandLine/Support/Output.swift
@@ -282,7 +282,9 @@ extension RefusalLogProblem {
case .damaged(let setAside):
"The list of refusals was damaged, so it was kept as \(Output.plain(Output.path(setAside)))"
+ " and started again."
- case .unreadable: "The list of refusals couldn't be read, so Peel keeps it as it is and writes nothing to it."
+ case .unreadable:
+ "The list of refusals couldn't be read, so Peel writes nothing to it until you clear it with"
+ + " `peel history --refused --clear` or start it over in the Peel app's History."
case .couldNotRecord: "The list of refusals couldn't be saved, so what stayed this time isn't in it."
}
}
diff --git a/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift b/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift
index 6719968a..d929d2d9 100644
--- a/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift
+++ b/Packages/PeelCore/Sources/PeelCore/Removal/RefusalLog.swift
@@ -56,15 +56,19 @@ public actor RefusalLog {
public let url: URL
/// What was last read or written, kept while the file stays the same, as in `RemovalLog`.
private var kept: (file: FileIdentity, records: [RefusalRecord])?
+ private var problem: RefusalLogProblem?
public init(url: URL = RemovalHistory.refusalsURL) {
self.url = url
}
- /// The records, with what went wrong reading them. Nil records when the file could not be read: what was refused
- /// is then not known, which is not the same as nothing refused.
+ /// The records, with what is still to be said about the file (`note`). Nil records when the file could not be
+ /// read: what was refused is then not known, which is not the same as nothing refused.
public func load() -> (records: [RefusalRecord]?, problem: RefusalLogProblem?) {
- FileLock.whileHeld(beside: url) { current() }
+ FileLock.whileHeld(beside: url) {
+ let records = current()
+ return (records, problem)
+ }
}
/// Writes down what one removal refused, and says what kept it from being written. The parts of one pass
@@ -80,49 +84,99 @@ public actor RefusalLog {
}
guard !records.isEmpty else { return nil }
return FileLock.whileHeld(beside: url) {
- let read = current()
- guard let existing = read.records else { return read.problem }
+ guard let existing = current() else { return problem }
let kept = Batches.trimmed(
existing + records, maximum: Self.maximumRecords, batch: { $0.batch ?? $0.id }, date: \.date,
keeping: [batch]
)
- return write(kept) ? read.problem : .couldNotRecord
+ guard write(kept) else {
+ note(.couldNotRecord)
+ return problem
+ }
+ if problem == .couldNotRecord { problem = nil }
+ return problem
}
}
- /// Moves the file to the Trash, so every refusal is forgotten and the record can still be taken back from there.
- /// Only the file moves, never a folder or a link put in its place, and a refusal written meanwhile waits for it.
+ /// Keeps a file that cannot be read beside a new one, under another name, and starts writing refusals down again.
+ public func startOver() -> (records: [RefusalRecord]?, problem: RefusalLogProblem?) {
+ FileLock.whileHeld(beside: url) {
+ if let records = current() { return (records, problem) }
+ guard DamagedFile.setAside(url) != nil else { return (nil, problem) }
+ problem = nil
+ let records = current()
+ return (records, problem)
+ }
+ }
+
+ /// Whether nothing is left to forget: no refusal written down, no file that can't be read, and no copy set aside.
+ public func holdsNothing() -> Bool {
+ FileLock.whileHeld(beside: url) { current() == [] && DamagedFile.copies(of: url) == [] }
+ }
+
+ /// Moves the file and the copies set aside to the Trash, so every refusal is forgotten and can still be taken back
+ /// from there. Only files move, never a folder or a link put in their place, and a refusal written meanwhile waits.
public func clear(through service: TrashService) async -> Bool {
await FileLock.whileHeld(beside: url, waitingFor: {
- guard !url.isMissing else { return true }
- var info = stat()
- guard lstat(url.path(percentEncoded: false), &info) == 0, info.st_mode & S_IFMT == S_IFREG else {
- return false
+ guard var files = DamagedFile.copies(of: url) else { return false }
+ if !url.isMissing {
+ var info = stat()
+ guard lstat(url.path(percentEncoded: false), &info) == 0, info.st_mode & S_IFMT == S_IFREG else {
+ return false
+ }
+ files.insert(url, at: 0)
}
- return await service.trashOwnFiles([url]).failures.isEmpty
+ guard !files.isEmpty else { return true }
+ guard await service.trashOwnFiles(files).failures.isEmpty else { return false }
+ problem = nil
+ return true
})
}
- /// The records in the file. A file that fails to decode is set aside and its readable rows kept. Nil records
- /// when the file could not be read or set aside, so it must not be written over.
- private func current() -> (records: [RefusalRecord]?, problem: RefusalLogProblem?) {
- guard !url.isMissing else { return ([], nil) }
- if let kept, FileIdentity.of(url) == kept.file { return (kept.records, nil) }
- guard let read = BoundedRead.contents(at: url, maximum: 16 * 1_024 * 1_024) else { return (nil, .unreadable) }
+ /// The records in the file. A file that fails to decode is set aside and its readable rows kept. Nil when the
+ /// file could not be read or set aside, so it must not be written over.
+ private func current() -> [RefusalRecord]? {
+ guard !url.isMissing else {
+ note(nil)
+ return []
+ }
+ if let kept, FileIdentity.of(url) == kept.file {
+ note(nil)
+ return kept.records
+ }
+ guard let read = BoundedRead.contents(at: url, maximum: 16 * 1_024 * 1_024) else {
+ note(.unreadable)
+ return nil
+ }
let data = read.data
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = LogTime.decoding
if let records = try? decoder.decode([RefusalRecord].self, from: data) {
+ note(nil)
kept = (read.file, records)
- return (records, nil)
+ return records
}
// A row that a later version wrote, or that a hand edit broke, must not cost the other rows.
let readable = (try? decoder.decode([Row].self, from: data))?.compactMap(\.record) ?? []
- guard let setAside = DamagedFile.setAside(url) else { return (nil, .unreadable) }
+ guard let setAside = DamagedFile.setAside(url) else {
+ note(.unreadable)
+ return nil
+ }
+ note(.damaged(setAside: setAside))
if !readable.isEmpty {
write(readable)
}
- return (readable, .damaged(setAside: setAside))
+ return readable
+ }
+
+ /// Sets `problem`, or clears it after a good read (nil), as `RemovalLog` does: a damaged file stays reported while
+ /// the copy set aside is there, since it is the only trace of it, and `.couldNotRecord` until a refusal is written.
+ private func note(_ problem: RefusalLogProblem?) {
+ if problem == nil {
+ if case .damaged(let setAside) = self.problem, !setAside.isMissing { return }
+ if self.problem == .couldNotRecord { return }
+ }
+ self.problem = problem
}
/// One row of the file. A row with a missing or malformed field is dropped and the others are kept: any
diff --git a/Packages/PeelCore/Sources/PeelPrivileged/DamagedFile.swift b/Packages/PeelCore/Sources/PeelPrivileged/DamagedFile.swift
index 517f2d40..34abf749 100644
--- a/Packages/PeelCore/Sources/PeelPrivileged/DamagedFile.swift
+++ b/Packages/PeelCore/Sources/PeelPrivileged/DamagedFile.swift
@@ -21,6 +21,27 @@ public enum DamagedFile {
}
}
+ /// The files `setAside` made of `url`, or nil when their folder can't be listed. Only regular files named exactly
+ /// as it names them count, so nothing else in the folder is taken for one.
+ public static func copies(of url: URL) -> [URL]? {
+ let folder = url.deletingLastPathComponent()
+ let path = folder.path(percentEncoded: false)
+ guard let names = try? FileManager.default.contentsOfDirectory(atPath: path) else {
+ var info = stat()
+ return lstat(path, &info) != 0 && errno == ENOENT ? [] : nil
+ }
+ let prefix = "\(url.deletingPathExtension().lastPathComponent)-damaged-"
+ let suffix = ".\(url.pathExtension)"
+ return names.filter { name in
+ guard name.hasPrefix(prefix), name.hasSuffix(suffix) else { return false }
+ let stamp = name.dropFirst(prefix.count).dropLast(suffix.count)
+ var info = stat()
+ return stamp.wholeMatch(of: /[0-9]{4,}-[0-9]{2}-[0-9]{2}-[0-9]{6}(-[0-9]+)?/) != nil
+ && lstat(folder.appending(path: name).path(percentEncoded: false), &info) == 0
+ && info.st_mode & S_IFMT == S_IFREG
+ }.map { folder.appending(path: $0) }
+ }
+
private static let stamp = Date.VerbatimFormatStyle(
format: """
\(year: .defaultDigits)-\(month: .twoDigits)-\(day: .twoDigits)-\
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/DamagedFileTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/DamagedFileTests.swift
index ef884be4..bbbd9ba0 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/DamagedFileTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/DamagedFileTests.swift
@@ -24,6 +24,31 @@ struct DamagedFileTests {
#expect(!FileManager.default.fileExists(atPath: url.path(percentEncoded: false)))
}
+ @Test func findsOnlyTheCopiesItMade() throws {
+ let directory = try TemporaryDirectory()
+ let made = try directory.file("Peel/refusals-damaged-2026-10-01-090000.json")
+ let again = try directory.file("Peel/refusals-damaged-2026-10-01-090000-2.json")
+ try directory.file("Peel/refusals-damaged-by-hand.json")
+ try directory.file("Peel/removals-damaged-2026-10-01-090000.json")
+ try directory.file("Peel/refusals-damaged-2026-10-01-090000.json.bak")
+ try directory.directory("Peel/refusals-damaged-2026-10-02-090000.json")
+
+ let copies = try #require(DamagedFile.copies(of: directory.url.appending(path: "Peel/refusals.json")))
+
+ #expect(Set(copies.map(\.lastPathComponent)) == [made.lastPathComponent, again.lastPathComponent])
+ #expect(copies.allSatisfy { $0.deletingLastPathComponent().lastPathComponent == "Peel" })
+ #expect(DamagedFile.copies(of: directory.url.appending(path: "Missing/refusals.json")) == [])
+ }
+
+ @Test(.permissionsHold) func saysWhenItCannotLookForCopies() throws {
+ let directory = try TemporaryDirectory()
+ let url = try directory.directory("Peel").appending(path: "refusals.json")
+ try directory.setPermissions(0o300, of: "Peel")
+ defer { try? directory.setPermissions(0o700, of: "Peel") }
+
+ #expect(DamagedFile.copies(of: url) == nil)
+ }
+
@Test func answersNothingForAFileThatIsNotThere() throws {
let directory = try TemporaryDirectory()
#expect(DamagedFile.setAside(directory.url.appending(path: "missing.json")) == nil)
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/HistoryCommandTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/HistoryCommandTests.swift
index 03559a25..21218eae 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/HistoryCommandTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/HistoryCommandTests.swift
@@ -353,6 +353,25 @@ struct HistoryCommandTests {
#expect(FileManager.default.fileExists(atPath: trash.appending(path: "refusals.json").path(percentEncoded: false)))
}
+ @Test func clearsACopySetAsideWhenNothingElseIsLeft() async throws {
+ let directory = try TemporaryDirectory()
+ let logs = logs(in: directory)
+ try directory.file("Peel/refusals-damaged-2026-10-01-090000.json", contents: Data("[".utf8))
+ let trash = try directory.directory("Trash")
+ let service = TrashService(
+ environment: SearchEnvironment(homeDirectory: directory.url, rootDirectory: directory.url)
+ ) { url in
+ let destination = trash.appending(path: url.lastPathComponent)
+ try FileManager.default.moveItem(at: url, to: destination)
+ return destination
+ }
+
+ try await (command(["history", "--refused", "--clear", "--yes"]) as HistoryCommand)
+ .run(in: logs.removals, refusals: logs.refusals, trash: service)
+
+ #expect(try FileManager.default.contentsOfDirectory(atPath: trash.path(percentEncoded: false)) == ["refusals-damaged-2026-10-01-090000.json"])
+ }
+
@Test func movesNothingWhenNothingWasRefused() async throws {
let directory = try TemporaryDirectory()
let logs = logs(in: directory)
@@ -398,6 +417,7 @@ struct HistoryCommandTests {
await #expect(throws: CommandFailure.self) { try await printed(["history", "--refused"], from: logs) }
await #expect(throws: CommandFailure.self) { try await printed(["history", "--refused", "--json"], from: logs) }
+ #expect(RefusalLogProblem.unreadable.summary.contains("`peel history --refused --clear`"))
}
@Test func putsNothingBackWhileTheExclusionsCannotBeRead() async throws {
diff --git a/Packages/PeelCore/Tests/PeelCoreTests/RefusalLogTests.swift b/Packages/PeelCore/Tests/PeelCoreTests/RefusalLogTests.swift
index f600e1e3..14ed93dc 100644
--- a/Packages/PeelCore/Tests/PeelCoreTests/RefusalLogTests.swift
+++ b/Packages/PeelCore/Tests/PeelCoreTests/RefusalLogTests.swift
@@ -157,6 +157,71 @@ struct RefusalLogTests {
)
}
+ @Test func aDamagedRecordIsSaidUntilPeelQuits() async throws {
+ let directory = try TemporaryDirectory()
+ let url = try directory.directory("Peel").appending(path: "refusals.json")
+ try Data("[{\"id\":\"not a uuid\"}]".utf8).write(to: url)
+ let log = RefusalLog(url: url)
+
+ let first = await log.load()
+ let second = await log.load()
+
+ guard case .damaged(let setAside) = first.problem else { Issue.record("no damage reported"); return }
+ #expect(second.problem == .damaged(setAside: setAside), "the copy set aside is the only trace of it")
+ }
+
+ @Test func forgetsTheDamageOnceItsCopyIsGone() async throws {
+ let directory = try TemporaryDirectory()
+ let url = try directory.directory("Peel").appending(path: "refusals.json")
+ try Data("[{\"id\":\"not a uuid\"}]".utf8).write(to: url)
+ let log = RefusalLog(url: url)
+ guard case .damaged(let setAside) = await log.load().problem else { Issue.record("no damage reported"); return }
+
+ try FileManager.default.removeItem(at: setAside)
+
+ #expect(await log.load().problem == nil, "Show in Finder would lead nowhere")
+ }
+
+ @Test(.permissionsHold) func saysARefusalItCouldNotWriteUntilOneIsWritten() async throws {
+ let directory = try TemporaryDirectory()
+ let log = RefusalLog(url: try directory.directory("Peel").appending(path: "refusals.json"))
+ try directory.setPermissions(0o500, of: "Peel")
+ defer { try? directory.setPermissions(0o700, of: "Peel") }
+
+ await log.add([failure("/Users/me/a", .lastCopy)], source: "Editor", tool: "applications")
+ let opened = await log.load()
+ try directory.setPermissions(0o700, of: "Peel")
+ await log.add([failure("/Users/me/b", .lastCopy)], source: "Editor", tool: "applications")
+
+ #expect(opened.problem == .couldNotRecord, "opening History read the old file and cleared it unseen")
+ #expect(await log.load().problem == nil)
+ }
+
+ @Test(.permissionsHold) func startsOverARecordItCannotRead() async throws {
+ let directory = try TemporaryDirectory()
+ let url = try directory.directory("Peel").appending(path: "refusals.json")
+ try Data("[]".utf8).write(to: url)
+ try directory.setPermissions(0, of: url)
+
+ let started = await RefusalLog(url: url).startOver()
+
+ #expect(started.records == [] && started.problem == nil)
+ let kept = try FileManager.default.contentsOfDirectory(atPath: url.deletingLastPathComponent().path())
+ #expect(kept.contains { $0.hasPrefix("refusals-damaged-") }, "the file it could not read was not kept")
+ }
+
+ @Test func clearMovesTheCopiesItSetAsideToo() async throws {
+ let directory = try TemporaryDirectory()
+ let (service, folder) = try trash(in: directory)
+ let url = try directory.directory("Peel").appending(path: "refusals.json")
+ try Data("[]".utf8).write(to: url)
+ try Data("[]".utf8).write(to: url.deletingLastPathComponent().appending(path: "refusals-damaged-2026-10-01-090000.json"))
+
+ #expect(await RefusalLog(url: url).clear(through: service))
+
+ #expect(try FileManager.default.contentsOfDirectory(atPath: folder.path()).count == 2)
+ }
+
/// The file is the only copy of what was refused, so when it cannot be read it is never written over.
@Test(.permissionsHold) func whatCannotBeReadIsKept() async throws {
let directory = try TemporaryDirectory()
diff --git a/Peel/Model/RemovalHistoryStore.swift b/Peel/Model/RemovalHistoryStore.swift
index 2daf1f6b..1753d6e6 100644
--- a/Peel/Model/RemovalHistoryStore.swift
+++ b/Peel/Model/RemovalHistoryStore.swift
@@ -256,8 +256,15 @@ final class RemovalHistoryStore {
await apply(await log.startOver())
}
+ func startOverRefusals() async {
+ await showRefusals(await refusals.startOver())
+ }
+
private func loadRefusals() async {
- let read = await refusals.load()
+ await showRefusals(await refusals.load())
+ }
+
+ private func showRefusals(_ read: (records: [RefusalRecord]?, problem: RefusalLogProblem?)) async {
refusalProblem = read.problem
refusalChange += 1
let change = refusalChange
@@ -312,15 +319,12 @@ final class RemovalHistoryStore {
}
// Refusals are logged whether or not anything moved: a removal where nothing moved is the one most worth a
// record.
- let refusalProblem = await refusals.add(
+ await refusals.add(
result.failures, source: part.source, sourceKey: part.sourceKey, tool: part.tool, batch: removal.refusals
)
if !result.failures.isEmpty {
await loadRefusals()
}
- if let refusalProblem {
- self.refusalProblem = refusalProblem
- }
checkReadability()
}
diff --git a/Peel/Views/History/HistoryList.swift b/Peel/Views/History/HistoryList.swift
index e9ff3ff3..70748317 100644
--- a/Peel/Views/History/HistoryList.swift
+++ b/Peel/Views/History/HistoryList.swift
@@ -153,6 +153,7 @@ private struct HistoryProblemNotice: View {
/// What kept the list under Not Moved from being read or saved.
private struct RefusalProblemNotice: View {
+ @Environment(RemovalHistoryStore.self) private var history
let problem: RefusalLogProblem
var body: some View {
@@ -169,8 +170,12 @@ private struct RefusalProblemNotice: View {
case .unreadable:
Notice(
title: Text("The Not Moved list can’t be read"),
- detail: Text("Peel leaves the file as it is and adds nothing to it, since it is the only record of what stayed.")
- ) { EmptyView() }
+ detail: Text("Until you start the list over, Peel adds nothing to it, since it is the only record of what stayed. Starting over keeps the old file beside a new one.")
+ ) {
+ Button("Start Over") {
+ Task { await history.startOverRefusals() }
+ }
+ }
case .couldNotRecord:
Notice(
title: Text("The Not Moved list couldn’t be saved"),
diff --git a/PeelTests/RemovalHistoryStoreTests.swift b/PeelTests/RemovalHistoryStoreTests.swift
index 34f87b0f..dad53241 100644
--- a/PeelTests/RemovalHistoryStoreTests.swift
+++ b/PeelTests/RemovalHistoryStoreTests.swift
@@ -61,6 +61,51 @@ struct RemovalHistoryStoreTests {
#expect(!history.isKnownEmpty)
}
+ @Test func startsOverANotMovedListItCannotRead() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ defer { try? FileManager.default.removeItem(at: folder) }
+ let refusals = folder.appending(path: "refusals.json")
+ try FileManager.default.createDirectory(at: refusals, withIntermediateDirectories: true)
+ let history = RemovalHistoryStore(
+ log: RemovalLog(url: folder.appending(path: "removals.json")),
+ refusals: RefusalLog(url: refusals),
+ knowsTheExclusions: { true }
+ )
+ await history.load()
+ #expect(history.refusalProblem == .unreadable)
+
+ await history.startOverRefusals()
+
+ #expect(history.refusalProblem == nil)
+ #expect(FileManager.default.fileExists(atPath: refusals.path(percentEncoded: false)) == false)
+ }
+
+ @Test func aRefusalThatCouldNotBeRecordedIsStillSaidWhenHistoryOpens() async throws {
+ let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
+ let path = folder.path(percentEncoded: false)
+ try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+ try FileManager.default.setAttributes([.posixPermissions: 0o500], ofItemAtPath: path)
+ defer {
+ try? FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: path)
+ try? FileManager.default.removeItem(at: folder)
+ }
+ let history = RemovalHistoryStore(
+ log: RemovalLog(url: folder.appending(path: "removals.json")),
+ refusals: RefusalLog(url: folder.appending(path: "refusals.json")),
+ knowsTheExclusions: { true }
+ )
+ let refused = TrashResult(failures: [TrashFailure(url: URL(filePath: "/Users/me/kept"), reason: .lastCopy)])
+ var removal = RemovalInProgress()
+ await history.record(
+ refused, part: RemovalPart(source: "Example", sourceKey: nil, tool: Tool.developer.rawValue), sizes: [:],
+ in: &removal
+ )
+
+ await history.load()
+
+ #expect(history.refusalProblem == .couldNotRecord)
+ }
+
@Test func aReadThatFindsNothingNewChangesNothing() async throws {
let folder = FileManager.default.temporaryDirectory.appending(path: "PeelTests-\(UUID().uuidString)")
defer { try? FileManager.default.removeItem(at: folder) }
diff --git a/SAFETY.md b/SAFETY.md
index 59f7e56f..a67332c4 100644
--- a/SAFETY.md
+++ b/SAFETY.md
@@ -198,7 +198,8 @@ What Peel deletes outright holds nothing of yours: such a placeholder, when the
it makes to save an app's settings before a reset, when saving fails before anything is written in it; the folders it
makes again on the way back for a Put Back, when the item then stays in the Trash and each is still the empty folder it
made; and the empty settings file macOS writes back when Peel forgets a preference domain, as described below. Its list
-of refusals goes to the Trash when `peel history --refused --clear` is asked to forget it, after a question.
+of refusals, with any copy of it set aside because it couldn't be read, goes to the Trash when
+`peel history --refused --clear` is asked to forget it, after a question.
Four things Peel starts can't be undone by History, and Peel says so before you confirm each of them: