Add main-app entry editing UI

Author: crazytan

CHANGELOG.md

@@ -9,6 +9,9 @@
 
 ## Unreleased
 
+### New Features
+- Add main-app entry editing with create, edit, delete, password generation, save-conflict resolution, and read-only editing safeguards
+
 ### Fixes
 - Remove the baked white background from the Dropbox provider glyph so it renders cleanly in dark mode
 - Show provider-specific cloud sync status during unlock, and add focused unlock coverage for cloud sync success, fallback, and failure paths

KeeForge.xcodeproj/project.pbxproj

@@ -1,4 +1,6 @@
+import AuthenticationServices
 import SwiftUI
+import UIKit
 
 @main
 struct KeeForgeApp: App {
@@ -24,7 +26,7 @@ struct KeeForgeApp: App {
                     break
                 case .background:
                     screenProtectionService.showShield()
-                    activeDatabaseViewModel?.lock()
+                    activeDatabaseViewModel?.lockRequest()
                 @unknown default:
                     screenProtectionService.showShield()
                 }
@@ -236,12 +238,14 @@ private struct LaunchRoutingView: View {
 
 struct DatabaseNavigationView: View {
     @Bindable var viewModel: DatabaseViewModel
+    @State private var presentedSaveError: DatabaseSaveError?
+    @State private var isDropboxReconnectInFlight = false
 
     var body: some View {
         NavigationStack(path: $viewModel.navigationPath) {
             Group {
-                if let root = viewModel.rootGroup {
-                    GroupListView(group: root, viewModel: viewModel)
+                if let root = viewModel.currentRootGroup {
+                    GroupListView(groupID: root.id, viewModel: viewModel)
                 } else {
                     ContentUnavailableView(
                         "Vault Not Loaded",
@@ -251,22 +255,205 @@ struct DatabaseNavigationView: View {
                 }
             }
             .navigationDestination(for: KPGroup.self) { group in
-                GroupListView(group: group, viewModel: viewModel)
+                GroupListView(groupID: group.id, viewModel: viewModel)
             }
             .navigationDestination(for: KPEntry.self) { entry in
-                EntryDetailView(entry: entry, sessionKey: viewModel.sessionKey!)
+                EntryDetailView(entryID: entry.id, viewModel: viewModel)
+            }
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    DatabaseSaveToolbarButton(viewModel: viewModel)
+                }
             }
             .safeAreaInset(edge: .top, spacing: 0) {
-                if let bannerText = viewModel.cloudSyncBannerText {
-                    Label(bannerText, systemImage: "icloud")
-                        .font(.caption.weight(.medium))
-                        .foregroundStyle(.orange)
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                        .padding(.horizontal, 16)
-                        .padding(.vertical, 10)
-                        .background(Color.orange.opacity(0.12))
+                VStack(spacing: 8) {
+                    if let bannerText = viewModel.cloudSyncBannerText {
+                        BannerLabel(
+                            text: bannerText,
+                            systemImage: "icloud",
+                            foregroundStyle: .orange,
+                            backgroundColor: Color.orange.opacity(0.12)
+                        )
+                    }
+
+                    if viewModel.saveError?.isWriteScopeRequired == true {
+                        CloudReauthBanner(
+                            isReconnectInFlight: isDropboxReconnectInFlight,
+                            onReconnect: beginDropboxReconnect
+                        )
+                    }
+
+                    if viewModel.isDirty {
+                        UnsavedChangesBanner()
+                    }
+
+                    if viewModel.isReadOnly {
+                        ReadOnlyRibbon()
+                    }
                 }
             }
         }
+        .saveConflictAlert(viewModel: viewModel)
+        .onChange(of: viewModel.saveError) { _, newValue in
+            if let newValue {
+                presentedSaveError = newValue
+            }
+        }
+        .alert(item: $presentedSaveError) { error in
+            Alert(
+                title: Text("Couldn't Save Database"),
+                message: Text(error.localizedDescription),
+                dismissButton: .default(Text("OK"))
+            )
+        }
+        .alert(
+            "Lock and discard unsaved changes?",
+            isPresented: Binding(
+                get: { viewModel.pendingLockRequest != nil },
+                set: { isPresented in
+                    if isPresented == false {
+                        viewModel.cancelLockRequest()
+                    }
+                }
+            )
+        ) {
+            Button("Lock and Discard", role: .destructive) {
+                let manuallyTriggered = viewModel.pendingLockRequest?.manuallyTriggered ?? false
+                viewModel.lockRequest(force: true, manuallyTriggered: manuallyTriggered)
+            }
+            Button("Keep Editing", role: .cancel) {
+                viewModel.cancelLockRequest()
+            }
+        } message: {
+            Text("Your unsaved entry changes will be lost.")
+        }
+    }
+
+    @MainActor
+    private func beginDropboxReconnect() {
+        guard isDropboxReconnectInFlight == false else { return }
+        guard let provider = CloudProviderRegistry.provider(for: CloudProviderKind.dropbox.rawValue) else {
+            viewModel.presentSaveError(CloudProviderError.invalidConfiguration)
+            return
+        }
+
+        isDropboxReconnectInFlight = true
+        Task { @MainActor in
+            defer { isDropboxReconnectInFlight = false }
+
+            do {
+                _ = try await provider.authenticate(from: presentationAnchor())
+                viewModel.clearSaveError()
+            } catch let error as CloudProviderError where error == .authenticationCancelled {
+                return
+            } catch {
+                viewModel.presentSaveError(error)
+            }
+        }
+    }
+
+    @MainActor
+    private func presentationAnchor() -> ASPresentationAnchor {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        if let window = scenes.flatMap(\.windows).first(where: \.isKeyWindow) {
+            return window
+        }
+        return ASPresentationAnchor()
+    }
+}
+
+private struct DatabaseSaveToolbarButton: View {
+    @Bindable var viewModel: DatabaseViewModel
+
+    var body: some View {
+        Button {
+            Task {
+                await viewModel.saveHandlingError()
+            }
+        } label: {
+            if viewModel.isSaving {
+                ProgressView()
+                    .controlSize(.small)
+                    .frame(width: 24, height: 24)
+            } else {
+                Image(systemName: "square.and.arrow.down")
+            }
+        }
+        .disabled(viewModel.isDirty == false || viewModel.isSaving)
+        .accessibilityIdentifier("database.save")
+    }
+}
+
+private struct ReadOnlyRibbon: View {
+    var body: some View {
+        Text("Read-only mode — toggle in the database list to enable editing.")
+            .font(.caption.weight(.medium))
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.horizontal, 16)
+            .padding(.vertical, 8)
+            .background(Color.yellow.opacity(0.18))
+            .accessibilityIdentifier("database.read-only-ribbon")
+    }
+}
+
+private struct UnsavedChangesBanner: View {
+    var body: some View {
+        HStack(spacing: 8) {
+            Circle()
+                .fill(Color.orange)
+                .frame(width: 8, height: 8)
+            Text("Unsaved changes")
+                .font(.caption.weight(.medium))
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(.horizontal, 16)
+        .padding(.vertical, 8)
+        .background(Color.orange.opacity(0.12))
+        .accessibilityIdentifier("database.unsaved-indicator")
+    }
+}
+
+private struct CloudReauthBanner: View {
+    let isReconnectInFlight: Bool
+    let onReconnect: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text("Reconnect Dropbox to save changes.")
+                .font(.subheadline.weight(.semibold))
+            Button("Reconnect Dropbox", action: onReconnect)
+                .buttonStyle(.borderedProminent)
+                .disabled(isReconnectInFlight)
+                .accessibilityIdentifier("cloud-reauth-banner.reconnect")
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(16)
+        .background(
+            RoundedRectangle(cornerRadius: 16, style: .continuous)
+                .fill(Color(.secondarySystemBackground))
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: 16, style: .continuous)
+                .stroke(Color(.separator), lineWidth: 0.5)
+        )
+        .padding(.horizontal, 12)
+        .accessibilityIdentifier("cloud-reauth-banner")
+    }
+}
+
+private struct BannerLabel: View {
+    let text: String
+    let systemImage: String
+    let foregroundStyle: Color
+    let backgroundColor: Color
+
+    var body: some View {
+        Label(text, systemImage: systemImage)
+            .font(.caption.weight(.medium))
+            .foregroundStyle(foregroundStyle)
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.horizontal, 16)
+            .padding(.vertical, 10)
+            .background(backgroundColor)
     }
 }

KeeForge/App/KeeForgeApp.swift

@@ -17,6 +17,7 @@ Use this folder as the main map for the app target. The subfolder READMEs hold t
 - Database list flow: `App/KeeForgeApp.swift` creates `DatabaseListViewModel`, which reads and mutates persisted database references through `Services/DatabaseListStore.swift`.
 - Unlock flow: `Views/UnlockView.swift` drives `ViewModels/DatabaseViewModel.swift`, which resolves the database file, derives the composite key, parses via `Models/KDBXParser.swift`, and stores a per-session `SymmetricKey`.
 - Local edit/save flow: `ViewModels/DatabaseViewModel.swift` stages changes in `Models/DatabaseDraft.swift`, reuses `Models/KDBXWriter.swift` for encryption, and saves local files through `Services/LocalDatabaseSaver.swift` with conflict checks, backups, and shared-cache refresh.
+- Entry editing flow: `Views/EntryEditView.swift` and `ViewModels/EntryEditViewModel.swift` drive create/edit/delete entry drafts from the unlocked database UI, while `Views/PasswordGeneratorSheet.swift` and `Services/PasswordGenerator.swift` provide the reusable strong-password generator surface.
 - Cloud database flow: cloud-backed `Models/DatabaseReference.swift` values carry `CloudSyncMetadata`; `Services/CloudSyncCoordinator.swift` decides whether to reuse cache or download before open.
 - Read-only/edit safety flow: `Models/DatabaseReference.swift` persists `isReadOnly` and `editsAcknowledgedAt`; `Services/SyncedFolderDetector.swift` classifies bookmark-backed synced folders before edit flows proceed.
 - AutoFill handoff: the main app and extension share models plus selected services through `project.yml`, `SharedVaultStore`, App Group defaults, cached database copies, and Keychain entries; local saves must keep the shared cached copy aligned.

KeeForge/README.md

@@ -14,6 +14,7 @@ enum DatabaseListStore {
     private static let uiTestDatabasesJSONEnv = "UI_TEST_DATABASES_JSON"
     private static let uiTestCloudDatabasesJSONEnv = "UI_TEST_CLOUD_DATABASES_JSON"
     private static let uiTestCloudAccountsJSONEnv = "UI_TEST_CLOUD_ACCOUNTS_JSON"
+    private static let uiTestLocalSaveConflictCountEnv = "UI_TEST_LOCAL_SAVE_CONFLICT_COUNT"
     private static let cloudAccountsStorageKey = "KeeForge.cloudAccounts"
 
     private static var sharedDefaults: UserDefaults {
@@ -30,6 +31,8 @@ enum DatabaseListStore {
     }
 
     private nonisolated(unsafe) static var didBootstrapUITesting = false
+    private nonisolated(unsafe) static var remainingUITestLocalSaveConflicts: Int?
+    private nonisolated(unsafe) static var consumedUITestLocalSaveConflicts = 0
 
     private struct UITestDatabasePayload: Decodable {
         let filename: String
@@ -345,6 +348,27 @@ enum DatabaseListStore {
         try? FileManager.default.removeItem(at: backupsRootURL)
         activeAutoFillDatabaseID = nil
         sharedDefaults.removeObject(forKey: migrationVersionKey)
+        remainingUITestLocalSaveConflicts = nil
+        consumedUITestLocalSaveConflicts = 0
+    }
+
+    static func consumeUITestLocalSaveConflictSequence() -> Int? {
+        guard ProcessInfo.processInfo.arguments.contains(uiTestingLaunchArg) else {
+            return nil
+        }
+
+        if remainingUITestLocalSaveConflicts == nil {
+            let rawValue = ProcessInfo.processInfo.environment[uiTestLocalSaveConflictCountEnv] ?? ""
+            remainingUITestLocalSaveConflicts = max(0, Int(rawValue) ?? 0)
+        }
+
+        guard let remainingUITestLocalSaveConflicts, remainingUITestLocalSaveConflicts > 0 else {
+            return nil
+        }
+
+        consumedUITestLocalSaveConflicts += 1
+        self.remainingUITestLocalSaveConflicts = remainingUITestLocalSaveConflicts - 1
+        return consumedUITestLocalSaveConflicts
     }
 
     static func pruneBackups(for reference: DatabaseReference, keeping count: Int) throws {

KeeForge/Services/DatabaseListStore.swift

@@ -178,7 +178,15 @@ enum LocalDatabaseSaver {
             }
         }
 
-        let currentData = try environment.readData(location.url)
+        var currentData = try environment.readData(location.url)
+        if let conflictSequence = DatabaseListStore.consumeUITestLocalSaveConflictSequence() {
+            currentData = try makeUITestConflictData(
+                from: currentData,
+                compositeKey: compositeKey,
+                sequence: conflictSequence
+            )
+            try environment.replaceFileAtomically(currentData, location.url)
+        }
         let currentSHA512 = KDBXCrypto.sha512(currentData)
         guard currentSHA512 == openTimeSHA512 else {
             return .conflict(remoteSHA512: currentSHA512, remoteData: currentData)
@@ -234,6 +242,32 @@ enum LocalDatabaseSaver {
         )
     }
 
+    private static func makeUITestConflictData(
+        from data: Data,
+        compositeKey: Data,
+        sequence: Int
+    ) throws -> Data {
+        let sessionKey = SymmetricKey(size: .bits256)
+        let parsed = try KDBXParser.parseWithMetaAndHeader(
+            data: data,
+            compositeKey: compositeKey,
+            sessionKey: sessionKey
+        )
+        parsed.rootGroup.entries.append(
+            KPEntry(
+                title: "UI Test Conflict \(sequence)",
+                notes: "Injected save conflict \(sequence)"
+            )
+        )
+        return try KDBXWriter.write(
+            rootGroup: parsed.rootGroup,
+            meta: parsed.meta,
+            compositeKey: compositeKey,
+            header: parsed.header,
+            sessionKey: sessionKey
+        )
+    }
+
     private static func replaceFileAtomically(_ data: Data, at url: URL) throws {
         let fileManager = FileManager.default
         let tempURL = url.deletingLastPathComponent().appendingPathComponent(