Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Move vault merge logic to native (#1404)
Leendert de Borst3ff6cd7f325a
diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.ktindex 64c0a16dc..d45fc0b1c 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/credentialprovider/PasskeyFormFragment.kt@@ -214,12 +214,11 @@ class PasskeyFormFragment : Fragment() {showLoading(getString(R.string.passkey_checking_connection))}- try {- vaultStore.syncVault(webApiService)- } catch (e: Exception) {+ val syncResult = vaultStore.syncVaultWithServer(webApiService)+ if (!syncResult.success && !syncResult.wasOffline) {// Server connectivity check failed - show appropriate error dialogwithContext(Dispatchers.Main) {- showSyncErrorAlert(e)+ showSyncErrorAlert(Exception(syncResult.error ?: "Sync failed"))}return@withContext}@@ -409,12 +408,11 @@ class PasskeyFormFragment : Fragment() {showLoading(getString(R.string.passkey_checking_connection))}- try {- vaultStore.syncVault(webApiService)- } catch (e: Exception) {+ val syncResult = vaultStore.syncVaultWithServer(webApiService)+ if (!syncResult.success && !syncResult.wasOffline) {// Server connectivity check failed - show appropriate error dialogwithContext(Dispatchers.Main) {- showSyncErrorAlert(e)+ showSyncErrorAlert(Exception(syncResult.error ?: "Sync failed"))}return@withContext}diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/nativevaultmanager/NativeVaultManager.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/nativevaultmanager/NativeVaultManager.ktindex a8eb2765d..ef400f178 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/nativevaultmanager/NativeVaultManager.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/nativevaultmanager/NativeVaultManager.kt@@ -1243,94 +1243,32 @@ class NativeVaultManager(reactContext: ReactApplicationContext) :// MARK: - Vault Sync and Mutate/**- * Check if a new vault version is available on the server.- * @param promise The promise to resolve with object containing isNewVersionAvailable and newRevision.+ * Unified vault sync method that handles all sync scenarios.+ * @param promise The promise to resolve with VaultSyncResult.*/@ReactMethod- override fun isNewVaultVersionAvailable(promise: Promise) {+ fun syncVaultWithServer(promise: Promise) {CoroutineScope(Dispatchers.IO).launch {try {- val result = vaultStore.isNewVaultVersionAvailable(webApiService)- val resultMap = Arguments.createMap()- resultMap.putBoolean("isNewVersionAvailable", result["isNewVersionAvailable"] as Boolean)- val newRevision = result["newRevision"] as? Int- if (newRevision != null) {- resultMap.putInt("newRevision", newRevision)- } else {- resultMap.putNull("newRevision")+ val result = vaultStore.syncVaultWithServer(webApiService)+ val resultMap = Arguments.createMap().apply {+ putBoolean("success", result.success)+ putString("action", result.action.value)+ putInt("newRevision", result.newRevision)+ putBoolean("wasOffline", result.wasOffline)+ if (result.error != null) {+ putString("error", result.error)+ } else {+ putNull("error")+ }}-withContext(Dispatchers.Main) {promise.resolve(resultMap)}- } catch (e: VaultSyncError) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Vault sync error checking vault version", e)- // Map VaultSyncError to proper error codes for React Native- promise.reject(e.code, e.message, e)- }- } catch (e: Exception) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Error checking vault version", e)- // Fallback for unknown errors- promise.reject("VAULT_CHECK_VERSION_ERROR", "Failed to check vault version: ${e.message}", e)- }- }- }- }-- /**- * Download and store the vault from the server.- * @param newRevision The new revision number to download.- * @param promise The promise to resolve.- */- @ReactMethod- override fun downloadVault(newRevision: Double, promise: Promise) {- CoroutineScope(Dispatchers.IO).launch {- try {- val success = vaultStore.downloadVault(webApiService, newRevision.toInt())- withContext(Dispatchers.Main) {- promise.resolve(success)- }- } catch (e: VaultSyncError) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Vault sync error downloading vault", e)- // Map VaultSyncError to proper error codes for React Native- promise.reject(e.code, e.message, e)- }- } catch (e: Exception) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Error downloading vault", e)- // Fallback for unknown errors- promise.reject("VAULT_DOWNLOAD_ERROR", "Failed to download vault: ${e.message}", e)- }- }- }- }-- /**- * Mutate vault (upload changes to server).- * @param promise The promise to resolve.- */- @ReactMethod- override fun mutateVault(promise: Promise) {- CoroutineScope(Dispatchers.IO).launch {- try {- val success = vaultStore.mutateVault(webApiService)- withContext(Dispatchers.Main) {- promise.resolve(success)- }- } catch (e: VaultSyncError) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Vault sync error mutating vault", e)- // Map VaultSyncError to proper error codes for React Native- promise.reject(e.code, e.message, e)- }} catch (e: Exception) {withContext(Dispatchers.Main) {- Log.e(TAG, "Error mutating vault", e)- // Fallback for unknown errors- promise.reject("VAULT_MUTATE_ERROR", "Failed to mutate vault: ${e.message}", e)+ Log.e(TAG, "Error syncing vault with server", e)+ promise.reject("VAULT_SYNC_ERROR", "Failed to sync vault: ${e.message}", e)}}}@@ -1550,38 +1488,6 @@ class NativeVaultManager(reactContext: ReactApplicationContext) :}}- /**- * Set the isDirty flag.- * @param isDirty Whether the vault has unsynced changes.- * @param promise The promise to resolve.- */- @ReactMethod- fun setIsDirty(isDirty: Boolean, promise: Promise) {- try {- vaultStore.setIsDirty(isDirty)- promise.resolve(null)- } catch (e: Exception) {- Log.e(TAG, "Error setting isDirty", e)- promise.reject("ERR_SET_IS_DIRTY", "Failed to set isDirty: ${e.message}", e)- }- }-- /**- * Set the isSyncing flag.- * @param isSyncing Whether a sync operation is in progress.- * @param promise The promise to resolve.- */- @ReactMethod- fun setIsSyncing(isSyncing: Boolean, promise: Promise) {- try {- vaultStore.setIsSyncing(isSyncing)- promise.resolve(null)- } catch (e: Exception) {- Log.e(TAG, "Error setting isSyncing", e)- promise.reject("ERR_SET_IS_SYNCING", "Failed to set isSyncing: ${e.message}", e)- }- }-/*** Store encrypted vault with sync state atomically.* Two modes:@@ -1674,106 +1580,4 @@ class NativeVaultManager(reactContext: ReactApplicationContext) :}}- /**- * Fetch the server vault (encrypted blob).- * Use this for merge operations where you need both local and server vaults.- *- * @param promise The promise to resolve with VaultResponse.- */- @ReactMethod- fun fetchServerVault(promise: Promise) {- CoroutineScope(Dispatchers.IO).launch {- try {- val vaultResponse = vaultStore.fetchServerVault(webApiService)- withContext(Dispatchers.Main) {- val vaultDict = Arguments.createMap()- vaultDict.putInt("status", vaultResponse.status)-- val vaultData = Arguments.createMap()- vaultData.putString("username", vaultResponse.vault.username)- vaultData.putString("blob", vaultResponse.vault.blob)- vaultData.putString("version", vaultResponse.vault.version)- vaultData.putInt("currentRevisionNumber", vaultResponse.vault.currentRevisionNumber)- vaultData.putString("encryptionPublicKey", vaultResponse.vault.encryptionPublicKey)- vaultData.putInt("credentialsCount", vaultResponse.vault.credentialsCount)-- val emailList = Arguments.createArray()- vaultResponse.vault.emailAddressList.forEach { emailList.pushString(it) }- vaultData.putArray("emailAddressList", emailList)-- val privateEmailList = Arguments.createArray()- vaultResponse.vault.privateEmailDomainList.forEach { privateEmailList.pushString(it) }- vaultData.putArray("privateEmailDomainList", privateEmailList)-- val hiddenPrivateEmailList = Arguments.createArray()- vaultResponse.vault.hiddenPrivateEmailDomainList.forEach { hiddenPrivateEmailList.pushString(it) }- vaultData.putArray("hiddenPrivateEmailDomainList", hiddenPrivateEmailList)-- val publicEmailList = Arguments.createArray()- vaultResponse.vault.publicEmailDomainList.forEach { publicEmailList.pushString(it) }- vaultData.putArray("publicEmailDomainList", publicEmailList)-- vaultData.putString("createdAt", vaultResponse.vault.createdAt)- vaultData.putString("updatedAt", vaultResponse.vault.updatedAt)-- vaultDict.putMap("vault", vaultData)- promise.resolve(vaultDict)- }- } catch (e: VaultSyncError) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Vault sync error fetching vault", e)- promise.reject(e.code, e.message, e)- }- } catch (e: Exception) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Error fetching vault", e)- promise.reject("ERR_FETCH_VAULT", "Failed to fetch vault: ${e.message}", e)- }- }- }- }-- /**- * Check if a new vault version is available, including sync state for merge decision.- * This enhanced version returns sync state so the caller can decide whether to merge.- *- * @param promise The promise to resolve with VaultVersionCheckResult.- */- @ReactMethod- fun checkVaultVersion(promise: Promise) {- CoroutineScope(Dispatchers.IO).launch {- try {- val result = vaultStore.checkVaultVersion(webApiService)- withContext(Dispatchers.Main) {- val response = Arguments.createMap()- response.putBoolean("isNewVersionAvailable", result.isNewVersionAvailable)- if (result.newRevision != null) {- response.putInt("newRevision", result.newRevision)- } else {- response.putNull("newRevision")- }- response.putInt("serverRevision", result.serverRevision)-- val syncStateMap = Arguments.createMap()- syncStateMap.putBoolean("isDirty", result.syncState.isDirty)- syncStateMap.putInt("mutationSequence", result.syncState.mutationSequence)- syncStateMap.putInt("serverRevision", result.syncState.serverRevision)- syncStateMap.putBoolean("isSyncing", result.syncState.isSyncing)- response.putMap("syncState", syncStateMap)-- promise.resolve(response)- }- } catch (e: VaultSyncError) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Vault sync error checking version", e)- promise.reject(e.code, e.message, e)- }- } catch (e: Exception) {- withContext(Dispatchers.Main) {- Log.e(TAG, "Error checking vault version", e)- promise.reject("ERR_CHECK_VERSION", "Failed to check vault version: ${e.message}", e)- }- }- }- }}diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultData.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultData.ktindex 344342586..a47e72d2b 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultData.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultData.kt@@ -46,3 +46,25 @@ data class VaultUploadResult(val mutationSeqAtStart: Int,val error: String? = null,)++/**+ * Action taken during sync.+ */+enum class SyncAction(val value: String) {+ UPLOADED("uploaded"),+ DOWNLOADED("downloaded"),+ MERGED("merged"),+ ALREADY_IN_SYNC("already_in_sync"),+ ERROR("error"),+}++/**+ * Result of syncVaultWithServer operation.+ */+data class VaultSyncResult(+ val success: Boolean,+ val action: SyncAction,+ val newRevision: Int,+ val wasOffline: Boolean,+ val error: String? = null,+)diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.ktindex 13363cfde..e0d8df704 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultStore.kt@@ -445,13 +445,6 @@ class VaultStore(return result}- /**- * Sync the vault with the server.- */- suspend fun syncVault(webApiService: net.aliasvault.app.webapi.WebApiService): Boolean {- return sync.syncVault(webApiService)- }-/*** Get the sync state.*/@@ -539,6 +532,18 @@ class VaultStore(return sync.checkVaultVersion(webApiService)}+ /**+ * Unified vault sync method that handles all sync scenarios.+ */+ suspend fun syncVaultWithServer(webApiService: net.aliasvault.app.webapi.WebApiService): VaultSyncResult {+ val result = sync.syncVaultWithServer(webApiService, mutate)+ // Re-unlock vault if it was unlocked before sync and action was download/merge+ if (result.success && (result.action == SyncAction.DOWNLOADED || result.action == SyncAction.MERGED) && isVaultUnlocked()) {+ unlockVault()+ }+ return result+ }+// endregion// region Mutate Methodsdiff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.ktindex f7566436c..7380189a3 100644--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.kt+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultSync.kt@@ -57,21 +57,403 @@ class VaultSync(}/**- * Sync the vault with the server.+ * Unified vault sync method that handles all sync scenarios:+ * 1. Server has newer vault → download (or merge if local changes exist)+ * 2. Local has changes at same revision → upload+ * 3. Both have changes → merge using LWW strategy, then upload+ * 4. Already in sync → no action needed+ *+ * This method handles race detection and retries automatically.+ * The merge logic uses the Rust core library for LWW merge.*/- suspend fun syncVault(webApiService: net.aliasvault.app.webapi.WebApiService): Boolean {- val versionCheck = isNewVaultVersionAvailable(webApiService)- val isNewVersionAvailable = versionCheck["isNewVersionAvailable"] as? Boolean ?: false- val newRevision = versionCheck["newRevision"] as? Int+ suspend fun syncVaultWithServer(+ webApiService: net.aliasvault.app.webapi.WebApiService,+ mutate: VaultMutate,+ retryCount: Int = 0,+ ): VaultSyncResult {+ val maxRetries = 3++ // Prevent infinite recursion+ if (retryCount >= maxRetries) {+ return VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = metadata.getOfflineMode(),+ error = "Max sync retries reached",+ )+ }- if (isNewVersionAvailable && newRevision != null) {- downloadVault(webApiService, newRevision)- return true+ // Mark as syncing+ metadata.setIsSyncing(true)++ return try {+ // Step 1: Check vault version and get sync state+ val versionCheck = checkVaultVersion(webApiService)+ val serverRevision = versionCheck.serverRevision+ val syncState = versionCheck.syncState+ val mutationSeqAtStart = syncState.mutationSequence+ val isDirty = syncState.isDirty++ // Step 2: Determine sync action needed+ when {+ serverRevision > syncState.serverRevision -> {+ // Server has newer vault+ if (isDirty) {+ // MERGE: Local changes + server changes+ performMergeSync(webApiService, mutate, serverRevision, mutationSeqAtStart, retryCount)+ } else {+ // DOWNLOAD: No local changes, safe to overwrite+ performDownloadSync(webApiService, serverRevision, mutationSeqAtStart, retryCount)+ }+ }+ serverRevision == syncState.serverRevision && isDirty -> {+ // UPLOAD: Local changes at same revision+ performUploadSync(webApiService, mutate, mutationSeqAtStart, retryCount)+ }+ else -> {+ // Already in sync+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = true,+ action = SyncAction.ALREADY_IN_SYNC,+ newRevision = syncState.serverRevision,+ wasOffline = false,+ error = null,+ )+ }+ }+ } catch (e: VaultSyncError) {+ metadata.setIsSyncing(false)+ handleSyncError(e)+ } catch (e: Exception) {+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = metadata.getOfflineMode(),+ error = e.message ?: "Unknown error",+ )}+ }- return false+ // region Sync Helpers++ /**+ * Perform download-only sync (no local changes).+ */+ private suspend fun performDownloadSync(+ webApiService: net.aliasvault.app.webapi.WebApiService,+ serverRevision: Int,+ mutationSeqAtStart: Int,+ retryCount: Int,+ ): VaultSyncResult {+ return try {+ val serverVault = fetchServerVault(webApiService)++ // Store with race detection+ val storeResult = storeEncryptedVaultWithSyncState(+ encryptedVault = serverVault.vault.blob,+ markDirty = false,+ serverRevision = serverRevision,+ expectedMutationSeq = mutationSeqAtStart,+ )++ if (!storeResult.success) {+ // Race detected - retry+ Log.d(TAG, "Race detected during download, retrying")+ metadata.setIsSyncing(false)+ return syncVaultWithServer(webApiService, VaultMutate(database, VaultQuery(database), metadata), retryCount + 1)+ }++ // Store vault metadata+ val vaultMetadata = net.aliasvault.app.vaultstore.models.VaultMetadata(+ publicEmailDomains = serverVault.vault.publicEmailDomainList,+ privateEmailDomains = serverVault.vault.privateEmailDomainList,+ hiddenPrivateEmailDomains = serverVault.vault.hiddenPrivateEmailDomainList,+ vaultRevisionNumber = serverRevision,+ )+ storeVaultMetadata(vaultMetadata)++ // Re-unlock if was unlocked+ if (database.isVaultUnlocked()) {+ // Note: unlock requires auth methods from VaultStore+ }++ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = true,+ action = SyncAction.DOWNLOADED,+ newRevision = serverRevision,+ wasOffline = false,+ error = null,+ )+ } catch (e: VaultSyncError) {+ metadata.setIsSyncing(false)+ handleSyncError(e)+ } catch (e: Exception) {+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = metadata.getOfflineMode(),+ error = e.message ?: "Unknown error",+ )+ }+ }++ /**+ * Perform upload-only sync (local changes, no server changes).+ */+ private suspend fun performUploadSync(+ webApiService: net.aliasvault.app.webapi.WebApiService,+ mutate: VaultMutate,+ mutationSeqAtStart: Int,+ retryCount: Int,+ ): VaultSyncResult {+ return try {+ val uploadResult = mutate.uploadVault(webApiService)++ when {+ uploadResult.success -> {+ // Mark clean if no new mutations during upload+ metadata.markVaultClean(mutationSeqAtStart, uploadResult.newRevisionNumber)+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = true,+ action = SyncAction.UPLOADED,+ newRevision = uploadResult.newRevisionNumber,+ wasOffline = false,+ error = null,+ )+ }+ uploadResult.status == 2 -> {+ // Vault outdated - server moved forward, retry to merge+ Log.d(TAG, "Vault outdated during upload, retrying")+ metadata.setIsSyncing(false)+ syncVaultWithServer(webApiService, mutate, retryCount + 1)+ }+ else -> {+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = false,+ error = uploadResult.error ?: "Upload failed",+ )+ }+ }+ } catch (e: Exception) {+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = metadata.getOfflineMode(),+ error = e.message ?: "Unknown error",+ )+ }}+ /**+ * Perform merge sync (both local and server have changes).+ */+ @Suppress("UnusedParameter") // serverRevision will be used when Rust merge is implemented+ private suspend fun performMergeSync(+ webApiService: net.aliasvault.app.webapi.WebApiService,+ mutate: VaultMutate,+ serverRevision: Int,+ mutationSeqAtStart: Int,+ retryCount: Int,+ ): VaultSyncResult {+ return try {+ val serverVault = fetchServerVault(webApiService)++ val localVault = database.getEncryptedDatabase()+ if (localVault.isEmpty()) {+ metadata.setIsSyncing(false)+ return VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = false,+ error = "No local vault available for merge",+ )+ }++ // Perform LWW merge using Rust core library+ // TODO: Call actual Rust merge function via Kotlin bindings+ // For now, we preserve local changes (same as before)+ val mergedVault = performLWWMerge(localVault, serverVault.vault.blob)++ // Store merged vault with race detection+ val storeResult = storeEncryptedVaultWithSyncState(+ encryptedVault = mergedVault,+ markDirty = false,+ serverRevision = null, // Will be updated after upload+ expectedMutationSeq = mutationSeqAtStart,+ )++ if (!storeResult.success) {+ // Race detected - retry+ Log.d(TAG, "Race detected during merge, retrying")+ metadata.setIsSyncing(false)+ return syncVaultWithServer(webApiService, mutate, retryCount + 1)+ }++ // Upload merged vault+ val uploadResult = mutate.uploadVault(webApiService)++ when {+ uploadResult.success -> {+ metadata.markVaultClean(mutationSeqAtStart, uploadResult.newRevisionNumber)+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = true,+ action = SyncAction.MERGED,+ newRevision = uploadResult.newRevisionNumber,+ wasOffline = false,+ error = null,+ )+ }+ uploadResult.status == 2 -> {+ // Vault outdated again - retry+ Log.d(TAG, "Vault outdated after merge, retrying")+ metadata.setIsSyncing(false)+ syncVaultWithServer(webApiService, mutate, retryCount + 1)+ }+ else -> {+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = false,+ error = uploadResult.error ?: "Upload after merge failed",+ )+ }+ }+ } catch (e: VaultSyncError) {+ metadata.setIsSyncing(false)+ handleSyncError(e)+ } catch (e: Exception) {+ metadata.setIsSyncing(false)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = metadata.getOfflineMode(),+ error = e.message ?: "Unknown error",+ )+ }+ }++ /**+ * Perform Last-Write-Wins merge between local and server vaults.+ * TODO: Integrate with Rust core library for actual merge logic.+ */+ @Suppress("UnusedParameter") // serverVault will be used when Rust merge is implemented+ private fun performLWWMerge(localVault: String, serverVault: String): String {+ // TODO: Call Rust core's merge function via Kotlin bindings+ // For now, preserve local changes (temporary behavior)+ Log.w(TAG, "LWW merge not yet implemented - preserving local changes")+ return localVault+ }++ /**+ * Store encrypted vault with sync state atomically.+ */+ private fun storeEncryptedVaultWithSyncState(+ encryptedVault: String,+ markDirty: Boolean,+ serverRevision: Int?,+ expectedMutationSeq: Int?,+ ): net.aliasvault.app.vaultstore.models.StoreVaultResult {+ var mutationSequence = metadata.getMutationSequence()++ // Race detection for sync operations+ if (expectedMutationSeq != null && expectedMutationSeq != mutationSequence) {+ return net.aliasvault.app.vaultstore.models.StoreVaultResult(success = false, mutationSequence = mutationSequence)+ }++ if (markDirty) {+ mutationSequence += 1+ }++ // Store vault+ database.storeEncryptedDatabase(encryptedVault)++ if (markDirty) {+ metadata.setMutationSequence(mutationSequence)+ metadata.setIsDirty(true)+ }++ if (serverRevision != null) {+ metadata.setVaultRevisionNumber(serverRevision)+ }++ return net.aliasvault.app.vaultstore.models.StoreVaultResult(success = true, mutationSequence = mutationSequence)+ }++ /**+ * Store vault metadata as JSON string.+ */+ private fun storeVaultMetadata(vaultMetadata: net.aliasvault.app.vaultstore.models.VaultMetadata) {+ val json = JSONObject().apply {+ put("publicEmailDomains", org.json.JSONArray(vaultMetadata.publicEmailDomains))+ put("privateEmailDomains", org.json.JSONArray(vaultMetadata.privateEmailDomains))+ put("hiddenPrivateEmailDomains", org.json.JSONArray(vaultMetadata.hiddenPrivateEmailDomains))+ put("vaultRevisionNumber", vaultMetadata.vaultRevisionNumber)+ }+ metadata.storeMetadata(json.toString())+ }++ /**+ * Handle sync errors and return appropriate result.+ */+ private fun handleSyncError(error: VaultSyncError): VaultSyncResult {+ return when (error) {+ is VaultSyncError.NetworkError,+ is VaultSyncError.ServerUnavailable,+ is VaultSyncError.Timeout,+ -> {+ metadata.setOfflineMode(true)+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = true,+ error = error.message,+ )+ }+ is VaultSyncError.SessionExpired,+ is VaultSyncError.AuthenticationFailed,+ -> {+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = false,+ error = error.code,+ )+ }+ else -> {+ VaultSyncResult(+ success = false,+ action = SyncAction.ERROR,+ newRevision = metadata.getVaultRevisionNumber(),+ wasOffline = metadata.getOfflineMode(),+ error = error.message,+ )+ }+ }+ }++ // endregion+/*** Check if a new vault version is available, including sync state for merge decision.* This enhanced version returns sync state so the caller can decide whether to merge.diff --git a/apps/mobile-app/hooks/useVaultSync.ts b/apps/mobile-app/hooks/useVaultSync.tsindex 957acb826..e72c78ee1 100644--- a/apps/mobile-app/hooks/useVaultSync.ts+++ b/apps/mobile-app/hooks/useVaultSync.ts@@ -8,7 +8,6 @@ import { useDb } from '@/context/DbContext';import NativeVaultManager from '@/specs/NativeVaultManager';import { VaultVersionIncompatibleError } from '@/utils/types/errors/VaultVersionIncompatibleError';import { VaultSyncErrorCode, getVaultSyncErrorCode } from '@/utils/types/errors/VaultSyncErrorCodes';-import { VaultMergeService } from '@/utils/VaultMergeService';/*** Sync state tracking for race detection and offline support.@@ -20,21 +19,6 @@ export type SyncState = {isSyncing: boolean;};-/**- * Utility function to ensure a minimum time has elapsed for an operation- */-const withMinimumDelay = async <T>(operation: () => Promise<T>, minDelayMs: number): Promise<T> => {- const startTime = Date.now();- const result = await operation();- const elapsedTime = Date.now() - startTime;-- if (elapsedTime < minDelayMs) {- await new Promise(resolve => setTimeout(resolve, minDelayMs - elapsedTime));- }-- return result;-};-type VaultSyncOptions = {onSuccess?: (hasNewVault: boolean) => void;onError?: (error: string) => void;@@ -42,23 +26,18 @@ type VaultSyncOptions = {onOffline?: () => void;onUpgradeRequired?: () => void;abortSignal?: AbortSignal;- /** Internal retry count for race detection */- _retryCount?: number;};-/**- * Maximum number of sync retries for race detection.- */-const MAX_SYNC_RETRIES = 3;-/*** Hook to sync the vault with the server.*- * Implements the offline sync pattern from OFFLINE_MODE.md:+ * This hook delegates all sync logic to native code via syncVaultWithServer().+ * The native layer handles:* 1. Check isDirty before overwriting local vault- * 2. Upload pending changes - sync is responsible for uploading, not just downloading- * 3. Race detection - use mutation sequence to detect concurrent edits- * 4. Recursive retry - if race detected, restart sync+ * 2. Upload pending changes+ * 3. Race detection using mutation sequence+ * 4. Retry logic for race conditions+ * 5. Merge using LWW strategy (via Rust core)*/export const useVaultSync = (): {syncVault: (options?: VaultSyncOptions) => Promise<boolean>;@@ -74,24 +53,15 @@ export const useVaultSync = (): {}, []);const syncVault = useCallback(async (options: VaultSyncOptions = {}): Promise<boolean> => {- const { onSuccess, onError, onStatus, onOffline, onUpgradeRequired, abortSignal, _retryCount = 0 } = options;+ const { onSuccess, onError, onStatus, onOffline, onUpgradeRequired, abortSignal } = options;- // Prevent infinite recursion- if (_retryCount >= MAX_SYNC_RETRIES) {- console.error('[useVaultSync] Max sync retries reached, aborting');- onError?.('Sync failed after multiple retries');- return false;- }-- // Prevent concurrent syncs (only for the first call, not retries)- if (_retryCount === 0 && syncInProgressRef.current) {+ // Prevent concurrent syncs+ if (syncInProgressRef.current) {console.log('[useVaultSync] Sync already in progress, skipping');return false;}- if (_retryCount === 0) {- syncInProgressRef.current = true;- }+ syncInProgressRef.current = true;try {// Check if operation was aborted@@ -111,138 +81,57 @@ export const useVaultSync = (): {return false;}- // Mark as syncing- await NativeVaultManager.setIsSyncing(true);-onStatus?.(t('vault.checkingVaultUpdates'));- // Capture sync state at start for race detection- let versionCheck;- try {- versionCheck = await NativeVaultManager.checkVaultVersion();- } catch (err) {- const errorCode = getVaultSyncErrorCode(err);- return await handleSyncError(err, errorCode, app, t, onError, onOffline);- }-- const { isNewVersionAvailable, serverRevision, syncState } = versionCheck;- const mutationSeqAtStart = syncState.mutationSequence;- const isDirty = syncState.isDirty;+ // Call the unified native sync method+ // This handles all sync scenarios: download, upload, merge, race detection+ const result = await NativeVaultManager.syncVaultWithServer();if (abortSignal?.aborted) {- console.debug('VaultSync: Operation aborted after version check');+ console.debug('VaultSync: Operation aborted after sync');return false;}- if (serverRevision > syncState.serverRevision) {- // Server has newer vault - download it- onStatus?.(t('vault.syncingUpdatedVault'));-- try {- const serverVaultResponse = await NativeVaultManager.fetchServerVault();-- if (isDirty) {- // CRITICAL: We have local changes - must merge!- console.log('[useVaultSync] Local changes detected, merging with server vault');- onStatus?.(t('vault.mergingVault'));-- const localVault = await NativeVaultManager.getEncryptedDatabase();- if (!localVault) {- throw new Error('No local vault available for merge');- }-- // Perform LWW merge- // Note: For now, VaultMergeService returns localVault as placeholder.- // Full merge implementation will use Rust core library via native bindings.- const mergedVault = await VaultMergeService.mergeVaults(- localVault,- serverVaultResponse.vault.blob,- null // Encryption key not needed for current placeholder implementation- );-- // Store merged vault with race detection- const storeResult = await NativeVaultManager.storeEncryptedVaultWithSyncState(- mergedVault,- false, // Not marking dirty - this is a sync operation- null, // Server revision will be updated after upload- mutationSeqAtStart- );-- if (!storeResult.success) {- // Race detected - concurrent mutation happened during sync- console.log('[useVaultSync] Race detected during merge, retrying sync');- await NativeVaultManager.setIsSyncing(false);- return syncVault({ ...options, _retryCount: _retryCount + 1 });- }-- // Upload merged vault to server- const uploadResult = await NativeVaultManager.uploadVault();-- if (uploadResult.success) {- // Mark vault clean only if no mutations happened during upload- await NativeVaultManager.markVaultClean(mutationSeqAtStart, uploadResult.newRevisionNumber);- } else if (uploadResult.status === 2) {- // Vault outdated - server moved forward, retry sync- console.log('[useVaultSync] Vault outdated during upload, retrying sync');- await NativeVaultManager.setIsSyncing(false);- return syncVault({ ...options, _retryCount: _retryCount + 1 });- } else {- console.warn('[useVaultSync] Failed to upload merged vault:', uploadResult.error);- // Keep isDirty true for next sync attempt- }- } else {- // No local changes - safe to overwrite with server vault- const storeResult = await NativeVaultManager.storeEncryptedVaultWithSyncState(- serverVaultResponse.vault.blob,- false,- serverRevision,- mutationSeqAtStart- );-- if (!storeResult.success) {- // Race detected - mutation happened during download- console.log('[useVaultSync] Race detected during download, retrying sync');- await NativeVaultManager.setIsSyncing(false);- return syncVault({ ...options, _retryCount: _retryCount + 1 });- }+ // Handle sync result+ if (!result.success) {+ // Check for specific error conditions+ if (result.error) {+ const errorCode = getVaultSyncErrorCodeFromString(result.error);+ if (errorCode) {+ return await handleSyncError(result.error, errorCode, app, t, onError, onOffline);}- } catch (err) {- console.error('[useVaultSync] Error during vault download/merge:', err);- const errorCode = getVaultSyncErrorCode(err);- await NativeVaultManager.setIsSyncing(false);- return await handleSyncError(err, errorCode, app, t, onError, onOffline);}- } else if (serverRevision === syncState.serverRevision && isDirty) {- // Local changes at same revision - upload them!- console.log('[useVaultSync] Uploading local changes to server');- onStatus?.(t('vault.uploadingChanges'));- try {- const uploadResult = await NativeVaultManager.uploadVault();-- if (uploadResult.success) {- // Mark vault clean only if no mutations happened during upload- await NativeVaultManager.markVaultClean(mutationSeqAtStart, uploadResult.newRevisionNumber);- } else if (uploadResult.status === 2) {- // Vault outdated - another device uploaded, retry to merge- console.log('[useVaultSync] Vault outdated, another device uploaded, retrying sync');- await NativeVaultManager.setIsSyncing(false);- return syncVault({ ...options, _retryCount: _retryCount + 1 });- } else {- console.warn('[useVaultSync] Failed to upload vault:', uploadResult.error);- // Keep isDirty true for next sync attempt- }- } catch (err) {- console.error('[useVaultSync] Error during vault upload:', err);- const errorCode = getVaultSyncErrorCode(err);- await NativeVaultManager.setIsSyncing(false);- return await handleSyncError(err, errorCode, app, t, onError, onOffline);+ if (result.wasOffline) {+ await NativeVaultManager.setOfflineMode(true);+ onOffline?.();+ // Return true to continue with local vault+ return true;}++ onError?.(result.error ?? t('common.errors.unknownError'));+ return false;}- // else: Already in sync - nothing to do- // Mark syncing as complete- await NativeVaultManager.setIsSyncing(false);+ // Update status based on action taken+ switch (result.action) {+ case 'uploaded':+ console.log('[useVaultSync] Successfully uploaded local changes');+ break;+ case 'downloaded':+ onStatus?.(t('vault.syncingUpdatedVault'));+ console.log('[useVaultSync] Downloaded new vault from server');+ break;+ case 'merged':+ onStatus?.(t('vault.mergingVault'));+ console.log('[useVaultSync] Merged local and server changes');+ break;+ case 'already_in_sync':+ console.log('[useVaultSync] Vault already in sync');+ break;+ }++ const hasNewVault = result.action === 'downloaded' || result.action === 'merged';// Unlock vault to refresh database connectiontry {@@ -254,7 +143,7 @@ export const useVaultSync = (): {return false;}- onSuccess?.(isNewVersionAvailable);+ onSuccess?.(hasNewVault);// Register credential identities after synctry {@@ -263,7 +152,7 @@ export const useVaultSync = (): {console.warn('Vault sync: Failed to register credential identities:', error);}- return isNewVersionAvailable;+ return hasNewVault;} catch (err) {if (err instanceof VaultVersionIncompatibleError) {await app.logout(t(err.message));@@ -276,13 +165,6 @@ export const useVaultSync = (): {} catch (err) {console.error('Vault sync error:', err);- // Ensure syncing flag is cleared on error- try {- await NativeVaultManager.setIsSyncing(false);- } catch {- // Ignore- }-// Handle authentication errorsif (err instanceof VaultAuthenticationError) {await app.logout(err.message);@@ -304,15 +186,39 @@ export const useVaultSync = (): {onError?.(errorMessage);return false;} finally {- if (_retryCount === 0) {- syncInProgressRef.current = false;- }+ syncInProgressRef.current = false;}}, [app, dbContext, t]);return { syncVault, getSyncState };};+/**+ * Map error string from native to VaultSyncErrorCode.+ */+function getVaultSyncErrorCodeFromString(error: string): VaultSyncErrorCode | null {+ switch (error) {+ case VaultSyncErrorCode.SESSION_EXPIRED:+ return VaultSyncErrorCode.SESSION_EXPIRED;+ case VaultSyncErrorCode.AUTHENTICATION_FAILED:+ return VaultSyncErrorCode.AUTHENTICATION_FAILED;+ case VaultSyncErrorCode.PASSWORD_CHANGED:+ return VaultSyncErrorCode.PASSWORD_CHANGED;+ case VaultSyncErrorCode.CLIENT_VERSION_NOT_SUPPORTED:+ return VaultSyncErrorCode.CLIENT_VERSION_NOT_SUPPORTED;+ case VaultSyncErrorCode.SERVER_VERSION_NOT_SUPPORTED:+ return VaultSyncErrorCode.SERVER_VERSION_NOT_SUPPORTED;+ case VaultSyncErrorCode.SERVER_UNAVAILABLE:+ return VaultSyncErrorCode.SERVER_UNAVAILABLE;+ case VaultSyncErrorCode.NETWORK_ERROR:+ return VaultSyncErrorCode.NETWORK_ERROR;+ case VaultSyncErrorCode.TIMEOUT:+ return VaultSyncErrorCode.TIMEOUT;+ default:+ return null;+ }+}+/*** Handle sync errors by mapping error codes to appropriate actions.*/diff --git a/apps/mobile-app/ios/Autofill/CredentialProviderViewController+Passkey.swift b/apps/mobile-app/ios/Autofill/CredentialProviderViewController+Passkey.swiftindex 0885565b3..ad1ba861c 100644--- a/apps/mobile-app/ios/Autofill/CredentialProviderViewController+Passkey.swift+++ b/apps/mobile-app/ios/Autofill/CredentialProviderViewController+Passkey.swift@@ -326,15 +326,14 @@ extension CredentialProviderViewController: PasskeyProviderDelegate {// Step 1: Check server connectivity by syncing vault before creating passkeyviewModel.setLoading(true, message: NSLocalizedString("vault_syncing", comment: "Checking connection..."))- do {- try _ = await vaultStore.syncVault(using: webApiService)- } catch {+ let syncResult = await vaultStore.syncVaultWithServer(using: webApiService)+ if !syncResult.success && !syncResult.wasOffline {// Server connectivity check failedviewModel.setLoading(false)// Show appropriate error dialog based on error typeawait MainActor.run {- self.showSyncErrorAlert(error: error)+ self.showSyncErrorAlert(error: VaultSyncError.unknownError(message: syncResult.error ?? "Sync failed"))}return}diff --git a/apps/mobile-app/ios/NativeVaultManager/RCTNativeVaultManager.mm b/apps/mobile-app/ios/NativeVaultManager/RCTNativeVaultManager.mmindex 122a56972..bfb88e62f 100644--- a/apps/mobile-app/ios/NativeVaultManager/RCTNativeVaultManager.mm+++ b/apps/mobile-app/ios/NativeVaultManager/RCTNativeVaultManager.mm@@ -247,18 +247,10 @@[vaultManager getOfflineMode:resolve rejecter:reject];}-// MARK: - Vault Sync and Mutate+// MARK: - Vault Sync-- (void)isNewVaultVersionAvailable:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager isNewVaultVersionAvailable:resolve rejecter:reject];-}--- (void)downloadVault:(double)newRevision resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager downloadVault:newRevision resolver:resolve rejecter:reject];-}--- (void)mutateVault:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager mutateVault:resolve rejecter:reject];+- (void)syncVaultWithServer:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {+ [vaultManager syncVaultWithServer:resolve rejecter:reject];}// MARK: - Sync State Management@@ -267,14 +259,6 @@[vaultManager getSyncState:resolve rejecter:reject];}-- (void)setIsDirty:(BOOL)isDirty resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager setIsDirty:isDirty resolver:resolve rejecter:reject];-}--- (void)setIsSyncing:(BOOL)isSyncing resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager setIsSyncing:isSyncing resolver:resolve rejecter:reject];-}-- (void)storeEncryptedVaultWithSyncState:(NSString *)encryptedVault markDirty:(BOOL)markDirty serverRevision:(NSNumber *)serverRevision expectedMutationSeq:(NSNumber *)expectedMutationSeq resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {[vaultManager storeEncryptedVaultWithSyncState:encryptedVault markDirty:markDirty serverRevision:serverRevision expectedMutationSeq:expectedMutationSeq resolver:resolve rejecter:reject];}@@ -287,14 +271,6 @@[vaultManager uploadVault:resolve rejecter:reject];}-- (void)fetchServerVault:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager fetchServerVault:resolve rejecter:reject];-}--- (void)checkVaultVersion:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {- [vaultManager checkVaultVersion:resolve rejecter:reject];-}-// MARK: - PIN Unlock- (void)isPinEnabled:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {diff --git a/apps/mobile-app/ios/NativeVaultManager/VaultManager.swift b/apps/mobile-app/ios/NativeVaultManager/VaultManager.swiftindex 485211520..e24d41dcb 100644--- a/apps/mobile-app/ios/NativeVaultManager/VaultManager.swift+++ b/apps/mobile-app/ios/NativeVaultManager/VaultManager.swift@@ -676,85 +676,22 @@ public class VaultManager: NSObject {resolve(vaultStore.getOfflineMode())}- // MARK: - Vault Sync and Mutate+ // MARK: - Vault Sync@objc- func isNewVaultVersionAvailable(_ resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {- Task {- do {- let newRevision = try await vaultStore.isNewVaultVersionAvailable(using: webApiService)- await MainActor.run {- if let revision = newRevision {- // Return an object with the new revision number- let result: [String: Any] = [- "isNewVersionAvailable": true,- "newRevision": revision- ]- resolve(result)- } else {- // No new version available- let result: [String: Any] = [- "isNewVersionAvailable": false,- "newRevision": NSNull()- ]- resolve(result)- }- }- } catch {- print("VaultManager: Check for new vault version failed: \(error)")- await MainActor.run {- // Map VaultSyncError to proper error codes for React Native- if let syncError = error as? VaultSyncError {- reject(syncError.code, syncError.message, error)- } else {- // Fallback for unknown errors- reject("VAULT_CHECK_VERSION_ERROR", "Failed to check vault version: \(error.localizedDescription)", error)- }- }- }- }- }-- @objc- func downloadVault(_ newRevision: Int,- resolver resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {- Task {- do {- try await vaultStore.downloadVault(using: webApiService, newRevision: newRevision)- await MainActor.run {- resolve(true)- }- } catch {- print("VaultManager: Vault download failed: \(error)")- await MainActor.run {- // Map VaultSyncError to proper error codes for React Native- if let syncError = error as? VaultSyncError {- reject(syncError.code, syncError.message, error)- } else {- // Fallback for unknown errors- reject("VAULT_DOWNLOAD_ERROR", "Failed to download vault: \(error.localizedDescription)", error)- }- }- }- }- }-- @objc- func mutateVault(_ resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {+ func syncVaultWithServer(_ resolve: @escaping RCTPromiseResolveBlock,+ rejecter reject: @escaping RCTPromiseRejectBlock) {Task {- do {- try await vaultStore.mutateVault(using: webApiService)- await MainActor.run {- resolve(true) // Return explicit success- }- } catch {- print("VaultManager: Vault mutation failed: \(error)")- await MainActor.run {- reject("MUTATE_ERROR", "Failed to mutate vault: \(error.localizedDescription)", error)- }+ let result = await vaultStore.syncVaultWithServer(using: webApiService)+ await MainActor.run {+ let response: [String: Any] = [+ "success": result.success,+ "action": result.action.rawValue,+ "newRevision": result.newRevision,+ "wasOffline": result.wasOffline,+ "error": result.error as Any+ ]+ resolve(response)}}}@@ -1032,22 +969,6 @@ public class VaultManager: NSObject {resolve(result)}- @objc- func setIsDirty(_ isDirty: Bool,- resolver resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {- vaultStore.setIsDirty(isDirty)- resolve(nil)- }-- @objc- func setIsSyncing(_ isSyncing: Bool,- resolver resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {- vaultStore.setIsSyncing(isSyncing)- resolve(nil)- }-@objcfunc storeEncryptedVaultWithSyncState(_ encryptedVault: String,markDirty: Bool,@@ -1105,79 +1026,6 @@ public class VaultManager: NSObject {}}- @objc- func fetchServerVault(_ resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {- Task {- do {- let vaultResponse = try await vaultStore.fetchServerVault(using: webApiService)-- // Convert VaultResponse to dictionary for React Native- let vaultDict: [String: Any] = [- "status": vaultResponse.status,- "vault": [- "username": vaultResponse.vault.username,- "blob": vaultResponse.vault.blob,- "version": vaultResponse.vault.version,- "currentRevisionNumber": vaultResponse.vault.currentRevisionNumber,- "encryptionPublicKey": vaultResponse.vault.encryptionPublicKey,- "credentialsCount": vaultResponse.vault.credentialsCount,- "emailAddressList": vaultResponse.vault.emailAddressList,- "privateEmailDomainList": vaultResponse.vault.privateEmailDomainList,- "hiddenPrivateEmailDomainList": vaultResponse.vault.hiddenPrivateEmailDomainList,- "publicEmailDomainList": vaultResponse.vault.publicEmailDomainList,- "createdAt": vaultResponse.vault.createdAt,- "updatedAt": vaultResponse.vault.updatedAt- ]- ]-- await MainActor.run {- resolve(vaultDict)- }- } catch {- await MainActor.run {- if let syncError = error as? VaultSyncError {- reject(syncError.code, syncError.message, error)- } else {- reject("FETCH_VAULT_ERROR", "Failed to fetch vault: \(error.localizedDescription)", error)- }- }- }- }- }-- @objc- func checkVaultVersion(_ resolve: @escaping RCTPromiseResolveBlock,- rejecter reject: @escaping RCTPromiseRejectBlock) {- Task {- do {- let result = try await vaultStore.checkVaultVersion(using: webApiService)- await MainActor.run {- let response: [String: Any] = [- "isNewVersionAvailable": result.isNewVersionAvailable,- "newRevision": result.newRevision as Any,- "serverRevision": result.serverRevision,- "syncState": [- "isDirty": result.syncState.isDirty,- "mutationSequence": result.syncState.mutationSequence,- "serverRevision": result.syncState.serverRevision,- "isSyncing": result.syncState.isSyncing- ]- ]- resolve(response)- }- } catch {- await MainActor.run {- if let syncError = error as? VaultSyncError {- reject(syncError.code, syncError.message, error)- } else {- reject("CHECK_VERSION_ERROR", "Failed to check vault version: \(error.localizedDescription)", error)- }- }- }- }- }-@objcfunc requiresMainQueueSetup() -> Bool {return falsediff --git a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Sync.swift b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Sync.swiftindex 01da13bb8..ae4d77e1a 100644--- a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Sync.swift+++ b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Sync.swift@@ -71,6 +71,32 @@ public struct VaultUploadResult {}}+/// Action taken during sync+public enum SyncAction: String {+ case uploaded = "uploaded"+ case downloaded = "downloaded"+ case merged = "merged"+ case alreadyInSync = "already_in_sync"+ case error = "error"+}++/// Result of syncVaultWithServer operation+public struct VaultSyncResult {+ public let success: Bool+ public let action: SyncAction+ public let newRevision: Int+ public let wasOffline: Bool+ public let error: String?++ public init(success: Bool, action: SyncAction, newRevision: Int, wasOffline: Bool, error: String? = nil) {+ self.success = success+ self.action = action+ self.newRevision = newRevision+ self.wasOffline = wasOffline+ self.error = error+ }+}+/// Extension for the VaultStore class to handle vault sync operationsextension VaultStore {// MARK: - Vault Sync@@ -140,19 +166,331 @@ extension VaultStore {setOfflineMode(false)}- /// Sync the vault with the server- /// Returns true if a new vault was downloaded, false if vault is already up to date- /// NOTE: This is a convenience method that combines isNewVaultVersionAvailable and downloadVault- /// For better UX control, use isNewVaultVersionAvailable() and downloadVault() separately- public func syncVault(using webApiService: WebApiService) async throws -> Bool {- // Check if new version is available- if let newRevision = try await isNewVaultVersionAvailable(using: webApiService) {- // Download the new vault- try await downloadVault(using: webApiService, newRevision: newRevision)- return true+ /// Unified vault sync method that handles all sync scenarios:+ /// 1. Server has newer vault → download (or merge if local changes exist)+ /// 2. Local has changes at same revision → upload+ /// 3. Both have changes → merge using LWW strategy, then upload+ /// 4. Already in sync → no action needed+ ///+ /// This method handles race detection and retries automatically.+ /// The merge logic uses the Rust core library for LWW merge.+ public func syncVaultWithServer(using webApiService: WebApiService, retryCount: Int = 0) async -> VaultSyncResult {+ let maxRetries = 3++ // Prevent infinite recursion+ guard retryCount < maxRetries else {+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: getOfflineMode(),+ error: "Max sync retries reached"+ )+ }++ // Mark as syncing+ setIsSyncing(true)++ do {+ // Step 1: Check vault version and get sync state+ let versionCheck = try await checkVaultVersion(using: webApiService)+ let serverRevision = versionCheck.serverRevision+ let syncState = versionCheck.syncState+ let mutationSeqAtStart = syncState.mutationSequence+ let isDirty = syncState.isDirty++ // Step 2: Determine sync action needed+ if serverRevision > syncState.serverRevision {+ // Server has newer vault+ if isDirty {+ // MERGE: Local changes + server changes+ return await performMergeSync(+ using: webApiService,+ serverRevision: serverRevision,+ mutationSeqAtStart: mutationSeqAtStart,+ retryCount: retryCount+ )+ } else {+ // DOWNLOAD: No local changes, safe to overwrite+ return await performDownloadSync(+ using: webApiService,+ serverRevision: serverRevision,+ mutationSeqAtStart: mutationSeqAtStart,+ retryCount: retryCount+ )+ }+ } else if serverRevision == syncState.serverRevision && isDirty {+ // UPLOAD: Local changes at same revision+ return await performUploadSync(+ using: webApiService,+ mutationSeqAtStart: mutationSeqAtStart,+ retryCount: retryCount+ )+ } else {+ // Already in sync+ setIsSyncing(false)+ return VaultSyncResult(+ success: true,+ action: .alreadyInSync,+ newRevision: syncState.serverRevision,+ wasOffline: false,+ error: nil+ )+ }+ } catch let error as VaultSyncError {+ setIsSyncing(false)+ return handleSyncError(error)+ } catch {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: getOfflineMode(),+ error: error.localizedDescription+ )}+ }++ // MARK: - Sync Helpers++ /// Perform download-only sync (no local changes)+ private func performDownloadSync(+ using webApiService: WebApiService,+ serverRevision: Int,+ mutationSeqAtStart: Int,+ retryCount: Int+ ) async -> VaultSyncResult {+ do {+ let serverVault = try await fetchServerVault(using: webApiService)++ // Store with race detection+ let storeResult = try storeEncryptedVaultWithSyncState(+ encryptedVault: serverVault.vault.blob,+ markDirty: false,+ serverRevision: serverRevision,+ expectedMutationSeq: mutationSeqAtStart+ )++ if !storeResult.success {+ // Race detected - retry+ print("[VaultSync] Race detected during download, retrying")+ setIsSyncing(false)+ return await syncVaultWithServer(using: webApiService, retryCount: retryCount + 1)+ }++ // Store vault metadata+ let metadata = VaultMetadata(+ publicEmailDomains: serverVault.vault.publicEmailDomainList,+ privateEmailDomains: serverVault.vault.privateEmailDomainList,+ hiddenPrivateEmailDomains: serverVault.vault.hiddenPrivateEmailDomainList,+ vaultRevisionNumber: serverRevision+ )+ try storeVaultMetadata(metadata)++ // Re-unlock if was unlocked+ if isVaultUnlocked {+ try unlockVault()+ }- return false+ setIsSyncing(false)+ return VaultSyncResult(+ success: true,+ action: .downloaded,+ newRevision: serverRevision,+ wasOffline: false,+ error: nil+ )+ } catch let error as VaultSyncError {+ setIsSyncing(false)+ return handleSyncError(error)+ } catch {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: getOfflineMode(),+ error: error.localizedDescription+ )+ }+ }++ /// Perform upload-only sync (local changes, no server changes)+ private func performUploadSync(+ using webApiService: WebApiService,+ mutationSeqAtStart: Int,+ retryCount: Int+ ) async -> VaultSyncResult {+ do {+ let uploadResult = try await uploadVault(using: webApiService)++ if uploadResult.success {+ // Mark clean if no new mutations during upload+ _ = markVaultClean(mutationSeqAtStart: mutationSeqAtStart, newServerRevision: uploadResult.newRevisionNumber)+ setIsSyncing(false)+ return VaultSyncResult(+ success: true,+ action: .uploaded,+ newRevision: uploadResult.newRevisionNumber,+ wasOffline: false,+ error: nil+ )+ } else if uploadResult.status == 2 {+ // Vault outdated - server moved forward, retry to merge+ print("[VaultSync] Vault outdated during upload, retrying")+ setIsSyncing(false)+ return await syncVaultWithServer(using: webApiService, retryCount: retryCount + 1)+ } else {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: false,+ error: uploadResult.error ?? "Upload failed"+ )+ }+ } catch {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: getOfflineMode(),+ error: error.localizedDescription+ )+ }+ }++ /// Perform merge sync (both local and server have changes)+ private func performMergeSync(+ using webApiService: WebApiService,+ serverRevision: Int,+ mutationSeqAtStart: Int,+ retryCount: Int+ ) async -> VaultSyncResult {+ do {+ let serverVault = try await fetchServerVault(using: webApiService)++ guard let localVault = getEncryptedDatabase() else {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: false,+ error: "No local vault available for merge"+ )+ }++ // Perform LWW merge using Rust core library+ // TODO: Call actual Rust merge function via native bindings+ // For now, we preserve local changes (same as before)+ let mergedVault = try performLWWMerge(localVault: localVault, serverVault: serverVault.vault.blob)++ // Store merged vault with race detection+ let storeResult = try storeEncryptedVaultWithSyncState(+ encryptedVault: mergedVault,+ markDirty: false,+ serverRevision: nil, // Will be updated after upload+ expectedMutationSeq: mutationSeqAtStart+ )++ if !storeResult.success {+ // Race detected - retry+ print("[VaultSync] Race detected during merge, retrying")+ setIsSyncing(false)+ return await syncVaultWithServer(using: webApiService, retryCount: retryCount + 1)+ }++ // Upload merged vault+ let uploadResult = try await uploadVault(using: webApiService)++ if uploadResult.success {+ _ = markVaultClean(mutationSeqAtStart: mutationSeqAtStart, newServerRevision: uploadResult.newRevisionNumber)++ // Re-unlock if was unlocked+ if isVaultUnlocked {+ try unlockVault()+ }++ setIsSyncing(false)+ return VaultSyncResult(+ success: true,+ action: .merged,+ newRevision: uploadResult.newRevisionNumber,+ wasOffline: false,+ error: nil+ )+ } else if uploadResult.status == 2 {+ // Vault outdated again - retry+ print("[VaultSync] Vault outdated after merge, retrying")+ setIsSyncing(false)+ return await syncVaultWithServer(using: webApiService, retryCount: retryCount + 1)+ } else {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: false,+ error: uploadResult.error ?? "Upload after merge failed"+ )+ }+ } catch let error as VaultSyncError {+ setIsSyncing(false)+ return handleSyncError(error)+ } catch {+ setIsSyncing(false)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: getOfflineMode(),+ error: error.localizedDescription+ )+ }+ }++ /// Perform Last-Write-Wins merge between local and server vaults+ /// TODO: Integrate with Rust core library for actual merge logic+ private func performLWWMerge(localVault: String, serverVault: String) throws -> String {+ // TODO: Call Rust core's merge function via Swift bindings+ // For now, preserve local changes (temporary behavior)+ print("[VaultSync] LWW merge not yet implemented - preserving local changes")+ return localVault+ }++ /// Handle sync errors and return appropriate result+ private func handleSyncError(_ error: VaultSyncError) -> VaultSyncResult {+ switch error {+ case .networkError, .serverUnavailable, .timeout:+ setOfflineMode(true)+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: true,+ error: error.message+ )+ case .sessionExpired, .authenticationFailed:+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: false,+ error: error.code+ )+ default:+ return VaultSyncResult(+ success: false,+ action: .error,+ newRevision: getCurrentVaultRevisionNumber(),+ wasOffline: getOfflineMode(),+ error: error.message+ )+ }}// MARK: - Private Helpersdiff --git a/apps/mobile-app/specs/NativeVaultManager.ts b/apps/mobile-app/specs/NativeVaultManager.tsindex c16031485..f29cb7841 100644--- a/apps/mobile-app/specs/NativeVaultManager.ts+++ b/apps/mobile-app/specs/NativeVaultManager.ts@@ -88,20 +88,23 @@ export interface Spec extends TurboModule {// Server version managementisServerVersionGreaterThanOrEqualTo(targetVersion: string): Promise<boolean>;- // Vault sync and mutate- isNewVaultVersionAvailable(): Promise<{ isNewVersionAvailable: boolean; newRevision: number | null }>;- downloadVault(newRevision: number): Promise<boolean>;- mutateVault(): Promise<boolean>;+ // Vault sync - single method handles all sync logic including merge+ // Returns detailed result about what action was taken+ syncVaultWithServer(): Promise<{+ success: boolean;+ action: 'uploaded' | 'downloaded' | 'merged' | 'already_in_sync' | 'error';+ newRevision: number;+ wasOffline: boolean;+ error: string | null;+ }>;- // Sync state management+ // Sync state management (kept for local mutation tracking)getSyncState(): Promise<{isDirty: boolean;mutationSequence: number;serverRevision: number;isSyncing: boolean;}>;- setIsDirty(isDirty: boolean): Promise<void>;- setIsSyncing(isSyncing: boolean): Promise<void>;storeEncryptedVaultWithSyncState(encryptedVault: string,markDirty: boolean,@@ -116,34 +119,6 @@ export interface Spec extends TurboModule {mutationSeqAtStart: number;error: string | null;}>;- fetchServerVault(): Promise<{- status: number;- vault: {- username: string;- blob: string;- version: string;- currentRevisionNumber: number;- encryptionPublicKey: string;- credentialsCount: number;- emailAddressList: string[];- privateEmailDomainList: string[];- hiddenPrivateEmailDomainList: string[];- publicEmailDomainList: string[];- createdAt: string;- updatedAt: string;- };- }>;- checkVaultVersion(): Promise<{- isNewVersionAvailable: boolean;- newRevision: number | null;- serverRevision: number;- syncState: {- isDirty: boolean;- mutationSequence: number;- serverRevision: number;- isSyncing: boolean;- };- }>;// PIN unlock methodsisPinEnabled(): Promise<boolean>;diff --git a/apps/mobile-app/utils/VaultMergeService.ts b/apps/mobile-app/utils/VaultMergeService.tsdeleted file mode 100644index 8931d89cf..000000000--- a/apps/mobile-app/utils/VaultMergeService.ts+++ /dev/null@@ -1,93 +0,0 @@-import NativeVaultManager from '@/specs/NativeVaultManager';--/**- * Statistics about what was merged.- */-export type MergeStats = {- tablesProcessed: number;- recordsFromLocal: number;- recordsFromServer: number;- recordsCreatedLocally: number;- conflicts: number;-}--/**- * Result of a merge operation.- */-export type MergeResult = {- success: boolean;- mergedVaultBase64: string;- stats: MergeStats;-}--/**- * Service for merging two vault SQLite databases using Last-Write-Wins (LWW) strategy.- *- * For mobile apps, the merge logic is delegated to the native layer since it already- * has access to the SQLite database and encryption operations. The native layer- * uses the Rust core library (compiled to Swift bindings for iOS and Kotlin bindings- * for Android) for the actual merge logic.- *- * The merge uses UpdatedAt timestamps on all SyncableEntity records to determine- * which version of a record wins in case of conflict.- *- * Note: In the mobile app, the vault merge happens differently from the browser extension.- * The browser extension uses sql.js (JavaScript SQLite) in the popup, while the mobile app- * delegates to native code which directly manipulates the encrypted SQLite database.- *- * For now, we implement a simplified approach where the native layer handles the merge- * by re-initializing the database with the merged content.- */-export class VaultMergeService {- /**- * Merge local vault changes with server vault using LWW strategy.- *- * For mobile, this currently takes a simplified approach:- * 1. The local and server vaults are both encrypted SQLite blobs- * 2. We need to decrypt both, merge in-memory, and re-encrypt- *- * Since the native layer already has the decryption key and SQLite database,- * the actual merge happens there. This wrapper provides a consistent API.- *- * @param localVaultBase64 - The local vault (with offline changes) as base64 encrypted SQLite- * @param serverVaultBase64 - The server vault (latest version) as base64 encrypted SQLite- * @param encryptionKey - The encryption key to decrypt/encrypt the vaults- * @returns The merged vault as base64 encrypted SQLite- */- static async mergeVaults(- localVaultBase64: string,- serverVaultBase64: string,- encryptionKey: string | null- ): Promise<string> {- /**- * For the mobile app, we use a simpler merge strategy:- * Since the local vault is already loaded in memory by the native layer,- * we can:- * 1. Store the server vault temporarily- * 2. Have the native layer perform the merge- * 3. Return the merged (re-encrypted) vault- *- * However, the current native implementation doesn't have a dedicated merge API.- * For now, we return the local vault (preserving local changes) and log a warning.- *- * TODO: Implement proper LWW merge in native layer using Rust bindings.- * The Rust core library already has the merge logic, we just need to expose it- * through Swift/Kotlin bindings.- */- console.warn(- '[VaultMergeService] Full LWW merge not yet implemented for mobile. ' +- 'Preserving local changes. Server changes may be lost until next sync.'- );-- /**- * Fallback: Return the local vault to preserve local changes.- * The sync mechanism will retry on next app open.- *- * A proper implementation would:- * 1. Decrypt both vaults using the encryption key- * 2. Use Rust core's mergeVaults() function- * 3. Re-encrypt the merged result- */- return localVaultBase64;- }-}