@tagea/capacitor-matrix 0.0.2 → 0.1.0

package/dist/plugin.cjs.js

@@ -15,27 +15,41 @@ class MatrixWeb extends core.WebPlugin {
         super(...arguments);
         this._cryptoCallbacks = {
             getSecretStorageKey: async (opts) => {
-                var _a;
+                var _a, _b;
                 const keyId = Object.keys(opts.keys)[0];
                 if (!keyId)
                     return null;
-                // If we have the raw key cached, use it directly
-                if (this.secretStorageKey) {
+                // Exact match: only return the cached raw key for the key ID it was cached under.
+                // (bootstrapSecretStorage uses createSecretStorageKey for the new key, so this
+                // path is only reached for an already-established key — e.g. after recoverAndSetup.)
+                if (this.secretStorageKey && this.secretStorageKeyId === keyId) {
                     return [keyId, this.secretStorageKey];
                 }
-                // If we have a passphrase, derive the key using the server's stored parameters
+                // Derive from the current passphrase (set during recoverAndSetup)
                 if (this.recoveryPassphrase) {
                     const keyInfo = opts.keys[keyId];
                     if (keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.passphrase) {
                         const derived = await keyPassphrase.deriveRecoveryKeyFromPassphrase(this.recoveryPassphrase, keyInfo.passphrase.salt, keyInfo.passphrase.iterations, (_a = keyInfo.passphrase.bits) !== null && _a !== void 0 ? _a : 256);
+                        // Cache with the correct key ID for subsequent calls
                         this.secretStorageKey = derived;
+                        this.secretStorageKeyId = keyId;
+                        return [keyId, derived];
+                    }
+                }
+                // Fallback: derive from the OLD passphrase when bootstrapSecretStorage is
+                // migrating existing cross-signing / backup secrets into a new SSSS.
+                if (this.fallbackPassphrase) {
+                    const keyInfo = opts.keys[keyId];
+                    if (keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.passphrase) {
+                        const derived = await keyPassphrase.deriveRecoveryKeyFromPassphrase(this.fallbackPassphrase, keyInfo.passphrase.salt, keyInfo.passphrase.iterations, (_b = keyInfo.passphrase.bits) !== null && _b !== void 0 ? _b : 256);
                         return [keyId, derived];
                     }
                 }
                 return null;
             },
-            cacheSecretStorageKey: (_keyId, _keyInfo, key) => {
+            cacheSecretStorageKey: (keyId, _keyInfo, key) => {
                 this.secretStorageKey = key;
+                this.secretStorageKeyId = keyId;
             },
         };
     }
@@ -60,6 +74,12 @@ class MatrixWeb extends core.WebPlugin {
         return session;
     }
     async loginWithToken(options) {
+        // Stop any previously running client to avoid parallel instances that
+        // would deadlock on the shared IndexedDB crypto store.
+        if (this.client) {
+            this.client.stopClient();
+            this.client = undefined;
+        }
         this.client = matrixJsSdk.createClient({
             baseUrl: options.homeserverUrl,
             accessToken: options.accessToken,
@@ -89,6 +109,19 @@ class MatrixWeb extends core.WebPlugin {
         }
         localStorage.removeItem(SESSION_KEY);
     }
+    async clearAllData() {
+        if (this.client) {
+            this.client.stopClient();
+            this.client = undefined;
+        }
+        // Reset all cached crypto state
+        this.secretStorageKey = undefined;
+        this.secretStorageKeyId = undefined;
+        this.recoveryPassphrase = undefined;
+        this.fallbackPassphrase = undefined;
+        localStorage.removeItem(SESSION_KEY);
+        await this.deleteCryptoStore();
+    }
     async getSession() {
         const raw = localStorage.getItem(SESSION_KEY);
         if (!raw)
@@ -141,13 +174,21 @@ class MatrixWeb extends core.WebPlugin {
                 }
             }
         });
-        this.client.on(matrixJsSdk.RoomEvent.Receipt, (_event, room) => {
-            var _a;
-            this.notifyListeners('receiptReceived', {
-                roomId: room.roomId,
-            });
+        this.client.on(matrixJsSdk.RoomEvent.Receipt, (event, room) => {
+            var _a, _b;
+            const receiptContent = event.getContent();
+            for (const [eventId, receiptTypes] of Object.entries(receiptContent)) {
+                const mRead = (_a = receiptTypes['m.read']) !== null && _a !== void 0 ? _a : {};
+                for (const userId of Object.keys(mRead)) {
+                    this.notifyListeners('receiptReceived', {
+                        roomId: room.roomId,
+                        eventId,
+                        userId,
+                    });
+                }
+            }
             // Re-emit own sent messages with updated read status
-            const myUserId = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getUserId();
+            const myUserId = (_b = this.client) === null || _b === void 0 ? void 0 : _b.getUserId();
             if (myUserId) {
                 const timeline = room.getLiveTimeline().getEvents();
                 // Walk backwards through recent events; stop after checking a reasonable batch
@@ -295,10 +336,7 @@ class MatrixWeb extends core.WebPlugin {
                 msgtype,
                 body: options.body || options.fileName || 'file',
                 url: mxcUrl,
-                info: {
-                    mimetype: options.mimeType,
-                    size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size,
-                },
+                info: Object.assign(Object.assign(Object.assign({ mimetype: options.mimeType, size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size }, (options.duration !== undefined && { duration: options.duration })), (options.width !== undefined && { w: options.width })), (options.height !== undefined && { h: options.height })),
             };
             const res = await this.client.sendMessage(options.roomId, content);
             return { eventId: res.event_id };
@@ -317,19 +355,35 @@ class MatrixWeb extends core.WebPlugin {
         return { eventId: res.event_id };
     }
     async editMessage(options) {
+        var _a, _b;
         this.requireClient();
-        const content = {
-            msgtype: matrixJsSdk.MsgType.Text,
-            body: `* ${options.newBody}`,
-            'm.new_content': {
-                msgtype: matrixJsSdk.MsgType.Text,
+        const msgtype = (_a = options.msgtype) !== null && _a !== void 0 ? _a : 'm.text';
+        const mediaTypes = ['m.image', 'm.audio', 'm.video', 'm.file'];
+        let newContent;
+        if (mediaTypes.includes(msgtype) && options.fileUri) {
+            const response = await fetch(options.fileUri);
+            const blob = await response.blob();
+            const uploadRes = await this.client.uploadContent(blob, {
+                name: options.fileName,
+                type: options.mimeType,
+            });
+            newContent = {
+                msgtype,
+                body: options.newBody || options.fileName || 'file',
+                url: uploadRes.content_uri,
+                info: Object.assign(Object.assign(Object.assign({ mimetype: options.mimeType, size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size }, (options.duration !== undefined && { duration: options.duration })), (options.width !== undefined && { w: options.width })), (options.height !== undefined && { h: options.height })),
+            };
+        }
+        else {
+            newContent = {
+                msgtype,
                 body: options.newBody,
-            },
-            'm.relates_to': {
+            };
+        }
+        const content = Object.assign(Object.assign({}, newContent), { body: `* ${options.newBody}`, 'm.new_content': newContent, 'm.relates_to': {
                 rel_type: 'm.replace',
                 event_id: options.eventId,
-            },
-        };
+            } });
         const res = await this.client.sendMessage(options.roomId, content);
         return { eventId: res.event_id };
     }
@@ -351,10 +405,7 @@ class MatrixWeb extends core.WebPlugin {
                 msgtype,
                 body: options.body || options.fileName || 'file',
                 url: uploadRes.content_uri,
-                info: {
-                    mimetype: options.mimeType,
-                    size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size,
-                },
+                info: Object.assign(Object.assign(Object.assign({ mimetype: options.mimeType, size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size }, (options.duration !== undefined && { duration: options.duration })), (options.width !== undefined && { w: options.width })), (options.height !== undefined && { h: options.height })),
                 'm.relates_to': {
                     'm.in_reply_to': {
                         event_id: options.replyToEventId,
@@ -572,18 +623,31 @@ class MatrixWeb extends core.WebPlugin {
     }
     // ── Device Management ──────────────────────────────────
     async getDevices() {
-        var _a;
+        var _a, _b;
         this.requireClient();
         const res = await this.client.getDevices();
-        const devices = ((_a = res.devices) !== null && _a !== void 0 ? _a : []).map((d) => {
-            var _a, _b, _c;
-            return ({
+        const crypto = this.client.getCrypto();
+        const myUserId = (_a = this.client.getUserId()) !== null && _a !== void 0 ? _a : '';
+        const devices = await Promise.all(((_b = res.devices) !== null && _b !== void 0 ? _b : []).map(async (d) => {
+            var _a, _b, _c, _d;
+            let isCrossSigningVerified;
+            if (crypto) {
+                try {
+                    const status = await crypto.getDeviceVerificationStatus(myUserId, d.device_id);
+                    isCrossSigningVerified = (_a = status === null || status === void 0 ? void 0 : status.crossSigningVerified) !== null && _a !== void 0 ? _a : false;
+                }
+                catch (_e) {
+                    // ignore — crypto may not be ready
+                }
+            }
+            return {
                 deviceId: d.device_id,
-                displayName: (_a = d.display_name) !== null && _a !== void 0 ? _a : undefined,
-                lastSeenTs: (_b = d.last_seen_ts) !== null && _b !== void 0 ? _b : undefined,
-                lastSeenIp: (_c = d.last_seen_ip) !== null && _c !== void 0 ? _c : undefined,
-            });
-        });
+                displayName: (_b = d.display_name) !== null && _b !== void 0 ? _b : undefined,
+                lastSeenTs: (_c = d.last_seen_ts) !== null && _c !== void 0 ? _c : undefined,
+                lastSeenIp: (_d = d.last_seen_ip) !== null && _d !== void 0 ? _d : undefined,
+                isCrossSigningVerified,
+            };
+        }));
         return { devices };
     }
     async deleteDevice(options) {
@@ -606,12 +670,48 @@ class MatrixWeb extends core.WebPlugin {
     }
     // ── Encryption ──────────────────────────────────────────
     async initializeCrypto() {
+        var _a, _b;
         this.requireClient();
-        const userId = this.client.getUserId();
-        const deviceId = this.client.getDeviceId();
-        await this.client.initRustCrypto({
-            cryptoDatabasePrefix: `matrix-js-sdk/${userId}/${deviceId}`,
-        });
+        const cryptoOpts = { cryptoDatabasePrefix: 'matrix-js-sdk' };
+        try {
+            await this.client.initRustCrypto(cryptoOpts);
+        }
+        catch (e) {
+            // After logout + re-login the server issues a new deviceId, but the
+            // shared IndexedDB crypto store still references the old one.
+            // Delete the stale store and retry so crypto initialises cleanly.
+            if ((_a = e === null || e === void 0 ? void 0 : e.message) === null || _a === void 0 ? void 0 : _a.includes("account in the store doesn't match")) {
+                await this.deleteCryptoStore();
+                await this.client.initRustCrypto(cryptoOpts);
+            }
+            else {
+                throw e;
+            }
+        }
+        // Flush the initial /keys/query request that initRustCrypto enqueues.
+        // Without this, any call to getIdentity (e.g. via getCrossSigningStatus)
+        // will spin-wait and emit periodic WARN logs until sync processes it.
+        const crypto = this.client.getCrypto();
+        if ((_b = crypto === null || crypto === void 0 ? void 0 : crypto.outgoingRequestsManager) === null || _b === void 0 ? void 0 : _b.doProcessOutgoingRequests) {
+            await crypto.outgoingRequestsManager.doProcessOutgoingRequests();
+        }
+    }
+    async deleteCryptoStore() {
+        if (typeof indexedDB === 'undefined')
+            return;
+        try {
+            const dbs = await indexedDB.databases();
+            await Promise.all(dbs
+                .filter((db) => { var _a; return (_a = db.name) === null || _a === void 0 ? void 0 : _a.startsWith('matrix-js-sdk'); })
+                .map((db) => new Promise((resolve) => {
+                const req = indexedDB.deleteDatabase(db.name);
+                req.onsuccess = () => resolve();
+                req.onerror = () => resolve();
+            })));
+        }
+        catch (_a) {
+            // indexedDB.databases() not available in all environments
+        }
     }
     async getEncryptionStatus() {
         this.requireClient();
@@ -694,12 +794,39 @@ class MatrixWeb extends core.WebPlugin {
         var _a;
         const crypto = await this.ensureCrypto();
         const keyInfo = await crypto.createRecoveryKeyFromPassphrase(options === null || options === void 0 ? void 0 : options.passphrase);
+        // Pre-cache the new key bytes. secretStorageKeyId will be set by
+        // cacheSecretStorageKey once bootstrapSecretStorage writes the new key
+        // into SSSS and the SDK calls back.
         this.secretStorageKey = keyInfo.privateKey;
-        await crypto.bootstrapSecretStorage({
-            createSecretStorageKey: async () => keyInfo,
-            setupNewSecretStorage: true,
-            setupNewKeyBackup: true,
-        });
+        this.secretStorageKeyId = undefined;
+        // If the caller provides the same or old passphrase, keep it so
+        // getSecretStorageKey can derive the key for the SDK.
+        if (options === null || options === void 0 ? void 0 : options.passphrase) {
+            this.recoveryPassphrase = options.passphrase;
+        }
+        // If the caller knows the OLD passphrase, keep it as fallbackPassphrase so
+        // that getSecretStorageKey can decrypt the existing SSSS during
+        // bootstrapSecretStorage's migration of cross-signing / backup secrets.
+        if (options === null || options === void 0 ? void 0 : options.existingPassphrase) {
+            this.fallbackPassphrase = options.existingPassphrase;
+        }
+        try {
+            const bootstrapPromise = crypto.bootstrapSecretStorage({
+                createSecretStorageKey: async () => keyInfo,
+                setupNewSecretStorage: true,
+                setupNewKeyBackup: true,
+            });
+            // Guard against SDK hanging when it can't retrieve the old SSSS key
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('bootstrapSecretStorage timed out — the old SSSS key could not be retrieved')), 30000);
+            });
+            await Promise.race([bootstrapPromise, timeoutPromise]);
+        }
+        finally {
+            // Always clear transient crypto state so it doesn't bleed into subsequent calls.
+            this.fallbackPassphrase = undefined;
+            this.recoveryPassphrase = undefined;
+        }
         return { recoveryKey: (_a = keyInfo.encodedPrivateKey) !== null && _a !== void 0 ? _a : '' };
     }
     async isRecoveryEnabled() {
@@ -728,8 +855,23 @@ class MatrixWeb extends core.WebPlugin {
             await crypto.loadSessionBackupPrivateKeyFromSecretStorage();
         }
         catch (e) {
-            // Clear stale key material so the next attempt starts fresh
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('decryption key does not match')) {
+                // The passphrase is correct (SSSS decrypted fine), but the backup key
+                // stored in SSSS doesn't match the server's current backup.  This happens
+                // when another client re-created the backup without updating SSSS, or
+                // vice-versa.  Auto-fix by creating a new backup that matches the SSSS key.
+                // recoveryPassphrase / secretStorageKey are still set, so the
+                // getSecretStorageKey callback can decrypt the existing SSSS.
+                await crypto.bootstrapSecretStorage({
+                    setupNewKeyBackup: true,
+                });
+                await crypto.checkKeyBackupAndEnable();
+                return;
+            }
+            // Different error — clear state and throw
             this.secretStorageKey = undefined;
+            this.secretStorageKeyId = undefined;
             this.recoveryPassphrase = undefined;
             throw e;
         }