forkoff 1.0.17 → 1.0.19

package/dist/crypto/websocketE2EE.js

@@ -4,8 +4,9 @@ exports.WebSocketE2EEIntegration = void 0;
 exports.createE2EEWebSocketClient = createE2EEWebSocketClient;
 const e2eeManager_1 = require("./e2eeManager");
 /**
- * WebSocket E2EE Integration
- * Adds end-to-end encryption capabilities to WebSocket client
+ * WebSocket E2EE Integration (legacy wrapper)
+ * E2EE is now wired directly into WebSocketClient.
+ * This class remains for backward compatibility.
  */
 class WebSocketE2EEIntegration {
     constructor(wsClient) {
@@ -16,42 +17,37 @@ class WebSocketE2EEIntegration {
     /**
      * Initializes E2EE and sets up event handlers
      */
-    async initialize(deviceId, apiUrl, authToken) {
-        this.e2eeManager = new e2eeManager_1.E2EEManager(deviceId, apiUrl, authToken);
+    async initialize(deviceId) {
+        this.e2eeManager = new e2eeManager_1.E2EEManager(deviceId);
         await this.e2eeManager.initialize();
         this.setupEventHandlers();
         this.enabled = true;
     }
-    /**
-     * Sets up WebSocket event handlers for E2EE
-     */
     setupEventHandlers() {
         if (!this.e2eeManager)
             return;
         // Handle incoming key exchange init
-        this.wsClient.on('encrypted_key_exchange_init', async (data) => {
+        this.wsClient.on('encrypted_key_exchange_init', (data) => {
             if (!this.e2eeManager)
                 return;
             try {
-                // Handle key exchange and send ack
-                const ackPayload = await this.e2eeManager.handleKeyExchangeInit(data.senderDeviceId, data.ephemeralPublicKey);
-                // Emit ack back to sender
-                this.emitKeyExchangeAck(data.senderDeviceId, ackPayload.ephemeralPublicKey);
+                const ack = this.e2eeManager.handleKeyExchangeInit(data);
+                this.emitKeyExchangeAck(data.senderDeviceId, ack.ephemeralPublicKey);
             }
             catch (error) {
-                console.error('[E2EE] Failed to handle key exchange init:', error);
+                console.error('[E2EE] Key exchange init failed');
             }
         });
         // Handle incoming key exchange ack
-        this.wsClient.on('encrypted_key_exchange_ack', async (data) => {
+        this.wsClient.on('encrypted_key_exchange_ack', (data) => {
             if (!this.e2eeManager)
                 return;
             try {
-                await this.e2eeManager.handleKeyExchangeAck(data.senderDeviceId, data.ephemeralPublicKey);
-                console.log(`[E2EE] Key exchange completed with ${data.senderDeviceId}`);
+                this.e2eeManager.handleKeyExchangeAck(data);
+                // Key exchange completed
             }
             catch (error) {
-                console.error('[E2EE] Failed to handle key exchange ack:', error);
+                console.error('[E2EE] Key exchange ack failed');
             }
         });
         // Handle incoming encrypted messages
@@ -60,27 +56,25 @@ class WebSocketE2EEIntegration {
                 return;
             try {
                 const plaintext = this.e2eeManager.decryptMessage(data, data.senderDeviceId);
-                // Emit decrypted message as a regular user_message event
                 this.wsClient.emit('decrypted_message', {
                     ...data,
                     decryptedContent: plaintext,
                 });
             }
             catch (error) {
-                console.error('[E2EE] Failed to decrypt message:', error);
+                console.error('[E2EE] Failed to decrypt message — dropped');
             }
         });
     }
     /**
      * Initiates key exchange with a target device
      */
-    async initiateKeyExchange(targetDeviceId) {
+    initiateKeyExchange(targetDeviceId) {
         if (!this.e2eeManager) {
             throw new Error('E2EE not initialized');
         }
-        const initPayload = await this.e2eeManager.initiateKeyExchange(targetDeviceId);
-        // Emit key exchange init via WebSocket
-        this.emitKeyExchangeInit(targetDeviceId, initPayload.ephemeralPublicKey);
+        const init = this.e2eeManager.createKeyExchangeInit(targetDeviceId);
+        this.emitKeyExchangeInit(targetDeviceId, init.ephemeralPublicKey);
     }
     /**
      * Encrypts and sends a message to a target device
@@ -93,39 +87,28 @@ class WebSocketE2EEIntegration {
             throw new Error(`No E2EE session with ${targetDeviceId}. Must complete key exchange first.`);
         }
         const encryptedMessage = this.e2eeManager.encryptMessage(plaintext, targetDeviceId, sessionId);
-        // Emit encrypted message via WebSocket
         this.emitEncryptedMessage(encryptedMessage);
     }
-    /**
-     * Checks if E2EE session exists for a device
-     */
     hasSession(deviceId) {
         return this.e2eeManager?.hasSessionKey(deviceId) ?? false;
     }
-    /**
-     * Checks if E2EE is enabled
-     */
     isEnabled() {
         return this.enabled && this.e2eeManager !== null;
     }
-    /**
-     * Cleans up E2EE sessions
-     */
     cleanup() {
         this.e2eeManager?.cleanup();
     }
-    // Private WebSocket emit methods
     emitKeyExchangeInit(recipientDeviceId, ephemeralPublicKey) {
         this.wsClient.emitKeyExchangeInit({
             recipientDeviceId,
-            senderDeviceId: this.e2eeManager?.['deviceId'] || '',
+            senderDeviceId: this.e2eeManager?.deviceId || '',
             ephemeralPublicKey,
         });
     }
     emitKeyExchangeAck(recipientDeviceId, ephemeralPublicKey) {
         this.wsClient.emitKeyExchangeAck({
             recipientDeviceId,
-            senderDeviceId: this.e2eeManager?.['deviceId'] || '',
+            senderDeviceId: this.e2eeManager?.deviceId || '',
             ephemeralPublicKey,
         });
     }
@@ -137,8 +120,8 @@ exports.WebSocketE2EEIntegration = WebSocketE2EEIntegration;
 /**
  * Factory function to create E2EE-enabled WebSocket client
  */
-function createE2EEWebSocketClient(wsClient, deviceId, apiUrl, authToken) {
+function createE2EEWebSocketClient(wsClient, deviceId) {
     const integration = new WebSocketE2EEIntegration(wsClient);
-    return integration.initialize(deviceId, apiUrl, authToken).then(() => integration);
+    return integration.initialize(deviceId).then(() => integration);
 }
 //# sourceMappingURL=websocketE2EE.js.map