@tagea/capacitor-matrix 0.0.2 → 0.1.0

package/dist/plugin.js

@@ -11,27 +11,41 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
             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;
                 },
             };
         }
@@ -56,6 +70,12 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
             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,
@@ -85,6 +105,19 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
             }
             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)
@@ -137,13 +170,21 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
                     }
                 }
             });
-            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
@@ -291,10 +332,7 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
                     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 };
@@ -313,19 +351,35 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
             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 };
         }
@@ -347,10 +401,7 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
                     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,
@@ -568,18 +619,31 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
         }
         // ── 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) {
@@ -602,12 +666,48 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
         }
         // ── 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();
@@ -690,12 +790,39 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
             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() {
@@ -724,8 +851,23 @@ var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, key
                 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;
             }