UI fixes

tests/clipboredtests/ClipboardStoreTests.swift

@@ -237,10 +237,12 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertEqual(store.items.first?.id, itemID)
     XCTAssertEqual(store.items.first?.payload, "legacy payload")
     XCTAssertEqual(store.items.first?.useCount, 3)
+    XCTAssertEqual(store.items.first?.sourceDeviceName, ClipboardItem.localDeviceName)
 
     let restored = makeStore(settings: settings)
     restored.flushPersistenceForTesting()
     XCTAssertEqual(restored.items.first?.payload, "legacy payload")
+    XCTAssertEqual(restored.items.first?.sourceDeviceName, ClipboardItem.localDeviceName)
   }
 
   func testPinnedItemsSurviveNormalHistoryPrune() {
@@ -266,6 +268,114 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertTrue(restored.items.contains(where: { $0.payload == "pinned-old" && $0.isPinned }))
   }
 
+  func testCollectionItemsSurviveNormalHistoryPrune() {
+    let settings = makeSettings(maxHistory: 50)
+    let store = makeStore(settings: settings)
+    let start = Date()
+    var saved = makeItem("collection-old", displayText: "Saved", created: start.addingTimeInterval(-500))
+    saved.collectionName = "Client Work"
+
+    store.upsert(saved)
+    for index in 0..<60 {
+      store.upsert(makeItem("new-\(index)", displayText: "New \(index)", created: start.addingTimeInterval(Double(index))))
+    }
+    store.flushPersistenceForTesting()
+
+    XCTAssertTrue(store.items.contains(where: { $0.payload == "collection-old" && $0.collectionName == "Client Work" }))
+    XCTAssertEqual(store.items.filter { !$0.isPinned && $0.collectionName == nil }.count, 50)
+    XCTAssertEqual(store.items.count, 51)
+
+    let restored = makeStore(settings: settings)
+    restored.flushPersistenceForTesting()
+    XCTAssertTrue(restored.items.contains(where: { $0.payload == "collection-old" && $0.collectionName == "Client Work" }))
+  }
+
+  func testRemovingCollectionMakesOverflowItemEligibleForHistoryPrune() {
+    let settings = makeSettings(maxHistory: 50)
+    let store = makeStore(settings: settings)
+    let start = Date()
+    var saved = makeItem("collection-old", displayText: "Saved", created: start.addingTimeInterval(-500))
+    saved.collectionName = "Client Work"
+
+    store.upsert(saved)
+    for index in 0..<60 {
+      store.upsert(makeItem("new-\(index)", displayText: "New \(index)", created: start.addingTimeInterval(Double(index))))
+    }
+    let savedID = try! XCTUnwrap(store.items.first(where: { $0.payload == "collection-old" })?.id)
+
+    store.setCollection(savedID, name: nil)
+    store.flushPersistenceForTesting()
+
+    XCTAssertFalse(store.items.contains(where: { $0.payload == "collection-old" }))
+    XCTAssertEqual(store.items.count, 50)
+
+    let restored = makeStore(settings: settings)
+    restored.flushPersistenceForTesting()
+    XCTAssertFalse(restored.items.contains(where: { $0.payload == "collection-old" }))
+  }
+
+  func testHistoryRetentionPrunesExpiredUnpinnedItems() {
+    let settings = makeSettings(maxHistory: 50)
+    settings.historyRetention = .oneDay
+    let store = makeStore(settings: settings)
+    let now = Date()
+
+    store.upsert(makeItem("old", displayText: "Old", created: now.addingTimeInterval(-2 * 24 * 60 * 60)))
+    store.upsert(makeItem("recent", displayText: "Recent", created: now.addingTimeInterval(-60)))
+    store.flushPersistenceForTesting()
+
+    XCTAssertEqual(store.items.map(\.payload), ["recent"])
+    XCTAssertFalse(store.items.contains(where: { $0.payload == "old" }))
+
+    let restored = makeStore(settings: settings)
+    restored.flushPersistenceForTesting()
+    XCTAssertEqual(restored.items.map(\.payload), ["recent"])
+  }
+
+  func testHistoryRetentionKeepsPinnedAndCollectionItems() {
+    let settings = makeSettings(maxHistory: 50)
+    settings.historyRetention = .oneDay
+    let store = makeStore(settings: settings)
+    let oldDate = Date().addingTimeInterval(-2 * 24 * 60 * 60)
+    var pinned = makeItem("pinned-old", displayText: "Pinned", created: oldDate)
+    pinned.isPinned = true
+    var saved = makeItem("collection-old", displayText: "Saved", created: oldDate)
+    saved.collectionName = "Client Work"
+
+    store.upsert(makeItem("plain-old", displayText: "Plain", created: oldDate))
+    store.upsert(pinned)
+    store.upsert(saved)
+    store.flushPersistenceForTesting()
+
+    XCTAssertFalse(store.items.contains(where: { $0.payload == "plain-old" }))
+    XCTAssertTrue(store.items.contains(where: { $0.payload == "pinned-old" && $0.isPinned }))
+    XCTAssertTrue(store.items.contains(where: { $0.payload == "collection-old" && $0.collectionName == "Client Work" }))
+
+    let restored = makeStore(settings: settings)
+    restored.flushPersistenceForTesting()
+    XCTAssertFalse(restored.items.contains(where: { $0.payload == "plain-old" }))
+    XCTAssertTrue(restored.items.contains(where: { $0.payload == "pinned-old" && $0.isPinned }))
+    XCTAssertTrue(restored.items.contains(where: { $0.payload == "collection-old" && $0.collectionName == "Client Work" }))
+  }
+
+  func testDuplicateCopyRefreshesRetentionAge() {
+    let settings = makeSettings(maxHistory: 50)
+    let store = makeStore(settings: settings)
+    let oldDate = Date().addingTimeInterval(-2 * 24 * 60 * 60)
+
+    store.upsert(makeItem("same", displayText: "Original", created: oldDate))
+    let originalCreatedAt = try! XCTUnwrap(store.items.first?.createdAt)
+    store.upsert(makeItem("same", displayText: "Copied again", created: oldDate))
+
+    XCTAssertGreaterThan(try! XCTUnwrap(store.items.first?.createdAt), originalCreatedAt)
+
+    settings.historyRetention = .oneDay
+    store.normalizeHistoryLength()
+
+    XCTAssertEqual(store.items.map(\.payload), ["same"])
+    XCTAssertEqual(store.items.first?.displayText, "Copied again")
+  }
+
   func testStorageFilesUsePrivatePermissions() throws {
     let settings = makeSettings(maxHistory: 50)
     let store = makeStore(settings: settings)
@@ -360,7 +470,8 @@ final class ClipboardStoreTests: XCTestCase {
       isPinned: false,
       sourceAppBundleId: "com.example.secret.\(UUID().uuidString)",
       ocrText: "OCR secret \(UUID().uuidString)",
-      collectionName: "Collection secret \(UUID().uuidString)"
+      collectionName: "Collection secret \(UUID().uuidString)",
+      sourceDeviceName: "Device secret \(UUID().uuidString)"
     )
 
     store.upsert(item)
@@ -375,6 +486,7 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertFalse(rawDatabaseText.contains(item.sourceAppBundleId!))
     XCTAssertFalse(rawDatabaseText.contains(item.ocrText!))
     XCTAssertFalse(rawDatabaseText.contains(item.collectionName!))
+    XCTAssertFalse(rawDatabaseText.contains(item.sourceDeviceName!))
 
     let restored = makeStore(settings: settings, encryptionService: encryptionService)
     restored.flushPersistenceForTesting()
@@ -386,6 +498,7 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertEqual(restored.items.first?.sourceAppBundleId, item.sourceAppBundleId)
     XCTAssertEqual(restored.items.first?.ocrText, item.ocrText)
     XCTAssertEqual(restored.items.first?.collectionName, item.collectionName)
+    XCTAssertEqual(restored.items.first?.sourceDeviceName, item.sourceDeviceName)
   }
 
   func testPlaintextDatabaseMigratesToEncryptedFieldsOnLoad() throws {
@@ -406,7 +519,8 @@ final class ClipboardStoreTests: XCTestCase {
       isPinned: false,
       sourceAppBundleId: "com.example.legacy.\(UUID().uuidString)",
       ocrText: "Legacy OCR \(UUID().uuidString)",
-      collectionName: "Legacy collection \(UUID().uuidString)"
+      collectionName: "Legacy collection \(UUID().uuidString)",
+      sourceDeviceName: "Legacy device \(UUID().uuidString)"
     )
 
     plaintextStore.upsert(item)
@@ -424,6 +538,7 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertEqual(restored.items.first?.sourceAppBundleId, item.sourceAppBundleId)
     XCTAssertEqual(restored.items.first?.ocrText, item.ocrText)
     XCTAssertEqual(restored.items.first?.collectionName, item.collectionName)
+    XCTAssertEqual(restored.items.first?.sourceDeviceName, item.sourceDeviceName)
 
     let migratedDatabaseText = try databaseText()
     XCTAssertTrue(migratedDatabaseText.contains(ClipboardEncryptionService.marker))
@@ -434,6 +549,7 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertFalse(migratedDatabaseText.contains(item.sourceAppBundleId!))
     XCTAssertFalse(migratedDatabaseText.contains(item.ocrText!))
     XCTAssertFalse(migratedDatabaseText.contains(item.collectionName!))
+    XCTAssertFalse(migratedDatabaseText.contains(item.sourceDeviceName!))
   }
 
   func testDuplicatePDFReplacementRemovesOldAttachment() throws {
@@ -454,6 +570,47 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertTrue(FileManager.default.fileExists(atPath: newPath))
   }
 
+  func testRemoveCanDeferManagedCachePurgeForUndoRestore() throws {
+    let settings = makeSettings(maxHistory: 50)
+    let store = makeStore(settings: settings)
+    let cachedImage = try XCTUnwrap(cacheService.cacheImage(makeImage(color: .systemBlue), id: UUID()))
+    let item = makeImageItem(
+      fullPath: cachedImage.full,
+      thumbPath: cachedImage.thumb,
+      hash: "undo-image",
+      ocrText: "undo searchable text",
+      created: Date(timeIntervalSince1970: 10)
+    )
+    store.upsert(item)
+    store.flushPersistenceForTesting()
+
+    let removal = try XCTUnwrap(store.remove(item.id, purgeManagedCache: false))
+    store.flushPersistenceForTesting()
+    cacheService.flushForTesting()
+
+    XCTAssertTrue(store.items.isEmpty)
+    XCTAssertTrue(FileManager.default.fileExists(atPath: cachedImage.full))
+    XCTAssertTrue(FileManager.default.fileExists(atPath: cachedImage.thumb))
+
+    store.restore([removal])
+    store.flushPersistenceForTesting()
+
+    XCTAssertEqual(store.items.map(\.id), [item.id])
+    XCTAssertTrue(FileManager.default.fileExists(atPath: cachedImage.full))
+    XCTAssertTrue(FileManager.default.fileExists(atPath: cachedImage.thumb))
+
+    let restored = makeStore(settings: settings)
+    restored.flushPersistenceForTesting()
+    XCTAssertEqual(restored.items.map(\.id), [item.id])
+
+    _ = store.remove(item.id)
+    store.flushPersistenceForTesting()
+    cacheService.flushForTesting()
+
+    XCTAssertFalse(FileManager.default.fileExists(atPath: cachedImage.full))
+    XCTAssertFalse(FileManager.default.fileExists(atPath: cachedImage.thumb))
+  }
+
   func testDuplicateReplacementClearsStaleImageSearchMetadata() throws {
     let settings = makeSettings(maxHistory: 50)
     settings.keepFirstImage = false
@@ -501,9 +658,204 @@ final class ClipboardStoreTests: XCTestCase {
     XCTAssertFalse(FileManager.default.fileExists(atPath: staleImage.thumb))
   }
 
+  func testArchiveExportImportMovesHistoryAndManagedAttachmentsToNewStorage() throws {
+    let settings = makeSettings(maxHistory: 50)
+    let store = makeStore(settings: settings)
+    let cachedImage = try XCTUnwrap(cacheService.cacheImage(makeImage(color: .systemBlue), id: UUID()))
+    let sourceFullImageData = try XCTUnwrap(cacheService.data(for: cachedImage.full))
+    let sourceThumbData = try XCTUnwrap(cacheService.data(for: cachedImage.thumb))
+    let sourcePDFData = Data("%PDF archive payload".utf8)
+    let sourcePDFPath = try XCTUnwrap(cacheService.cachePDF(sourcePDFData, id: UUID()))
+    let created = Date(timeIntervalSince1970: 300)
+
+    var note = makeItem("archive note", displayText: "Archive Note", created: created)
+    note.collectionName = "Read Later"
+    note.customTitle = "Migration Note"
+    note.sourceDeviceName = "Studio Mac"
+    var image = makeImageItem(
+      fullPath: cachedImage.full,
+      thumbPath: cachedImage.thumb,
+      hash: "archive-image",
+      ocrText: "blue archive image",
+      created: created.addingTimeInterval(1)
+    )
+    image.isPinned = true
+    image.collectionName = "Client Work"
+    image.customTitle = "Launch Screenshot"
+    image.sourceDeviceName = "MacBook Pro"
+    var pdf = makePDFItem(
+      path: sourcePDFPath,
+      hash: "archive-pdf",
+      created: created.addingTimeInterval(2)
+    )
+    pdf.collectionName = "Research"
+    pdf.sourceDeviceName = "Design Mac"
+
+    store.upsert(note)
+    store.upsert(image)
+    store.upsert(pdf)
+    store.flushPersistenceForTesting()
+
+    let archiveURL = baseURL.appendingPathComponent("backup.clipboredarchive")
+    let exportSummary = try store.exportArchive(to: archiveURL)
+
+    XCTAssertEqual(exportSummary.itemCount, 3)
+    XCTAssertEqual(exportSummary.sidecarCount, 3)
+    XCTAssertEqual(try posixPermissions(archiveURL), 0o600)
+
+    let destinationBaseURL = FileManager.default.temporaryDirectory
+      .appendingPathComponent("clipboredtests", isDirectory: true)
+      .appendingPathComponent(UUID().uuidString, isDirectory: true)
+    try FileManager.default.createDirectory(at: destinationBaseURL, withIntermediateDirectories: true)
+    defer { try? FileManager.default.removeItem(at: destinationBaseURL) }
+
+    let destinationDefaultsSuite = "com.clipbored.archiveimport.\(UUID().uuidString)"
+    let destinationDefaults = try XCTUnwrap(UserDefaults(suiteName: destinationDefaultsSuite))
+    destinationDefaults.removePersistentDomain(forName: destinationDefaultsSuite)
+    defer { destinationDefaults.removePersistentDomain(forName: destinationDefaultsSuite) }
+
+    let destinationSettings = SettingsModel(defaults: destinationDefaults)
+    destinationSettings.maxHistoryItems = 50
+    destinationSettings.historyRetention = .forever
+    let destinationCache = ClipboardCacheService(
+      baseURL: destinationBaseURL,
+      encryptionService: noOpEncryptionService()
+    )
+    let destinationStore = ClipboardStore(
+      settings: destinationSettings,
+      cacheService: destinationCache,
+      baseURL: destinationBaseURL,
+      encryptionService: noOpEncryptionService()
+    )
+    destinationStore.upsert(makeItem("destination only", displayText: "Destination", created: created.addingTimeInterval(3)))
+    destinationStore.flushPersistenceForTesting()
+
+    let importSummary = try destinationStore.importArchive(from: archiveURL)
+    destinationStore.flushPersistenceForTesting()
+
+    XCTAssertEqual(importSummary.itemCount, 3)
+    XCTAssertEqual(importSummary.sidecarCount, 3)
+    XCTAssertEqual(destinationStore.items.count, 4)
+    XCTAssertTrue(destinationStore.items.contains { $0.payload == "destination only" })
+
+    let importedNote = try XCTUnwrap(destinationStore.items.first { $0.id == note.id })
+    XCTAssertEqual(importedNote.collectionName, "Read Later")
+    XCTAssertEqual(importedNote.customTitle, "Migration Note")
+    XCTAssertEqual(importedNote.sourceDeviceName, "Studio Mac")
+
+    let importedImage = try XCTUnwrap(destinationStore.items.first { $0.id == image.id })
+    XCTAssertTrue(importedImage.isPinned)
+    XCTAssertEqual(importedImage.collectionName, "Client Work")
+    XCTAssertEqual(importedImage.customTitle, "Launch Screenshot")
+    XCTAssertEqual(importedImage.sourceDeviceName, "MacBook Pro")
+    let importedImagePath = try XCTUnwrap(importedImage.imagePath)
+    let importedThumbPath = try XCTUnwrap(importedImage.thumbnailPath)
+    XCTAssertTrue(importedImagePath.hasPrefix(destinationBaseURL.path))
+    XCTAssertTrue(importedThumbPath.hasPrefix(destinationBaseURL.path))
+    XCTAssertNotEqual(importedImagePath, cachedImage.full)
+    XCTAssertEqual(destinationCache.data(for: importedImagePath), sourceFullImageData)
+    XCTAssertEqual(destinationCache.data(for: importedThumbPath), sourceThumbData)
+
+    let importedPDF = try XCTUnwrap(destinationStore.items.first { $0.id == pdf.id })
+    XCTAssertEqual(importedPDF.collectionName, "Research")
+    XCTAssertTrue(importedPDF.payload.hasPrefix(destinationBaseURL.path))
+    XCTAssertNotEqual(importedPDF.payload, sourcePDFPath)
+    XCTAssertEqual(destinationCache.data(for: importedPDF.payload), sourcePDFData)
+
+    let reloaded = ClipboardStore(
+      settings: destinationSettings,
+      cacheService: destinationCache,
+      baseURL: destinationBaseURL,
+      encryptionService: noOpEncryptionService()
+    )
+    reloaded.flushPersistenceForTesting()
+    XCTAssertEqual(reloaded.items.count, 4)
+    XCTAssertTrue(reloaded.items.contains { $0.id == image.id && $0.collectionName == "Client Work" })
+    XCTAssertTrue(reloaded.items.contains { $0.id == pdf.id && $0.collectionName == "Research" })
+  }
+
+  func testPinboardExportImportsOnlyThatCollectionAndPreservesColor() throws {
+    let settings = makeSettings(maxHistory: 50)
+    settings.ensureCollection(named: "Client Work", colorHex: "#3366FF")
+    let store = makeStore(settings: settings)
+    let created = Date(timeIntervalSince1970: 500)
+    var client = makeItem("client note", displayText: "Client Note", created: created)
+    client.collectionName = "Client Work"
+    let unrelated = makeItem("other note", displayText: "Other Note", created: created.addingTimeInterval(1))
+
+    store.upsert(client)
+    store.upsert(unrelated)
+    store.flushPersistenceForTesting()
+
+    let archiveURL = baseURL.appendingPathComponent("client-work.clipboredarchive")
+    let exportSummary = try store.exportCollection(named: "Client Work", to: archiveURL)
+
+    XCTAssertEqual(exportSummary.itemCount, 1)
+    XCTAssertEqual(exportSummary.sidecarCount, 0)
+
+    let destinationDefaultsSuite = "com.clipbored.pinboardimport.\(UUID().uuidString)"
+    let destinationDefaults = try XCTUnwrap(UserDefaults(suiteName: destinationDefaultsSuite))
+    destinationDefaults.removePersistentDomain(forName: destinationDefaultsSuite)
+    defer { destinationDefaults.removePersistentDomain(forName: destinationDefaultsSuite) }
+    let destinationSettings = SettingsModel(defaults: destinationDefaults)
+    destinationSettings.maxHistoryItems = 50
+    destinationSettings.historyRetention = .forever
+    let destinationBaseURL = baseURL.appendingPathComponent("pinboard-destination", isDirectory: true)
+    let destinationCache = ClipboardCacheService(
+      baseURL: destinationBaseURL,
+      encryptionService: noOpEncryptionService()
+    )
+    let destinationStore = ClipboardStore(
+      settings: destinationSettings,
+      cacheService: destinationCache,
+      baseURL: destinationBaseURL,
+      encryptionService: noOpEncryptionService()
+    )
+
+    let importSummary = try destinationStore.importArchive(from: archiveURL)
+
+    XCTAssertEqual(importSummary.itemCount, 1)
+    XCTAssertEqual(destinationStore.items.map(\.payload), ["client note"])
+    XCTAssertEqual(destinationStore.items.first?.collectionName, "Client Work")
+    XCTAssertEqual(destinationSettings.customCollectionNames, ["Client Work"])
+    XCTAssertEqual(destinationSettings.collectionColorHex(forCollectionNamed: "Client Work"), "#3366FF")
+  }
+
+  func testEmptyPinboardExportImportsCollectionMetadata() throws {
+    let settings = makeSettings(maxHistory: 50)
+    settings.ensureCollection(named: "Read Later", colorHex: "#0A9EB8")
+    let store = makeStore(settings: settings)
+    let archiveURL = baseURL.appendingPathComponent("read-later-empty.clipboredarchive")
+
+    let exportSummary = try store.exportCollection(named: "Read Later", to: archiveURL)
+
+    XCTAssertEqual(exportSummary.itemCount, 0)
+
+    let destinationDefaultsSuite = "com.clipbored.emptypinboard.\(UUID().uuidString)"
+    let destinationDefaults = try XCTUnwrap(UserDefaults(suiteName: destinationDefaultsSuite))
+    destinationDefaults.removePersistentDomain(forName: destinationDefaultsSuite)
+    defer { destinationDefaults.removePersistentDomain(forName: destinationDefaultsSuite) }
+    let destinationSettings = SettingsModel(defaults: destinationDefaults)
+    let destinationBaseURL = baseURL.appendingPathComponent("empty-pinboard-destination", isDirectory: true)
+    let destinationStore = ClipboardStore(
+      settings: destinationSettings,
+      cacheService: ClipboardCacheService(baseURL: destinationBaseURL, encryptionService: noOpEncryptionService()),
+      baseURL: destinationBaseURL,
+      encryptionService: noOpEncryptionService()
+    )
+
+    let importSummary = try destinationStore.importArchive(from: archiveURL)
+
+    XCTAssertEqual(importSummary.itemCount, 0)
+    XCTAssertTrue(destinationStore.items.isEmpty)
+    XCTAssertEqual(destinationSettings.customCollectionNames, ["Read Later"])
+    XCTAssertEqual(destinationSettings.collectionColorHex(forCollectionNamed: "Read Later"), "#0A9EB8")
+  }
+
   private func makeSettings(maxHistory: Int) -> SettingsModel {
     let settings = SettingsModel(defaults: defaults)
     settings.maxHistoryItems = maxHistory
+    settings.historyRetention = .forever
     settings.pruneDuplicates = true
     settings.keepFirstImage = true
     return settings