favalib 0.0.8 → 0.0.10

package/build/Command/commandConstructors.d.mts

@@ -2,12 +2,12 @@ import AddEntryCommand from './commands/AddEntryCommand.mjs';
 import AddSyncDeviceCommand from './commands/AddSyncDeviceCommand.mjs';
 import DeleteEntryCommand from './commands/DeleteEntryCommand.mjs';
 import UpdateEntryCommand from './commands/UpdateEntryCommand.mjs';
-import ChangeSyncDeviceMetaCommand from './commands/ChangeSyncDeviceMetaCommand.mjs';
+import ChangeSyncDeviceInfoCommand from './commands/ChangeDeviceInfoCommand.mjs';
 declare const commandConstructors: {
     AddEntry: typeof AddEntryCommand;
     DeleteEntry: typeof DeleteEntryCommand;
     UpdateEntry: typeof UpdateEntryCommand;
     AddSyncDevice: typeof AddSyncDeviceCommand;
-    ChangeSyncDeviceMeta: typeof ChangeSyncDeviceMetaCommand;
+    ChangeSyncDeviceInfo: typeof ChangeSyncDeviceInfoCommand;
 };
 export default commandConstructors;

package/build/Command/commandConstructors.mjs

@@ -2,12 +2,12 @@ import AddEntryCommand from './commands/AddEntryCommand.mjs';
 import AddSyncDeviceCommand from './commands/AddSyncDeviceCommand.mjs';
 import DeleteEntryCommand from './commands/DeleteEntryCommand.mjs';
 import UpdateEntryCommand from './commands/UpdateEntryCommand.mjs';
-import ChangeSyncDeviceMetaCommand from './commands/ChangeSyncDeviceMetaCommand.mjs';
+import ChangeSyncDeviceInfoCommand from './commands/ChangeDeviceInfoCommand.mjs';
 const commandConstructors = {
     AddEntry: AddEntryCommand,
     DeleteEntry: DeleteEntryCommand,
     UpdateEntry: UpdateEntryCommand,
     AddSyncDevice: AddSyncDeviceCommand,
-    ChangeSyncDeviceMeta: ChangeSyncDeviceMetaCommand,
+    ChangeSyncDeviceInfo: ChangeSyncDeviceInfoCommand,
 };
 export default commandConstructors;

package/build/Command/commands/AddSyncDeviceCommand.d.mts

@@ -1,10 +1,11 @@
 import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
 import Command from '../BaseCommand.mjs';
-import type { DeviceId } from '../../interfaces/SyncTypes.mjs';
+import type { DeviceId, DeviceInfo } from '../../interfaces/SyncTypes.mjs';
 import type { PublicKey } from '../../interfaces/CryptoLib.mjs';
 export interface AddSyncDeviceData {
     deviceId: DeviceId;
     publicKey: PublicKey;
+    deviceInfo: DeviceInfo;
 }
 /**
  * Represents a command that when executed add an entry to the vault.

package/build/Command/commands/{ChangeSyncDeviceMetaCommand.d.mts → ChangeDeviceInfoCommand.d.mts}

@@ -1,25 +1,25 @@
 import type TwoFaLibMediator from '../../TwoFaLibMediator.mjs';
 import Command from '../BaseCommand.mjs';
 import type { DeviceFriendlyName, DeviceId, DeviceType } from '../../interfaces/SyncTypes.mjs';
-export interface ChangeSyncDeviceMetaData {
+export interface ChangeSyncDeviceInfoData {
     deviceId: DeviceId;
-    newMeta: {
-        deviceFriendlyName: DeviceFriendlyName;
+    newDeviceInfo: {
+        deviceFriendlyName?: DeviceFriendlyName;
         deviceType: DeviceType;
     };
 }
 /**
- * Represents a command that when executed changes the meta info of a sync device
+ * Represents a command that when executed changes the device info of a sync device
  */
-declare class ChangeSyncDeviceMetaCommand extends Command<ChangeSyncDeviceMetaData> {
+declare class ChangeDeviceInfoCommand extends Command<ChangeSyncDeviceInfoData> {
     /**
      * Creates a new ChangeSyncDeviceMetaCommand instance.
      * @inheritdoc
      * @param data - The id of the device to change and the new meta info
      */
-    constructor(data: ChangeSyncDeviceMetaData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
+    constructor(data: ChangeSyncDeviceInfoData, id?: string, timestamp?: number, version?: string, fromRemote?: boolean);
     /**
-     * Executes the command to change the sync device metadata
+     * Executes the command to change the sync device info
      * @inheritdoc
      * @throws {InvalidCommandError} If the referenced sync device cannot be found
      */
@@ -28,5 +28,10 @@ declare class ChangeSyncDeviceMetaCommand extends Command<ChangeSyncDeviceMetaDa
      * @inheritdoc
      */
     createUndoCommand(): Command;
+    /**
+     * Validates the command data.
+     * @inheritdoc
+     */
+    validate(mediator: TwoFaLibMediator): boolean;
 }
-export default ChangeSyncDeviceMetaCommand;
+export default ChangeDeviceInfoCommand;

package/build/Command/commands/ChangeDeviceInfoCommand.mjs

@@ -0,0 +1,78 @@
+import { InvalidCommandError, TwoFALibError } from '../../TwoFALibError.mjs';
+import Command from '../BaseCommand.mjs';
+/**
+ * Represents a command that when executed changes the device info of a sync device
+ */
+class ChangeDeviceInfoCommand extends Command {
+    /**
+     * Creates a new ChangeSyncDeviceMetaCommand instance.
+     * @inheritdoc
+     * @param data - The id of the device to change and the new meta info
+     */
+    constructor(data, id, timestamp, version, fromRemote = false) {
+        super('ChangeDeviceInfo', data, id, timestamp, version, fromRemote);
+    }
+    /**
+     * Executes the command to change the sync device info
+     * @inheritdoc
+     * @throws {InvalidCommandError} If the referenced sync device cannot be found
+     */
+    async execute(mediator) {
+        if (!this.validate(mediator)) {
+            throw new InvalidCommandError('Failed to validate ChangeDeviceInfo command');
+        }
+        const lib = mediator.getComponent('lib');
+        if (this.data.deviceId === lib.meta.deviceId) {
+            // we're changing our own friendly name
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            lib['favaMeta'].deviceFriendlyName =
+                this.data.newDeviceInfo.deviceFriendlyName;
+        }
+        const syncManager = mediator.getComponent('syncManager');
+        if (syncManager) {
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            const device = syncManager['syncDevices'].find((d) => d.deviceId === this.data.deviceId);
+            if (!device) {
+                throw new InvalidCommandError('Trying to change info of device that is not found');
+            }
+            device.deviceInfo = this.data.newDeviceInfo;
+        }
+        await mediator.getComponent('persistentStorageManager').save();
+    }
+    /**
+     * @inheritdoc
+     */
+    createUndoCommand() {
+        throw new TwoFALibError('Not implemented yet');
+    }
+    /**
+     * Validates the command data.
+     * @inheritdoc
+     */
+    validate(mediator) {
+        const lib = mediator.getComponent('lib');
+        if (this.fromRemote) {
+            // we can only validate this command locally
+            return true;
+        }
+        if (this.data.deviceId !== lib.meta.deviceId) {
+            // device ids are not identical
+            return false;
+        }
+        if (this.data.newDeviceInfo.deviceType !== lib.meta.deviceType) {
+            // Changing device type
+            return false;
+        }
+        const deviceFriendlyName = this.data.newDeviceInfo.deviceFriendlyName;
+        if (deviceFriendlyName !== undefined) {
+            if (deviceFriendlyName.length > 256) {
+                return false;
+            }
+            if (deviceFriendlyName.length < 1) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+export default ChangeDeviceInfoCommand;

package/build/CryptoProviders/browser/index.d.mts

@@ -14,7 +14,7 @@ declare class BrowserCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    getRandomBytes(count: number): Promise<Uint8Array>;
+    getRandomBytes(count: number): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * @inheritdoc
      */

package/build/CryptoProviders/node/index.d.mts

@@ -7,7 +7,7 @@ declare class NodeCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    getRandomBytes(count: number): Promise<Uint8Array>;
+    getRandomBytes(count: number): Promise<Uint8Array<ArrayBufferLike>>;
     /**
      * @inheritdoc
      */

package/build/TwoFaLib.d.mts

@@ -1,27 +1,36 @@
 import { TypedEventTarget } from 'typescript-event-target';
 import type CryptoLib from './interfaces/CryptoLib.mjs';
 import type { EncryptedPrivateKey, EncryptedSymmetricKey, PrivateKey, PublicKey, Salt, SymmetricKey } from './interfaces/CryptoLib.mjs';
-import type { DeviceFriendlyName, DeviceId, DeviceType } from './interfaces/SyncTypes.mjs';
+import type { DeviceFriendlyName, DeviceType } from './interfaces/SyncTypes.mjs';
 import type { TwoFaLibEventMapEvents } from './interfaces/Events.mjs';
 import type { PassphraseExtraDict } from './interfaces/PassphraseExtraDict.js';
 import type { Vault, VaultSyncState } from './interfaces/Vault.mjs';
+import type { SaveFunction } from './interfaces/SaveFunction.mjs';
+import type { FavaMeta } from './interfaces/FavaMeta.mjs';
 import SyncManager from './subclasses/SyncManager.mjs';
 import ExportImportManager from './subclasses/ExportImportManager.mjs';
 import VaultOperationsManager from './subclasses/VaultOperationsManager.mjs';
-import SaveFunction from './interfaces/SaveFunction.mjs';
 import StorageOperationsManager from './subclasses/StorageOperationsManager.mjs';
 /**
  * The Two-Factor Library, this is the main entry point.
  */
 declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
     static readonly version = "0.0.1";
-    readonly deviceId: DeviceId;
+    private readonly favaMeta;
     readonly deviceType: DeviceType;
-    deviceFriendlyName: DeviceFriendlyName;
+    deviceFriendlyName?: DeviceFriendlyName;
     private mediator;
     private readonly publicKey;
     private readonly privateKey;
     readonly ready: Promise<unknown>;
+    /**
+     * @returns The meta info for this device.
+     */
+    get meta(): {
+        deviceId: import("./interfaces/SyncTypes.mjs").DeviceId;
+        deviceFriendlyName: string | DeviceFriendlyName;
+        deviceType: DeviceType;
+    };
     /**
      * Constructs a new instance of TwoFaLib. If a serverUrl is provided, the library will use it for its sync operations.
      * @param deviceType - The identifier for this device type (e.g. 2fa-cli).
@@ -33,7 +42,7 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @param encryptedSymmetricKey - The encrypted symmetric key
      * @param salt - The salt used for key derivation.
      * @param publicKey - The public key of the device.
-     * @param deviceId - A unique identifier for this device.
+     * @param favaMeta - Meta info about this device containing at least a unique identifier for this device.
      * @param vault - The vault data (entries)
      * @param saveFunction - The function to save the data.
      * @param syncState - The state of the sync, includes the serverUrl
@@ -41,7 +50,7 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @throws {InitializationError} If some parameter has an invalid value
      * @throws {AuthenticationError} If the provided passphrase is incorrect.
      */
-    constructor(deviceType: DeviceType, cryptoLib: CryptoLib, passphraseExtraDict: PassphraseExtraDict, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, publicKey: PublicKey, deviceId: DeviceId, vault?: Vault, saveFunction?: SaveFunction, syncState?: VaultSyncState);
+    constructor(deviceType: DeviceType, cryptoLib: CryptoLib, passphraseExtraDict: PassphraseExtraDict, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, publicKey: PublicKey, favaMeta: FavaMeta, vault?: Vault, saveFunction?: SaveFunction, syncState?: VaultSyncState);
     /**
      * @returns The persistent storage manager instance which can be used to store data.
      */
@@ -72,6 +81,11 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @param force - Force setting the sync server url, even if no connection can be made
      */
     setSyncServerUrl(serverUrl: string, force?: boolean): Promise<void>;
+    /**
+     * Set a friendly name for this vault (used in syncing)
+     * @param deviceFriendlyName Human readable name for the device
+     */
+    setDeviceFriendlyName(deviceFriendlyName: DeviceFriendlyName): Promise<void>;
     /**
      * Dispatches a library event.
      * @param eventType - The type of the event to dispatch, uses the TwoFaLibEvent enum.

package/build/TwoFaLib.mjs

@@ -1,7 +1,7 @@
 import { TypedEventTarget } from 'typescript-event-target';
 import TwoFaLibMediator from './TwoFaLibMediator.mjs';
 import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
-import { InitializationError, SyncError } from './TwoFALibError.mjs';
+import { InitializationError, SyncError, TwoFALibError, } from './TwoFALibError.mjs';
 import SyncManager, { ConnectionStatus } from './subclasses/SyncManager.mjs';
 import LibraryLoader from './subclasses/LibraryLoader.mjs';
 import ExportImportManager from './subclasses/ExportImportManager.mjs';
@@ -10,12 +10,23 @@ import VaultDataManager from './subclasses/VaultDataManager.mjs';
 import VaultOperationsManager from './subclasses/VaultOperationsManager.mjs';
 import CommandManager from './subclasses/CommandManager.mjs';
 import StorageOperationsManager from './subclasses/StorageOperationsManager.mjs';
+import ChangeDeviceInfoCommand from './Command/commands/ChangeDeviceInfoCommand.mjs';
 /**
  * The Two-Factor Library, this is the main entry point.
  */
 class TwoFaLib extends TypedEventTarget {
     // TOOD: load this from package.json
     static { this.version = '0.0.1'; }
+    /**
+     * @returns The meta info for this device.
+     */
+    get meta() {
+        return {
+            deviceId: this.favaMeta.deviceId,
+            deviceFriendlyName: this.deviceFriendlyName ?? '',
+            deviceType: this.deviceType,
+        };
+    }
     /**
      * Constructs a new instance of TwoFaLib. If a serverUrl is provided, the library will use it for its sync operations.
      * @param deviceType - The identifier for this device type (e.g. 2fa-cli).
@@ -27,7 +38,7 @@ class TwoFaLib extends TypedEventTarget {
      * @param encryptedSymmetricKey - The encrypted symmetric key
      * @param salt - The salt used for key derivation.
      * @param publicKey - The public key of the device.
-     * @param deviceId - A unique identifier for this device.
+     * @param favaMeta - Meta info about this device containing at least a unique identifier for this device.
      * @param vault - The vault data (entries)
      * @param saveFunction - The function to save the data.
      * @param syncState - The state of the sync, includes the serverUrl
@@ -35,23 +46,26 @@ class TwoFaLib extends TypedEventTarget {
      * @throws {InitializationError} If some parameter has an invalid value
      * @throws {AuthenticationError} If the provided passphrase is incorrect.
      */
-    constructor(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, vault, saveFunction, syncState) {
+    constructor(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, favaMeta, vault, saveFunction, syncState) {
         super();
-        this.deviceFriendlyName = '';
         if (!deviceType) {
             throw new InitializationError('Device type is required');
         }
-        if (!deviceId) {
+        if (!favaMeta.deviceId) {
             throw new InitializationError('Device id is required');
         }
         if (deviceType.length > 256) {
             throw new InitializationError('Device type is too long, max 256 characters');
         }
+        if (favaMeta.deviceFriendlyName &&
+            favaMeta.deviceFriendlyName.length > 256) {
+            throw new InitializationError('Device friendly name is too long, max 256 characters');
+        }
         if (passphraseExtraDict?.length === 0) {
             throw new InitializationError('Passphrase extra dictionary is required and must contain at least one element (eg phone)');
         }
+        this.favaMeta = favaMeta;
         this.deviceType = deviceType;
-        this.deviceId = deviceId;
         this.publicKey = publicKey;
         this.privateKey = privateKey;
         this.mediator = new TwoFaLibMediator();
@@ -59,7 +73,7 @@ class TwoFaLib extends TypedEventTarget {
             ['libraryLoader', new LibraryLoader(cryptoLib)],
             [
                 'persistentStorageManager',
-                new PersistentStorageManager(this.mediator, passphraseExtraDict, deviceId, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction),
+                new PersistentStorageManager(this.mediator, passphraseExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction),
             ],
             ['vaultDataManager', new VaultDataManager(this.mediator)],
             ['commandManager', new CommandManager(this.mediator)],
@@ -71,13 +85,14 @@ class TwoFaLib extends TypedEventTarget {
             ],
             ['dispatchLibEvent', this.dispatchLibEvent.bind(this)],
             ['log', this.log.bind(this)],
+            ['lib', this],
         ]);
         if (vault) {
             this.mediator.getComponent('vaultDataManager').replaceVault(vault);
         }
         if (syncState?.serverUrl) {
             // Initiate the syncManager
-            this.mediator.registerComponent('syncManager', new SyncManager(this.mediator, this.publicKey, this.privateKey, syncState, this.deviceId));
+            this.mediator.registerComponent('syncManager', new SyncManager(this.mediator, this.publicKey, this.privateKey, this.favaMeta, syncState, this.deviceType));
         }
         else {
             // If no syncmanager we're ready now, otherwise the syncmanager is responsible for emitting the ready event
@@ -147,7 +162,7 @@ class TwoFaLib extends TypedEventTarget {
             devices: [],
             commandSendQueue: [],
         };
-        const newSyncManager = new SyncManager(this.mediator, this.publicKey, this.privateKey, newSyncState, this.deviceId);
+        const newSyncManager = new SyncManager(this.mediator, this.publicKey, this.privateKey, this.favaMeta, newSyncState, this.deviceType);
         const success = await new Promise((resolve) => {
             this.addEventListener(TwoFaLibEvent.ConnectionToSyncServerStatusChanged, (event) => {
                 if (event.detail.newStatus === ConnectionStatus.CONNECTED) {
@@ -178,6 +193,21 @@ class TwoFaLib extends TypedEventTarget {
         // save
         await this.persistentStorageManager.save();
     }
+    /**
+     * Set a friendly name for this vault (used in syncing)
+     * @param deviceFriendlyName Human readable name for the device
+     */
+    async setDeviceFriendlyName(deviceFriendlyName) {
+        const data = {
+            deviceId: this.favaMeta.deviceId,
+            newDeviceInfo: { deviceType: this.deviceType, deviceFriendlyName },
+        };
+        const command = ChangeDeviceInfoCommand.create(data);
+        if (!command.validate(this.mediator)) {
+            throw new TwoFALibError('Device friendly name has invalid length, max 256 characters');
+        }
+        await this.mediator.getComponent('commandManager').execute(command);
+    }
     /**
      * Dispatches a library event.
      * @param eventType - The type of the event to dispatch, uses the TwoFaLibEvent enum.

package/build/interfaces/CommandTypes.d.mts

@@ -2,7 +2,7 @@ import type { AddEntryData } from '../Command/commands/AddEntryCommand.mjs';
 import type { DeleteEntryData } from '../Command/commands/DeleteEntryCommand.mjs';
 import type { UpdateEntryData } from '../Command/commands/UpdateEntryCommand.mjs';
 import type { AddSyncDeviceData } from '../Command/commands/AddSyncDeviceCommand.mjs';
-import type { ChangeSyncDeviceMetaData } from '../Command/commands/ChangeSyncDeviceMetaCommand.mjs';
+import type { ChangeSyncDeviceInfoData } from '../Command/commands/ChangeDeviceInfoCommand.mjs';
 export type SyncCommand = ({
     type: 'AddEntry';
     data: AddEntryData;
@@ -16,9 +16,9 @@ export type SyncCommand = ({
     type: 'AddSyncDevice';
     data: AddSyncDeviceData;
 } | {
-    type: 'ChangeSyncDeviceMeta';
-    data: ChangeSyncDeviceMetaData;
+    type: 'ChangeSyncDeviceInfo';
+    data: ChangeSyncDeviceInfoData;
 }) & {
     id: string;
 };
-export type CommandData = AddEntryData | DeleteEntryData | UpdateEntryData | AddSyncDeviceData | ChangeSyncDeviceMetaData;
+export type CommandData = AddEntryData | DeleteEntryData | UpdateEntryData | AddSyncDeviceData | ChangeSyncDeviceInfoData;

package/build/interfaces/FavaMeta.d.mts

@@ -0,0 +1,5 @@
+import type { DeviceFriendlyName, DeviceId } from './SyncTypes.mjs';
+export interface FavaMeta {
+    deviceId: DeviceId;
+    deviceFriendlyName?: DeviceFriendlyName;
+}

package/build/interfaces/FavaMeta.mjs

@@ -0,0 +1 @@
+export {};

package/build/interfaces/SaveFunction.d.mts

@@ -1,3 +1,2 @@
 import type { LockedRepresentationString } from './Vault.mjs';
-type SaveFunction = (newLockedRepresentationString: LockedRepresentationString) => Promise<void> | void;
-export default SaveFunction;
+export type SaveFunction = (newLockedRepresentationString: LockedRepresentationString) => Promise<void> | void;

package/build/interfaces/SyncTypes.d.mts

@@ -1,18 +1,20 @@
 import type { Tagged } from 'type-fest';
 import type { JPakeThreePass, Round1Result } from 'jpake-ts';
-import { PublicKey, SyncKey } from './CryptoLib.mjs';
+import type { PublicKey, SyncKey } from './CryptoLib.mjs';
+import type { Vault, VaultSyncState } from './Vault.mjs';
 export type DeviceId = Tagged<string, 'DeviceId'>;
 export type DeviceType = Tagged<string, 'DeviceType'>;
 export type DeviceFriendlyName = Tagged<string, 'DeviceFriendlyName'>;
+export interface DeviceInfo {
+    deviceType: DeviceType;
+    deviceFriendlyName?: DeviceFriendlyName;
+}
 export interface SyncDevice {
     deviceId: DeviceId;
     publicKey: PublicKey;
-    meta?: {
-        deviceType: DeviceType;
-        deviceFriendlyName: DeviceFriendlyName;
-    };
+    deviceInfo?: DeviceInfo;
 }
-export type PublicSyncDevice = Omit<SyncDevice, 'publicKey'>;
+export type PublicSyncDevice = Omit<SyncDevice, 'publicKey' | 'deviceInfo'> & Partial<SyncDevice['deviceInfo']>;
 export interface BaseAddDeviceFlow {
     jpak: JPakeThreePass;
     addDevicePassword: Uint8Array;
@@ -45,3 +47,10 @@ export interface InitiateAddDeviceFlowResult {
     timestamp: number;
     pass1Result: Record<keyof Round1Result, string>;
 }
+export interface VaultStateSend {
+    deviceId: DeviceId;
+    forDeviceId: DeviceId;
+    deviceFriendlyName?: DeviceFriendlyName;
+    vault: Vault;
+    sync: VaultSyncState;
+}

package/build/interfaces/Vault.d.mts

@@ -1,7 +1,7 @@
 import type { Tagged } from 'type-fest';
 import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Salt } from './CryptoLib.mjs';
 import type Entry from './Entry.mjs';
-import { DeviceId, SyncDevice } from './SyncTypes.mjs';
+import { DeviceFriendlyName, DeviceId, SyncDevice } from './SyncTypes.mjs';
 import { SyncCommandFromClient } from 'favaserver/ClientMessage';
 export type Vault = Entry[];
 export type EncryptedVaultStateString = Encrypted<VaultStateString>;
@@ -24,6 +24,7 @@ export type VaultSyncStateWithServerUrl = Omit<VaultSyncState, 'serverUrl'> & {
 };
 export interface VaultState {
     deviceId: DeviceId;
+    deviceFriendlyName?: DeviceFriendlyName;
     vault: Vault;
     sync: VaultSyncState;
 }

package/build/main.d.mts

@@ -3,11 +3,11 @@ import type Entry from './interfaces/Entry.mjs';
 import type { EntryId, NewEntry, EntryMeta, EntryType, TotpPayload, Token, EntryMetaWithToken } from './interfaces/Entry.mjs';
 import type CryptoLib from './interfaces/CryptoLib.mjs';
 import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, EncryptedPublicKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt } from './interfaces/CryptoLib.mjs';
-import type { PublicSyncDevice, DeviceId, DeviceType, DeviceFriendlyName } from './interfaces/SyncTypes.mjs';
+import type { PublicSyncDevice, DeviceId, DeviceType, DeviceFriendlyName, DeviceInfo } from './interfaces/SyncTypes.mjs';
 import type { EncryptedVaultStateString, LockedRepresentationString } from './interfaces/Vault.mjs';
-import type SaveFunction from './interfaces/SaveFunction.mjs';
+import type { SaveFunction } from './interfaces/SaveFunction.mjs';
 import { TwoFALibError, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError } from './TwoFALibError.mjs';
 import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
 import { getTwoFaLibVaultCreationUtils } from './utils/creationUtils.mjs';
 export { TwoFaLib, TwoFALibError, getTwoFaLibVaultCreationUtils, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError, TwoFaLibEvent, };
-export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt, DeviceId, DeviceType, DeviceFriendlyName, PublicSyncDevice, SaveFunction, };
+export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt, DeviceId, DeviceType, DeviceFriendlyName, DeviceInfo, PublicSyncDevice, SaveFunction, };

package/build/subclasses/PersistentStorageManager.d.mts

@@ -1,16 +1,17 @@
 import type { EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
-import { EncryptedVaultStateString } from '../interfaces/Vault.mjs';
+import { EncryptedVaultStateString, LockedRepresentationString } from '../interfaces/Vault.mjs';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
-import type { DeviceId } from '../interfaces/SyncTypes.mjs';
+import type { FavaMeta } from '../interfaces/FavaMeta.mjs';
 import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
-import SaveFunction from '../interfaces/SaveFunction.mjs';
+import type { SaveFunction } from '../interfaces/SaveFunction.mjs';
+import type { DeviceId } from '../interfaces/SyncTypes.mjs';
 /**
  * Manages all storage of data that should be persistent.
  */
 declare class PersistentStorageManager {
     private mediator;
     private readonly passphraseExtraDict;
-    private readonly deviceId;
+    private readonly favaMeta;
     private readonly privateKey;
     private readonly symmetricKey;
     private encryptedPrivateKey;
@@ -23,7 +24,7 @@ declare class PersistentStorageManager {
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
      * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
-     * @param deviceId - The unique identifier of the device.
+     * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
      * @param encryptedPrivateKey - The encrypted private key
@@ -31,7 +32,7 @@ declare class PersistentStorageManager {
      * @param salt - The salt used for key derivation.
      * @param saveFunction - The function to save the data.
      */
-    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, deviceId: DeviceId, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
+    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, favaMeta: FavaMeta, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
     private get cryptoLib();
     private get vaultDataManager();
     private get syncManager();
@@ -39,9 +40,10 @@ declare class PersistentStorageManager {
      * Retrieves an encrypted representation of the library's current state.
      * This can be used for secure storage or transmission of the library's data.
      * @param key - The key to decrypt the locked representation with. If not provided the library's current symmetric key will be used.
+     * @param forDeviceId - If the vault is meant for a specific deviceId
      * @returns A promise that resolves with a string representation of the locked state.
      */
-    getEncryptedVaultState(key?: SymmetricKey): Promise<EncryptedVaultStateString>;
+    getEncryptedVaultState(key?: SymmetricKey, forDeviceId?: DeviceId): Promise<EncryptedVaultStateString>;
     /**
      * Creates a partially encrypted representation of all data, except for
      * the passphrase, that is needed to load the library. This can be used
@@ -49,7 +51,7 @@ declare class PersistentStorageManager {
      * @returns A promise that resolves with a json encoded string of
      * the partially encrypted library's data.
      */
-    private getLockedRepresentation;
+    getLockedRepresentation(): Promise<LockedRepresentationString>;
     /**
      * Sets the save function for the library.
      * @param saveFunction - The save function to set.

package/build/subclasses/PersistentStorageManager.mjs

@@ -10,7 +10,7 @@ class PersistentStorageManager {
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
      * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
-     * @param deviceId - The unique identifier of the device.
+     * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
      * @param encryptedPrivateKey - The encrypted private key
@@ -18,10 +18,10 @@ class PersistentStorageManager {
      * @param salt - The salt used for key derivation.
      * @param saveFunction - The function to save the data.
      */
-    constructor(mediator, passphraseExtraDict, deviceId, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
+    constructor(mediator, passphraseExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
         this.mediator = mediator;
         this.passphraseExtraDict = passphraseExtraDict;
-        this.deviceId = deviceId;
+        this.favaMeta = favaMeta;
         this.privateKey = privateKey;
         this.symmetricKey = symmetricKey;
         this.encryptedPrivateKey = encryptedPrivateKey;
@@ -46,13 +46,16 @@ class PersistentStorageManager {
      * Retrieves an encrypted representation of the library's current state.
      * This can be used for secure storage or transmission of the library's data.
      * @param key - The key to decrypt the locked representation with. If not provided the library's current symmetric key will be used.
+     * @param forDeviceId - If the vault is meant for a specific deviceId
      * @returns A promise that resolves with a string representation of the locked state.
      */
-    async getEncryptedVaultState(key) {
+    async getEncryptedVaultState(key, forDeviceId) {
         const vault = this.vaultDataManager.getAllEntries();
         const vaultState = {
             vault,
-            deviceId: this.deviceId,
+            deviceId: this.favaMeta.deviceId,
+            forDeviceId,
+            deviceFriendlyName: this.favaMeta.deviceFriendlyName,
             sync: {
                 // eslint-disable-next-line @typescript-eslint/dot-notation
                 devices: this.syncManager ? this.syncManager['syncDevices'] : [],

package/build/subclasses/StorageOperationsManager.d.mts

@@ -1,6 +1,6 @@
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 import type { Passphrase } from '../interfaces/CryptoLib.mjs';
-import type SaveFunction from '../interfaces/SaveFunction.mjs';
+import type { SaveFunction } from '../interfaces/SaveFunction.mjs';
 /**
  * Manages the public operations related to the vault storage
  */
@@ -17,6 +17,7 @@ declare class StorageOperationsManager {
     get persistentStorage(): import("./PersistentStorageManager.mjs").default;
     /**
      * Forces a save.
+     * @returns void
      */
     forceSave(): Promise<void>;
     /**

package/build/subclasses/StorageOperationsManager.mjs

@@ -17,6 +17,7 @@ class StorageOperationsManager {
     }
     /**
      * Forces a save.
+     * @returns void
      */
     async forceSave() {
         return this.persistentStorage.save();

package/build/subclasses/SyncManager.d.mts

@@ -1,8 +1,9 @@
-import { SyncDevice, DeviceId, PublicSyncDevice } from '../interfaces/SyncTypes.mjs';
+import { SyncDevice, PublicSyncDevice, DeviceType } from '../interfaces/SyncTypes.mjs';
 import type { PrivateKey, PublicKey } from '../interfaces/CryptoLib.mjs';
 import type Command from '../Command/BaseCommand.mjs';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 import { VaultSyncStateWithServerUrl } from '../interfaces/Vault.mjs';
+import type { FavaMeta } from '../interfaces/FavaMeta.mjs';
 import { SyncCommandFromServer } from 'favaserver/ServerMessage';
 import { SyncCommandFromClient } from 'favaserver/ClientMessage';
 export declare enum ConnectionStatus {
@@ -18,18 +19,23 @@ declare class SyncManager {
     private readonly mediator;
     private readonly publicKey;
     private readonly privateKey;
+    private readonly favaMeta;
+    private readonly deviceType;
     private ws?;
     private activeAddDeviceFlow?;
     private readonly reconnectInterval;
     readonly serverUrl: string;
     private syncDevices;
-    deviceId: DeviceId;
     private readyEventEmitted;
     private commandSendQueue;
     private reconnectTimeout?;
     private terminateTimeout?;
     private connectionFailedTimeout?;
     private shouldReconnect;
+    private requestedResilver;
+    private requestedResilverTimeout?;
+    private get deviceId();
+    private get deviceInfo();
     /**
      * Public getter for the command send queue.
      * @returns The command send queue.
@@ -45,11 +51,12 @@ declare class SyncManager {
      * @param mediator - The mediator for accessing other components.
      * @param publicKey - The public key of the device.
      * @param privateKey - The private key of the device.
+     * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param syncState - The state of the sync.
-     * @param deviceId - The unique identifier of the device.
+     * @param deviceType - The identifier for this device type (e.g. 2fa-cli).
      * @throws {InitializationError} If initialization fails (e.g., if the server URL is invalid).
      */
-    constructor(mediator: TwoFaLibMediator, publicKey: PublicKey, privateKey: PrivateKey, syncState: VaultSyncStateWithServerUrl, deviceId: DeviceId);
+    constructor(mediator: TwoFaLibMediator, publicKey: PublicKey, privateKey: PrivateKey, favaMeta: FavaMeta, syncState: VaultSyncStateWithServerUrl, deviceType: DeviceType);
     private get libraryLoader();
     private get cryptoLib();
     private get persistentStorageManager();
@@ -132,8 +139,8 @@ declare class SyncManager {
     respondToAddDeviceFlow(initiatorData: string | Uint8Array | File, initiatorDataType: 'text' | 'qr'): Promise<void>;
     private finishAddDeviceFlowKeyExchangeInitiator;
     private finishAddDeviceFlowKeyExchangeResponder;
-    private sendFullVaultData;
-    private importInitialVaultState;
+    private sendFullVaultDataAndSetDeviceInfo;
+    private importInitialVault;
     private importVaultState;
     /**
      * Cancels the active add sync device flow.
@@ -165,14 +172,14 @@ declare class SyncManager {
     private resilver;
     /**
      * Add a sync device
-     * @param deviceInfo - The info about the device
+     * @param device - The device to add
      * @param saveAfter - Whether to save the new vault after adding it (set to false when adding multiple devices)
      */
-    addSyncDevice(deviceInfo: SyncDevice, saveAfter?: boolean): Promise<void>;
+    addSyncDevice(device: SyncDevice, saveAfter?: boolean): Promise<void>;
     /**
      * Requests a resilver of the vault
      */
-    requestResilver(): void;
+    requestResilver(): Promise<void>;
     /**
      * Function to call when the server connection should be closed
      */

package/build/subclasses/SyncManager.mjs

@@ -22,6 +22,15 @@ const generateNonCryptographicRandomString = () => {
  * Manages synchronization of 2FA devices and communication with the server.
  */
 class SyncManager {
+    get deviceId() {
+        return this.favaMeta.deviceId;
+    }
+    get deviceInfo() {
+        return {
+            deviceType: this.deviceType,
+            deviceFriendlyName: this.favaMeta.deviceFriendlyName,
+        };
+    }
     /**
      * Public getter for the command send queue.
      * @returns The command send queue.
@@ -38,7 +47,7 @@ class SyncManager {
             .filter((d) => d.deviceId !== this.deviceId)
             .map((d) => ({
             deviceId: d.deviceId,
-            meta: d.meta,
+            ...d.deviceInfo,
         }));
     }
     /**
@@ -46,33 +55,37 @@ class SyncManager {
      * @param mediator - The mediator for accessing other components.
      * @param publicKey - The public key of the device.
      * @param privateKey - The private key of the device.
+     * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param syncState - The state of the sync.
-     * @param deviceId - The unique identifier of the device.
+     * @param deviceType - The identifier for this device type (e.g. 2fa-cli).
      * @throws {InitializationError} If initialization fails (e.g., if the server URL is invalid).
      */
-    constructor(mediator, publicKey, privateKey, syncState, deviceId) {
+    constructor(mediator, publicKey, privateKey, favaMeta, syncState, deviceType) {
         this.mediator = mediator;
         this.publicKey = publicKey;
         this.privateKey = privateKey;
+        this.favaMeta = favaMeta;
+        this.deviceType = deviceType;
         this.reconnectInterval = IN_TESTING ? 100 : 5000; // 5 seconds
         this.readyEventEmitted = false;
         this.commandSendQueue = [];
         this.shouldReconnect = true;
+        this.requestedResilver = false;
         const { serverUrl, devices, commandSendQueue } = syncState;
         if (!serverUrl.startsWith('wss://')) {
             if (!serverUrl.startsWith('ws://') && !(IN_DEV || IN_TESTING)) {
                 throw new InitializationError('Invalid server URL, protocol must be wss');
             }
         }
-        this.deviceId = deviceId;
         this.syncDevices = devices;
         this.commandSendQueue = commandSendQueue;
         this.serverUrl = serverUrl;
         this.initServerConnection();
         // add ourselves to the list of syncdevices if we're missing
         void this.addSyncDevice({
-            deviceId: deviceId,
+            deviceId: this.favaMeta.deviceId,
             publicKey: this.publicKey,
+            deviceInfo: this.deviceInfo,
         }, false);
         // if not yet connected after 2 tries, emit ready event so we can continue
         this.connectionFailedTimeout = setTimeout(() => {
@@ -132,7 +145,8 @@ class SyncManager {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const syncManager = this;
         ws.addEventListener('error', (event) => {
-            syncManager.log('warning', `Error in websocket: ${event}`);
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            syncManager.log('warning', `Error in websocket: ${event.toString()}`);
         });
         ws.addEventListener('message', function message(message) {
             try {
@@ -209,21 +223,27 @@ class SyncManager {
                 void this.finishAddDeviceFlowKeyExchangeResponder(pass3Result);
                 break;
             }
-            case 'publicKey': {
+            case 'publicKeyAndDeviceInfo': {
                 const { data } = message;
-                const { responderEncryptedPublicKey } = data;
-                void this.sendFullVaultData(responderEncryptedPublicKey);
+                const { responderEncryptedPublicKey, responderEncryptedDeviceInfo } = data;
+                void this.sendFullVaultDataAndSetDeviceInfo(responderEncryptedPublicKey, responderEncryptedDeviceInfo);
                 break;
             }
             case 'initialVault': {
                 const { data } = message;
                 const { encryptedVaultData } = data;
-                void this.importInitialVaultState(encryptedVaultData);
+                void this.importInitialVault(encryptedVaultData);
                 break;
             }
             case 'vault': {
+                if (!this.requestedResilver) {
+                    throw new SyncError('Got vault data while no resilver was requested, probably replay attack!');
+                }
                 const { data } = message;
-                const { encryptedVaultData, encryptedSymmetricKey, fromDeviceId } = data;
+                const { encryptedVaultData, encryptedSymmetricKey, fromDeviceId, forDeviceId, } = data;
+                if (forDeviceId !== this.deviceId) {
+                    throw new SyncError('Got vault data for the wrong device!');
+                }
                 void this.cryptoLib
                     .decrypt(this.privateKey, encryptedSymmetricKey)
                     .then((symmetricKey) => this.importVaultState(encryptedVaultData, symmetricKey, fromDeviceId));
@@ -415,14 +435,16 @@ class SyncManager {
             syncKey,
         };
         const responderEncryptedPublicKey = await this.cryptoLib.encryptSymmetric(syncKey, this.publicKey);
+        const responderEncryptedDeviceInfo = await this.cryptoLib.encryptSymmetric(syncKey, JSON.stringify(this.deviceInfo));
         // send our public key
-        this.sendToServer('publicKey', {
+        this.sendToServer('publicKeyAndDeviceInfo', {
             nonce: await this.getNonce(),
             responderEncryptedPublicKey,
+            responderEncryptedDeviceInfo,
             initiatorDeviceId: this.activeAddDeviceFlow.initiatorDeviceId,
         });
     }
-    async sendFullVaultData(responderEncryptedPublicKey) {
+    async sendFullVaultDataAndSetDeviceInfo(responderEncryptedPublicKey, responderEncryptedDeviceInfo) {
         if (!this.ws || !this.webSocketConnected) {
             throw new SyncNoServerConnectionError();
         }
@@ -435,8 +457,10 @@ class SyncManager {
         const syncKey = this.activeAddDeviceFlow.syncKey;
         // Decrypt the received public key
         const decryptedPublicKey = await this.cryptoLib.decryptSymmetric(syncKey, responderEncryptedPublicKey);
+        // decrypt the received device info
+        const responderDeviceInfo = JSON.parse(await this.cryptoLib.decryptSymmetric(syncKey, responderEncryptedDeviceInfo));
         // get the vault data (encrypted with the sync key)
-        const encryptedVaultData = await this.persistentStorageManager.getEncryptedVaultState(syncKey);
+        const encryptedVaultData = await this.persistentStorageManager.getEncryptedVaultState(syncKey, this.activeAddDeviceFlow.responderDeviceId);
         // Send the encrypted vault data to the server
         this.sendToServer('initialVault', {
             nonce: await this.getNonce(),
@@ -447,12 +471,13 @@ class SyncManager {
         const command = AddSyncDeviceCommand.create({
             deviceId: this.activeAddDeviceFlow.responderDeviceId,
             publicKey: decryptedPublicKey,
+            deviceInfo: responderDeviceInfo,
         });
         await this.commandManager.execute(command);
         // all done
         this.activeAddDeviceFlow = undefined;
     }
-    async importInitialVaultState(encryptedVaultState) {
+    async importInitialVault(encryptedVaultState) {
         if (this.activeAddDeviceFlow?.state !== 'responder:syncKeyCreated') {
             throw new SyncInWrongStateError(`Expected responder:syncKeyCreated, got ${this.activeAddDeviceFlow?.state}`);
         }
@@ -466,6 +491,9 @@ class SyncManager {
         if (vaultState.deviceId !== expectedDeviceId) {
             throw new SyncError(`DeviceId mismatch when importing, expected ${expectedDeviceId} got ${vaultState.deviceId}`);
         }
+        if (vaultState.forDeviceId !== this.deviceId) {
+            throw new SyncError(`For deviceId mismatch when importing, expected ${this.deviceId} got ${vaultState.forDeviceId}`);
+        }
         for (const device of vaultState.sync.devices) {
             await this.addSyncDevice(device, false);
         }
@@ -506,6 +534,7 @@ class SyncManager {
                 // skip ourselves
                 return;
             }
+            // unique symmetricKey per command
             const symmetricKey = await this.cryptoLib.createSymmetricKey();
             const encryptedSymmetricKey = await this.cryptoLib.encrypt(device.publicKey, symmetricKey);
             const encryptedCommand = await this.cryptoLib.encryptSymmetric(symmetricKey, JSON.stringify({
@@ -587,7 +616,7 @@ class SyncManager {
             }
             const symmetricKey = await this.cryptoLib.createSymmetricKey();
             const encryptedSymmetricKey = await this.cryptoLib.encrypt(device.publicKey, symmetricKey);
-            const encryptedVaultData = await this.persistentStorageManager.getEncryptedVaultState(symmetricKey);
+            const encryptedVaultData = await this.persistentStorageManager.getEncryptedVaultState(symmetricKey, device.deviceId);
             this.sendToServer('vault', {
                 forDeviceId: device.deviceId,
                 nonce: await this.getNonce(),
@@ -598,17 +627,17 @@ class SyncManager {
     }
     /**
      * Add a sync device
-     * @param deviceInfo - The info about the device
+     * @param device - The device to add
      * @param saveAfter - Whether to save the new vault after adding it (set to false when adding multiple devices)
      */
-    async addSyncDevice(deviceInfo, saveAfter = true) {
-        if (this.syncDevices.some((d) => d.deviceId === deviceInfo.deviceId)) {
+    async addSyncDevice(device, saveAfter = true) {
+        if (this.syncDevices.some((d) => d.deviceId === device.deviceId)) {
             // we already have this device
             return;
         }
-        this.log('info', `Adding syncdevice ${deviceInfo.deviceId} to ${this.deviceId}`);
+        this.log('info', `Adding syncdevice ${device.deviceId} to ${this.deviceId}`);
         this.syncDevices.push({
-            ...deviceInfo,
+            ...device,
         });
         if (saveAfter) {
             await this.persistentStorageManager.save();
@@ -617,10 +646,18 @@ class SyncManager {
     /**
      * Requests a resilver of the vault
      */
-    requestResilver() {
+    async requestResilver() {
         this.sendToServer('startResilver', {
             deviceIds: this.syncDevices.map((d) => d.deviceId),
+            nonce: await this.getNonce(),
         });
+        // Set requestedResilver to true for 60 seconds, after this we no longer
+        // accept vault data
+        this.requestedResilver = true;
+        if (this.requestedResilverTimeout) {
+            clearTimeout(this.requestedResilverTimeout);
+        }
+        this.requestedResilverTimeout = setTimeout(() => (this.requestedResilver = false), 60 * 1000);
     }
     /**
      * Function to call when the server connection should be closed

package/build/utils/creationUtils.d.mts

@@ -6,7 +6,7 @@ import TwoFaLib from '../TwoFaLib.mjs';
 import LibraryLoader from '../subclasses/LibraryLoader.mjs';
 import type { LockedRepresentationString } from '../interfaces/Vault.mjs';
 import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
-import SaveFunction from '../interfaces/SaveFunction.mjs';
+import { SaveFunction } from '../interfaces/SaveFunction.mjs';
 /**
  * Evaluates the strength of a passphrase.
  * @param libraryLoader - An instance of LibraryLoader.

package/build/utils/creationUtils.mjs

@@ -65,7 +65,9 @@ const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, pass
     const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(passphrase);
     await validatePassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
     const deviceId = genUuidV4();
-    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, [], saveFunction, {
+    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
+        deviceId,
+    }, [], saveFunction, {
         serverUrl,
         devices: [],
         commandSendQueue: [],
@@ -107,7 +109,10 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !vaultState.sync?.devices) {
         throw new InitializationError('encryptedVaultState is incomplete or corrupted');
     }
-    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, vaultState.deviceId, vaultState.vault, saveFunction, vaultState.sync);
+    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
+        deviceId: vaultState.deviceId,
+        deviceFriendlyName: vaultState.deviceFriendlyName,
+    }, vaultState.vault, saveFunction, vaultState.sync);
 };
 /**
  * Returns utility functions useful in creating a new twoFaLib vault

package/build/utils/exportImportUtils.mjs

@@ -162,6 +162,7 @@ export const processImportLines = async (lines, importFromUri) => {
  * @returns A promise that resolves to the encrypted data.
  */
 export const encryptExport = async (openPgpLib, data, password) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const encrypted = await openPgpLib.encrypt({
         message: await openPgpLib.createMessage({ text: data }),
         passwords: [password],

package/build/utils/syncUtils.d.mts

@@ -17,7 +17,7 @@ export declare const decodeInitiatorData: (initiatorData: string | Uint8Array |
  * @param jsonObj - The JSONified Uint8Array to convert.
  * @returns A Uint8Array containing the values of the JSONified Uint8Array.
  */
-export declare const jsonifiedUint8ArraytoUint8Array: (jsonObj: Record<string, number>) => Uint8Array;
+export declare const jsonifiedUint8ArraytoUint8Array: (jsonObj: Record<string, number>) => Uint8Array<ArrayBuffer>;
 /**
  * Converts a JSON object to a record of Uint8Arrays.
  * @param jsonObj - The JSON object to convert.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favalib",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "",
   "type": "module",
   "exports": {

package/build/Command/commands/ChangeSyncDeviceMetaCommand.mjs

@@ -1,37 +0,0 @@
-import { InvalidCommandError, TwoFALibError } from '../../TwoFALibError.mjs';
-import Command from '../BaseCommand.mjs';
-/**
- * Represents a command that when executed changes the meta info of a sync device
- */
-class ChangeSyncDeviceMetaCommand extends Command {
-    /**
-     * Creates a new ChangeSyncDeviceMetaCommand instance.
-     * @inheritdoc
-     * @param data - The id of the device to change and the new meta info
-     */
-    constructor(data, id, timestamp, version, fromRemote = false) {
-        super('ChangeSyncDeviceMeta', data, id, timestamp, version, fromRemote);
-    }
-    /**
-     * Executes the command to change the sync device metadata
-     * @inheritdoc
-     * @throws {InvalidCommandError} If the referenced sync device cannot be found
-     */
-    execute(mediator) {
-        const syncManager = mediator.getComponent('syncManager');
-        // eslint-disable-next-line @typescript-eslint/dot-notation
-        const device = syncManager['syncDevices'].find((d) => d.deviceId === this.data.deviceId);
-        if (!device) {
-            throw new InvalidCommandError('Trying to change meta of device that is not found');
-        }
-        device.meta = this.data.newMeta;
-        return Promise.resolve();
-    }
-    /**
-     * @inheritdoc
-     */
-    createUndoCommand() {
-        throw new TwoFALibError('Not implemented yet');
-    }
-}
-export default ChangeSyncDeviceMetaCommand;