favalib 0.0.1 → 0.0.3

package/build/TwoFaLib.d.mts

@@ -72,8 +72,9 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
     /**
      * Sets a server url, this will allow syncing with the server.
      * @param serverUrl - The server url.
+     * @param force - Force setting the sync server url, even if no connection can be made
      */
-    setSyncServerUrl(serverUrl: string): Promise<void>;
+    setSyncServerUrl(serverUrl: string, force?: boolean): Promise<void>;
     /**
      * Sets the sync state, this will initiate the sync manager instance.
      * @param syncState - The state of the sync.

package/build/TwoFaLib.mjs

@@ -1,8 +1,8 @@
 import { TypedEventTarget } from 'typescript-event-target';
 import TwoFaLibMediator from './TwoFaLibMediator.mjs';
 import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
-import { InitializationError } from './TwoFALibError.mjs';
-import SyncManager from './subclasses/SyncManager.mjs';
+import { InitializationError, SyncError } from './TwoFALibError.mjs';
+import SyncManager, { ConnectionStatus } from './subclasses/SyncManager.mjs';
 import LibraryLoader from './subclasses/LibraryLoader.mjs';
 import ExportImportManager from './subclasses/ExportImportManager.mjs';
 import PersistentStorageManager from './subclasses/PersistentStorageManager.mjs';
@@ -139,18 +139,45 @@ class TwoFaLib extends TypedEventTarget {
     /**
      * Sets a server url, this will allow syncing with the server.
      * @param serverUrl - The server url.
+     * @param force - Force setting the sync server url, even if no connection can be made
      */
-    async setSyncServerUrl(serverUrl) {
+    async setSyncServerUrl(serverUrl, force = false) {
         if (this.sync) {
+            // close connection so no data is send to the old syncServer
             this.sync.closeServerConnection();
-            this.mediator.unRegisterComponent('syncManager');
         }
         const newSyncState = {
             serverUrl,
             devices: [],
             commandSendQueue: [],
         };
-        this.setSyncState(newSyncState);
+        const newSyncManager = new SyncManager(this.mediator, this.deviceType, this.publicKey, this.privateKey, newSyncState, this.deviceId);
+        const success = await new Promise((resolve) => {
+            this.addEventListener(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, (event) => {
+                if (event.detail.newStatus === ConnectionStatus.CONNECTED) {
+                    resolve(true);
+                }
+                if (event.detail.newStatus === ConnectionStatus.FAILED) {
+                    resolve(false);
+                }
+            });
+        });
+        if (!success) {
+            if (force) {
+                this.log('warning', `Failed to connect to server at ${serverUrl}, force setting`);
+            }
+            else {
+                if (this.sync) {
+                    // re-establish old connection
+                    this.sync.initServerConnection();
+                }
+                newSyncManager.closeServerConnection();
+                throw new SyncError(`Failed to connect to server at ${serverUrl}, not setting`);
+            }
+        }
+        // connection succeeded (or force=true), switch to the new syncManager
+        this.mediator.unRegisterComponent('syncManager');
+        this.mediator.registerComponent('syncManager', newSyncManager);
         await this.forceSave();
     }
     /**

package/build/interfaces/Events.d.mts

@@ -1,6 +1,7 @@
 import type { EmptyObject } from 'type-fest';
 import type { TwoFaLibEvent } from '../TwoFaLibEvent.mjs';
 import type { LockedRepresentationString } from './Vault.mjs';
+import type { ConnectionStatus } from '../subclasses/SyncManager.mjs';
 export interface ChangedEvent {
     newLockedRepresentationString: LockedRepresentationString;
 }
@@ -9,7 +10,7 @@ export interface TwoFaLibEventMap {
     [TwoFaLibEvent.LoadedFromLockedRepresentation]: EmptyObject;
     [TwoFaLibEvent.ConnectToExistingVaultFinished]: EmptyObject;
     [TwoFaLibEvent.ConnectionToSyncServerStatusChanged]: {
-        connected: boolean;
+        newStatus: ConnectionStatus;
     };
     [TwoFaLibEvent.Log]: {
         severity: 'info' | 'warning';

package/build/subclasses/SyncManager.d.mts

@@ -6,6 +6,12 @@ import { VaultSyncStateWithServerUrl } from '../interfaces/Vault.mjs';
 import { SyncCommandFromServer } from 'favaserver/ServerMessage';
 import { SyncCommandFromClient } from 'favaserver/ClientMessage';
 import type { AddSyncDeviceData } from '../Command/commands/AddSyncDeviceCommand.mjs';
+export declare enum ConnectionStatus {
+    CONNECTING = 0,
+    CONNECTED = 1,
+    NOT_CONNECTED = 2,
+    FAILED = 3
+}
 /**
  * Manages synchronization of 2FA devices and communication with the server.
  */
@@ -23,6 +29,7 @@ declare class SyncManager {
     private readyEventEmitted;
     private commandSendQueue;
     private reconnectTimeout?;
+    private terminateTimeout?;
     private shouldReconnect;
     /**
      * Public getter for the command send queue.

package/build/subclasses/SyncManager.mjs

@@ -7,6 +7,13 @@ import { InitializationError, SyncAddDeviceFlowConflictError, SyncError, SyncInW
 import AddSyncDeviceCommand from '../Command/commands/AddSyncDeviceCommand.mjs';
 const IN_TESTING = process.env.NODE_ENV === 'test';
 const IN_DEV = process.env.NODE_ENV === 'development';
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus[ConnectionStatus["CONNECTING"] = 0] = "CONNECTING";
+    ConnectionStatus[ConnectionStatus["CONNECTED"] = 1] = "CONNECTED";
+    ConnectionStatus[ConnectionStatus["NOT_CONNECTED"] = 2] = "NOT_CONNECTED";
+    ConnectionStatus[ConnectionStatus["FAILED"] = 3] = "FAILED";
+})(ConnectionStatus || (ConnectionStatus = {}));
 const generateNonCryptographicRandomString = () => {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     const length = Math.floor(Math.random() * 64) + 1;
@@ -53,6 +60,16 @@ class SyncManager {
         this.commandSendQueue = commandSendQueue;
         this.serverUrl = serverUrl;
         this.initServerConnection();
+        // if not yet connected after 2 tries, emit ready event so we can continue
+        setTimeout(() => {
+            if (!this.readyEventEmitted && !this.webSocketConnected) {
+                this.log('warning', 'Failed to connect to sync backend');
+                this.dispatchLibEvent(TwoFaLibEvent.Ready);
+                this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
+                    newStatus: ConnectionStatus.FAILED,
+                });
+            }
+        }, this.reconnectInterval + 1000);
     }
     get libraryLoader() {
         return this.mediator.getComponent('libraryLoader');
@@ -123,7 +140,7 @@ class SyncManager {
             this.log('info', 'Connected to server.');
             this.sendToServer('connect', { deviceId: syncManager.deviceId });
             this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
-                connected: true,
+                newStatus: ConnectionStatus.CONNECTED,
             });
             // send any commands that were done while offline
             void this.processCommandSendQueue();
@@ -132,14 +149,23 @@ class SyncManager {
         this.ws = ws;
     }
     handleWebSocketClose(event) {
-        this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
-            connected: false,
-        });
         if (this.shouldReconnect) {
+            this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
+                newStatus: ConnectionStatus.CONNECTING,
+            });
             // if we shouldn't reconnect, this closing is expected
             this.log('warning', `WebSocket closed: ${event.code} ${event.reason}`);
             this.attemptReconnect();
         }
+        else {
+            this.dispatchLibEvent(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, {
+                newStatus: ConnectionStatus.NOT_CONNECTED,
+            });
+            // Connection closed, no need to force terminate
+            if (this.terminateTimeout) {
+                clearTimeout(this.terminateTimeout);
+            }
+        }
     }
     handleServerMessage(message) {
         switch (message.type) {
@@ -558,9 +584,9 @@ class SyncManager {
             const ws = this.ws;
             this.ws = undefined;
             ws.close();
-            // force terminate the connection after 5 seconds
+            // force terminate the connection after 2 seconds
             // ws.terminate is not defined in the test enviroment, which is the reason for the &&
-            setTimeout(() => ws.terminate && ws.terminate(), 5000);
+            this.terminateTimeout = setTimeout(() => ws.terminate && ws.terminate(), 2000);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favalib",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "",
   "type": "module",
   "exports": {
@@ -52,5 +52,8 @@
     "vitest-websocket-mock": "^0.4.0",
     "whatwg-url": "^14.0.0",
     "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=20"
   }
 }