Add sync control and portable image paths

Ensure login release workflow has contents write, add sync button/animation, startup toggle, and store local images by filename for portability.

Author: CSL

.github/workflows/build.yml

@@ -11,6 +11,9 @@ on:
         required: true
         default: 'dev'
 
+permissions:
+  contents: write
+
 jobs:
   build:
     runs-on: macos-14

IMPLEMENTATION_PLAN.md

@@ -0,0 +1,48 @@
+## Stage 1: Understand current preview and toolbar flows
+**Goal**: Locate bookmark web preview toolbar, OGP preview rendering, and image storage helpers.
+**Success Criteria**: Know where to add a snapshot control and how preview images are stored/loaded.
+**Tests**: None (discovery only).
+**Status**: Complete
+
+## Stage 2: Snapshot capture & persistence
+**Goal**: Add a toolbar snapshot mode that lets users drag a rectangle over the web view and save a captured image locally.
+**Success Criteria**: Snapshot button toggles selection UI; Save writes PNG to storage and updates bookmark metadata image path; cancels cleanly.
+**Tests**: Manual: open bookmark detail → capture snapshot → preview shows saved image.
+**Status**: Complete
+
+## Stage 3: Preview area UX improvements
+**Goal**: Always render preview area in sidebar, allow external image drop, and support local paths in cards.
+**Success Criteria**: Sidebar preview shows placeholder when empty, accepts drag/drop to set preview; cards render local preview paths.
+**Tests**: Manual: drag external image into preview area → card shows image; fallback placeholder visible when empty.
+**Status**: Complete
+
+## Stage 4: Startup setting discovery
+**Goal**: Understand current settings architecture and how preferences are stored to add an auto-launch toggle.
+**Success Criteria**: Identify where to place UI and which persistence/manager pattern to follow for startup behavior.
+**Tests**: None (discovery only).
+**Status**: Complete
+
+## Stage 5: Login item manager
+**Goal**: Implement a manager that enables/disables Seahorse at login using ServiceManagement and keeps the preference persisted.
+**Success Criteria**: Toggling the setting registers/unregisters the app as a login item without errors; preference is stored.
+**Tests**: Manual: toggle on/off and observe no errors in logs.
+**Status**: Complete
+
+## Stage 6: UI and localization
+**Goal**: Expose the startup toggle in Basic Settings with localized copy and accessibility labels.
+**Success Criteria**: Toggle appears in settings, uses localized strings, and updates state reactively.
+**Tests**: Manual: open Settings → Basic → toggle is visible and updates.
+**Status**: Complete
+
+## Stage 7: Validation
+**Goal**: Verify startup behavior and document manual test steps.
+**Success Criteria**: Manual check shows Seahorse can be set to launch at login and disabled again; plan file updated.
+**Tests**: Manual: enable auto-start, restart login session (simulated), then disable and confirm removal.
+**Status**: Not Started
+
+## Stage 8: Image path portability
+**Goal**: Store only filenames for local images and resolve paths using the current storage directory to avoid breakage after migrations.
+**Success Criteria**: Saved image paths omit absolute directories; UI renders local images via resolved paths; existing remote URLs unaffected.
+**Tests**: Manual: add image and snapshot, move storage folder, reopen and confirm images load.
+**Status**: In Progress
+

Seahorse/ContentView.swift

@@ -25,6 +25,9 @@ struct ContentView: View {
     @StateObject private var sortPreferenceManager = SortPreferenceManager.shared
     @StateObject private var pasteHandler: PasteHandler
     @FocusState private var isSearchFocused: Bool
+    @State private var isSyncing = false
+    @State private var syncRotation: Double = 0
+    @State private var syncStartTime: Date?
 
     @State private var windowDelegate = MainWindowDelegate()
 
@@ -85,37 +88,53 @@ struct ContentView: View {
         if !searchQuery.isEmpty {
             let queryLower = searchQuery.lowercased()
             items = items.filter { item in
-                let tagIds: [UUID] = item.asBookmark?.tagIds ??
-                    item.asImageItem?.tagIds ??
-                    item.asTextItem?.tagIds ??
-                    []
-                
-                let tagMatch = dataStorage.tags.contains { tag in
-                    tagIds.contains(tag.id) && tag.name.lowercased().contains(queryLower)
-                }
-                
-                if let bookmark = item.asBookmark {
-                    return bookmark.title.lowercased().contains(queryLower) ||
-                           bookmark.url.lowercased().contains(queryLower) ||
-                           (bookmark.notes?.lowercased().contains(queryLower) ?? false) ||
-                           tagMatch
-                } else if let imageItem = item.asImageItem {
-                    return imageItem.imagePath.lowercased().contains(queryLower) ||
-                           (imageItem.notes?.lowercased().contains(queryLower) ?? false) ||
-                           tagMatch
-                } else if let textItem = item.asTextItem {
-                    return textItem.content.lowercased().contains(queryLower) ||
-                           (textItem.notes?.lowercased().contains(queryLower) ?? false) ||
-                           tagMatch
-                }
-                return false
+                let searchable = searchableStrings(for: item)
+                return searchable.contains { $0.contains(queryLower) }
             }
         }
 
         // Apply sorting to all items uniformly
         return sortPreferenceManager.sortOption.sort(items)
     }
 
+    private func tagNames(for item: AnyCollectionItem) -> [String] {
+        let tagIds: [UUID] = item.asBookmark?.tagIds ??
+            item.asImageItem?.tagIds ??
+            item.asTextItem?.tagIds ??
+            []
+        
+        guard !tagIds.isEmpty else { return [] }
+        
+        return dataStorage.tags
+            .filter { tagIds.contains($0.id) }
+            .map { $0.name.lowercased() }
+    }
+    
+    private func searchableStrings(for item: AnyCollectionItem) -> [String] {
+        var fields: [String] = []
+        
+        if let bookmark = item.asBookmark {
+            fields.append(bookmark.title.lowercased())
+            fields.append(bookmark.url.lowercased())
+            if let notes = bookmark.notes {
+                fields.append(notes.lowercased())
+            }
+        } else if let imageItem = item.asImageItem {
+            fields.append(imageItem.imagePath.lowercased())
+            if let notes = imageItem.notes {
+                fields.append(notes.lowercased())
+            }
+        } else if let textItem = item.asTextItem {
+            fields.append(textItem.content.lowercased())
+            if let notes = textItem.notes {
+                fields.append(notes.lowercased())
+            }
+        }
+        
+        fields.append(contentsOf: tagNames(for: item))
+        return fields
+    }
+    
     var body: some View {
         NavigationSplitView {
             SidebarView(
@@ -176,6 +195,22 @@ struct ContentView: View {
                     .padding(.vertical, 5)
                     .background(Color(NSColor.controlBackgroundColor))
                     .cornerRadius(6)
+                    
+                    // Sync button
+                    Button(action: performManualSync) {
+                        Image(systemName: "arrow.triangle.2.circlepath")
+                            .rotationEffect(.degrees(syncRotation))
+                            .animation(isSyncing
+                                       ? .linear(duration: 1.0).repeatForever(autoreverses: false)
+                                       : .default,
+                                       value: isSyncing)
+                            .padding(.horizontal, 10)
+                            .padding(.vertical, 6)
+                            .background(Color(NSColor.controlBackgroundColor))
+                            .cornerRadius(6)
+                    }
+                    .buttonStyle(.borderless)
+                    .help("Sync")
                 }
 
                 ToolbarItemGroup(placement: .automatic) {
@@ -351,6 +386,12 @@ struct ContentView: View {
         .onReceive(NotificationCenter.default.publisher(for: NSNotification.Name("ShowAddText"))) { _ in
             showingAddText = true
         }
+        .onReceive(NotificationCenter.default.publisher(for: .autoSyncStarted)) { _ in
+            startSyncAnimation()
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .autoSyncEnded)) { _ in
+            stopSyncAnimation()
+        }
         .onPasteCommand(of: [.url, .image, .plainText]) { providers in
             pasteHandler.handlePaste(providers: providers)
         }
@@ -375,6 +416,46 @@ struct ContentView: View {
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
     }
+    
+    private func performManualSync() {
+        guard !isSyncing else { return }
+        startSyncAnimation()
+        
+        Task { @MainActor in
+            // Force save triggers autoSync notifications; we handle animation stop with minimum duration.
+            DataStorage.shared.forceSaveAllData()
+            stopSyncAnimation()
+        }
+    }
+    
+    private func startSyncAnimation() {
+        guard !isSyncing else { return }
+        isSyncing = true
+        syncRotation = 0
+        syncStartTime = Date()
+        syncRotation += 360
+    }
+    
+    private func stopSyncAnimation() {
+        guard let start = syncStartTime else {
+            isSyncing = false
+            syncRotation = 0
+            return
+        }
+        let elapsed = Date().timeIntervalSince(start)
+        let minimumDuration: TimeInterval = 1.0
+        if elapsed >= minimumDuration {
+            isSyncing = false
+            syncRotation = 0
+        } else {
+            let remaining = minimumDuration - elapsed
+            Task { @MainActor in
+                try? await Task.sleep(nanoseconds: UInt64(remaining * 1_000_000_000))
+                isSyncing = false
+                syncRotation = 0
+            }
+        }
+    }
 }
 
 #Preview {

Seahorse/Database/JSONStorage.swift

@@ -118,7 +118,9 @@ class JSONStorage: DatabaseProtocol {
                 Log.info("  ✅ Read \(data.count) bytes from items file", category: .database)
 
                 let loaded = try JSONDecoder().decode([AnyCollectionItem].self, from: data)
-                items = loaded
+                items = loaded.map { normalizeItemPaths($0) }
+                // Persist normalized paths so future reads stay portable
+                saveItemsToDisk()
                 Log.info("  ✓ Loaded \(items.count) items", category: .database)
             } catch {
                 Log.error("  ❌ Failed to load items: \(error)", category: .database)
@@ -189,7 +191,8 @@ class JSONStorage: DatabaseProtocol {
         queue.async(flags: .barrier) {
             let encoder = JSONEncoder()
             encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
-            if let data = try? encoder.encode(self.items) {
+            let normalized = self.items.map { self.normalizeItemPaths($0) }
+            if let data = try? encoder.encode(normalized) {
                 try? data.write(to: self.itemsURL)
             }
         }
@@ -225,6 +228,49 @@ class JSONStorage: DatabaseProtocol {
         }
     }
 
+    // MARK: - Path Normalization
+    
+    /// Ensure image-related paths are portable (filenames only) while leaving remote URLs untouched.
+    private func normalizeItemPaths(_ item: AnyCollectionItem) -> AnyCollectionItem {
+        func normalizePath(_ path: String?) -> String? {
+            guard let path = path, !path.isEmpty else { return path }
+            // Keep remote URLs as-is
+            if let url = URL(string: path),
+               let scheme = url.scheme,
+               (scheme == "http" || scheme == "https") {
+                return path
+            }
+            let resolved = StorageManager.shared.resolveImagePath(path)
+            return StorageManager.shared.relativeImageFilename(from: resolved)
+        }
+        
+        switch item.itemType {
+        case .bookmark:
+            if var bookmark = item.asBookmark {
+                if var metadata = bookmark.metadata {
+                    metadata.imageURL = normalizePath(metadata.imageURL)
+                    bookmark.metadata = metadata
+                }
+                return AnyCollectionItem(bookmark)
+            }
+        case .image:
+            if var imageItem = item.asImageItem {
+                if let normalized = normalizePath(imageItem.imagePath) {
+                    imageItem.imagePath = normalized
+                }
+                if let thumb = imageItem.thumbnailPath,
+                   let normalizedThumb = normalizePath(thumb) {
+                    imageItem.thumbnailPath = normalizedThumb
+                }
+                return AnyCollectionItem(imageItem)
+            }
+        case .text:
+            return item
+        }
+        
+        return item
+    }
+    
     // MARK: - Bookmark Operations
 
     func saveBookmark(_ bookmark: Bookmark) throws {
@@ -295,7 +341,7 @@ class JSONStorage: DatabaseProtocol {
             guard !items.contains(where: { $0.id == item.id }) else {
                 throw DatabaseError.duplicateEntry
             }
-            items.append(item)
+            items.append(normalizeItemPaths(item))
         }
         saveItemsToDisk()
     }
@@ -305,7 +351,7 @@ class JSONStorage: DatabaseProtocol {
             guard let index = items.firstIndex(where: { $0.id == item.id }) else {
                 throw DatabaseError.notFound
             }
-            items[index] = item
+            items[index] = normalizeItemPaths(item)
         }
         saveItemsToDisk()
     }