Skip to content

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.kt
index 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 dialog
withContext(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 dialog
withContext(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.kt
index 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.kt
index 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.kt
index 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 Methods
diff --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.kt
index 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.ts
index 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 connection
try {
@@ -254,7 +143,7 @@ export const useVaultSync = (): {
return false;
}
- onSuccess?.(isNewVersionAvailable);
+ onSuccess?.(hasNewVault);
// Register credential identities after sync
try {
@@ -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 errors
if (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.swift
index 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 passkey
viewModel.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 failed
viewModel.setLoading(false)
// Show appropriate error dialog based on error type
await 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.mm
index 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.swift
index 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)
- }
-
@objc
func 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)
- }
- }
- }
- }
- }
-
@objc
func requiresMainQueueSetup() -> Bool {
return false
diff --git a/apps/mobile-app/ios/VaultStoreKit/VaultStore+Sync.swift b/apps/mobile-app/ios/VaultStoreKit/VaultStore+Sync.swift
index 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 operations
extension 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 Helpers
diff --git a/apps/mobile-app/specs/NativeVaultManager.ts b/apps/mobile-app/specs/NativeVaultManager.ts
index 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 management
isServerVersionGreaterThanOrEqualTo(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 methods
isPinEnabled(): Promise<boolean>;
diff --git a/apps/mobile-app/utils/VaultMergeService.ts b/apps/mobile-app/utils/VaultMergeService.ts
deleted file mode 100644
index 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;
- }
-}