add server status checking

Author: sunwei

src/sync/FridaySyncCore.ts

@@ -607,6 +607,13 @@ export class FridaySyncCore implements LiveSyncLocalDBEnv, LiveSyncCouchDBReplic
     async handleNetworkRecovery(): Promise<void> {
         Logger("Network recovery detected", LOG_LEVEL_INFO);
 
+        // Check current status - if already LIVE, skip recovery
+        const currentStatus = this.replicationStat.value.syncStatus;
+        if (currentStatus === "LIVE") {
+            Logger("Sync already in LIVE state, skipping recovery", LOG_LEVEL_VERBOSE);
+            return;
+        }
+
         // Update network status
         this._managers?.networkManager.setServerReachable(true);
 
@@ -623,10 +630,9 @@ export class FridaySyncCore implements LiveSyncLocalDBEnv, LiveSyncCouchDBReplic
         // Restart sync if configured
         // Check if sync needs to be restarted - only skip if already in LIVE state
         if (this._settings.liveSync && this._replicator) {
-            const status = this.replicationStat.value.syncStatus;
-            // Restart if not in LIVE state (covers PAUSED, CLOSED, ERRORED, NOT_CONNECTED, etc.)
-            if (status !== "LIVE") {
-                Logger(`Restarting sync after network recovery (current status: ${status})`, LOG_LEVEL_INFO);
+            // Only restart if not in LIVE state
+            if (currentStatus !== "LIVE") {
+                Logger(`Restarting sync after network recovery (current status: ${currentStatus})`, LOG_LEVEL_INFO);
                 await this.startSync(true);
             }
         }

src/sync/core/common/messagesJson/en.json

@@ -601,5 +601,8 @@
     "fridaySync.error.cannotConnectServer": "Cannot connect to sync server. Your changes will be saved locally and synced when connection is restored.",
     "fridaySync.error.serverTimeout": "Connection to sync server timed out. Will retry automatically.",
     "fridaySync.status.offlineMode": "Offline mode - changes saved locally",
-    "fridaySync.status.reconnecting": "Reconnecting to sync server..."
+    "fridaySync.status.reconnecting": "Reconnecting to sync server...",
+    "fridaySync.error.noCacheOffline": "First-time setup requires server connection",
+    "fridaySync.error.firstTimeNeedsConnection": "First-time setup requires server connection. Please connect to network and restart sync.",
+    "fridaySync.offline.workingMode": "Working offline - changes will sync when connected"
 }

src/sync/core/common/messagesJson/zh.json

@@ -436,5 +436,8 @@
     "fridaySync.error.cannotConnectServer": "无法连接同步服务器。您的修改将保存在本地，恢复连接后会自动同步。",
     "fridaySync.error.serverTimeout": "连接同步服务器超时。将自动重试。",
     "fridaySync.status.offlineMode": "离线模式 - 修改已保存到本地",
-    "fridaySync.status.reconnecting": "正在重新连接同步服务器..."
+    "fridaySync.status.reconnecting": "正在重新连接同步服务器...",
+    "fridaySync.error.noCacheOffline": "首次使用需要连接服务器",
+    "fridaySync.error.firstTimeNeedsConnection": "首次使用需要连接服务器。请连接网络后重新启动同步。",
+    "fridaySync.offline.workingMode": "离线工作中 - 连接后自动同步"
 }

src/sync/core/replication/couchdb/LiveSyncReplicator.ts

@@ -57,6 +57,7 @@ import {
     SyncParamsUpdateError,
 } from "../SyncParamsHandler.ts";
 import type { ServiceHub } from "../../services/ServiceHub.ts";
+import { arrayBufferToBase64Single, base64ToArrayBufferInternalBrowser } from "../../string_and_binary/convert.ts";
 
 const currentVersionRange: ChunkVersionRange = {
     min: 0,
@@ -203,17 +204,124 @@ export class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
         }
     }
 
+    // Instance-level salt cache (session lifetime)
+    private _saltCache: Uint8Array | null = null;
+    
     override async getReplicationPBKDF2Salt(
         setting: RemoteDBSettings,
-        refresh?: boolean
+        refresh?: boolean = false
     ): Promise<Uint8Array<ArrayBuffer>> {
-        const server = `${setting.couchDB_URI}/${setting.couchDB_DBNAME}`;
-        const manager = createSyncParamsHanderForServer(server, {
-            put: (params: SyncParameters) => this.putSyncParameters(setting, params),
-            get: () => this.getSyncParameters(setting),
-            create: () => this.getInitialSyncParameters(setting),
-        });
-        return await manager.getPBKDF2Salt(refresh);
+        
+        // ========== Step 1: Check instance cache ==========
+        // Fast path: return cached salt if available and not forcing refresh
+        if (this._saltCache && !refresh) {
+            Logger("Using session salt cache", LOG_LEVEL_VERBOSE);
+            return this._saltCache;
+        }
+        
+        // ========== Step 2: Check server reachability ==========
+        const serverReachable = this.env.isServerReachable?.() ?? true;
+        
+        if (!serverReachable) {
+            // 🔑 Server unreachable: try local persistent cache
+            // CRITICAL: Do NOT call manager.getPBKDF2Salt() to avoid _fetchSyncParameters
+            Logger("Server unreachable, trying local salt cache", LOG_LEVEL_VERBOSE);
+            
+            const cachedSalt = await this.getLocalCachedSalt(setting.couchDB_DBNAME);
+            
+            if (cachedSalt) {
+                Logger("Using local salt cache (offline mode)", LOG_LEVEL_INFO);
+                this._saltCache = cachedSalt;  // Update session cache
+                return cachedSalt;
+            }
+            
+            // No cache available - cannot proceed offline
+            Logger("No salt cache available for offline mode", LOG_LEVEL_INFO);
+            throw new Error(
+                $msg("fridaySync.error.noCacheOffline") ||
+                "First-time setup requires server connection"
+            );
+        }
+        
+        // ========== Step 3: Server reachable - fetch normally ==========
+        try {
+            const server = `${setting.couchDB_URI}/${setting.couchDB_DBNAME}`;
+            const manager = createSyncParamsHanderForServer(server, {
+                put: (params: SyncParameters) => this.putSyncParameters(setting, params),
+                get: () => this.getSyncParameters(setting),
+                create: () => this.getInitialSyncParameters(setting),
+            });
+            
+            // Fetch from server via SyncParamsHandler
+            const salt = await manager.getPBKDF2Salt(refresh);
+            
+            // ✅ Success: update both caches
+            this._saltCache = salt;  // Session cache
+            await this.saveLocalSaltCache(setting.couchDB_DBNAME, salt);  // Persistent cache
+            
+            Logger("Salt fetched from server and cached", LOG_LEVEL_VERBOSE);
+            return salt;
+            
+        } catch (ex) {
+            // Server fetch failed - try fallback to local cache
+            Logger(`Failed to fetch salt from server: ${ex}`, LOG_LEVEL_VERBOSE);
+            
+            const cachedSalt = await this.getLocalCachedSalt(setting.couchDB_DBNAME);
+            
+            if (cachedSalt) {
+                Logger("Falling back to local salt cache", LOG_LEVEL_INFO);
+                this._saltCache = cachedSalt;
+                return cachedSalt;
+            }
+            
+            // Real failure - no server and no cache
+            Logger("No salt available (server failed and no cache)", LOG_LEVEL_INFO);
+            throw ex;
+        }
+    }
+    
+    /**
+     * Save salt to local persistent cache (reuses existing "friday-sync-salt" store)
+     */
+    private async saveLocalSaltCache(
+        dbName: string,
+        salt: Uint8Array
+    ): Promise<void> {
+        try {
+            const saltKey = this._getKnownSaltKey(dbName);
+            const saltStore = this.env.services.database.openSimpleStore<string>("friday-sync-salt");
+            const saltBase64 = await arrayBufferToBase64Single(salt);
+            await saltStore.set(saltKey, saltBase64);
+            Logger("Salt saved to local cache", LOG_LEVEL_VERBOSE);
+        } catch (ex) {
+            Logger(`Failed to save salt cache: ${ex}`, LOG_LEVEL_VERBOSE);
+            // Non-critical error, don't throw
+        }
+    }
+    
+    /**
+     * Get salt from local persistent cache (reuses existing "friday-sync-salt" store)
+     */
+    private async getLocalCachedSalt(
+        dbName: string
+    ): Promise<Uint8Array | null> {
+        try {
+            const saltKey = this._getKnownSaltKey(dbName);
+            const saltStore = this.env.services.database.openSimpleStore<string>("friday-sync-salt");
+            const saltBase64 = await saltStore.get(saltKey);
+            
+            if (saltBase64) {
+                const salt = new Uint8Array(base64ToArrayBufferInternalBrowser(saltBase64));
+                Logger("Local salt cache found", LOG_LEVEL_VERBOSE);
+                return salt;
+            }
+            
+            Logger("No local salt cache found", LOG_LEVEL_VERBOSE);
+            return null;
+        } catch (ex) {
+            Logger(`Failed to read salt cache: ${ex}`, LOG_LEVEL_VERBOSE);
+            return null;
+        }
     }
 
     // eslint-disable-next-line require-await

src/sync/features/NetworkEvents/index.ts

@@ -75,7 +75,17 @@ export class FridayNetworkEvents {
         Logger(`Network status changed: ${isOnline ? "online" : "offline"}`, LOG_LEVEL_INFO);
 
         if (isOnline) {
+            // Check current sync status before attempting recovery
+            const currentStatus = this.core.replicationStat.value.syncStatus;
+            
+            if (currentStatus === "LIVE") {
+                // Already in LIVE state, no need to reconnect
+                Logger("Network online but sync already active", LOG_LEVEL_VERBOSE);
+                return;
+            }
+            
             // Network recovered - trigger reconnection
+            Logger("Network recovered, attempting reconnection", LOG_LEVEL_INFO);
             await this.core.handleNetworkRecovery();
         } else {
             // Network lost - update status
@@ -121,9 +131,31 @@ export class FridayNetworkEvents {
         } else {
             // Window visible again
             if (!this.hasFocus) return;
-            Logger("Window visible, checking for sync updates", LOG_LEVEL_VERBOSE);
-            // Trigger a sync check on resume
-            await this.core.handleNetworkRecovery();
+            
+            // Check current sync status - only reconnect if needed
+            const currentStatus = this.core.replicationStat.value.syncStatus;
+            
+            // If already in LIVE state, no need to reconnect
+            if (currentStatus === "LIVE") {
+                Logger("Window visible, sync already active", LOG_LEVEL_VERBOSE);
+                return;
+            }
+            
+            // If status is NOT_CONNECTED or ERRORED, attempt recovery
+            if (currentStatus === "NOT_CONNECTED" || currentStatus === "ERRORED") {
+                Logger("Window visible, checking for sync recovery", LOG_LEVEL_VERBOSE);
+                
+                // Avoid duplicate reconnection attempts if already scheduled
+                if (this.core.connectionMonitor?.isReconnectScheduled()) {
+                    Logger("Reconnect already scheduled, skipping duplicate attempt", LOG_LEVEL_VERBOSE);
+                    return;
+                }
+                
+                await this.core.handleNetworkRecovery();
+            } else {
+                // Other states (STARTED, PAUSED, CLOSED), just log
+                Logger(`Window visible, current status: ${currentStatus}`, LOG_LEVEL_VERBOSE);
+            }
         }
     }