@tagea/capacitor-matrix 0.0.2

package/dist/plugin.cjs.js

@@ -0,0 +1,964 @@
+'use strict';
+
+var core = require('@capacitor/core');
+var matrixJsSdk = require('matrix-js-sdk');
+var recoveryKey = require('matrix-js-sdk/lib/crypto-api/recovery-key');
+var keyPassphrase = require('matrix-js-sdk/lib/crypto-api/key-passphrase');
+
+const Matrix = core.registerPlugin('Matrix', {
+    web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.MatrixWeb()),
+});
+
+const SESSION_KEY = 'matrix_session';
+class MatrixWeb extends core.WebPlugin {
+    constructor() {
+        super(...arguments);
+        this._cryptoCallbacks = {
+            getSecretStorageKey: async (opts) => {
+                var _a;
+                const keyId = Object.keys(opts.keys)[0];
+                if (!keyId)
+                    return null;
+                // If we have the raw key cached, use it directly
+                if (this.secretStorageKey) {
+                    return [keyId, this.secretStorageKey];
+                }
+                // If we have a passphrase, derive the key using the server's stored parameters
+                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);
+                        this.secretStorageKey = derived;
+                        return [keyId, derived];
+                    }
+                }
+                return null;
+            },
+            cacheSecretStorageKey: (_keyId, _keyInfo, key) => {
+                this.secretStorageKey = key;
+            },
+        };
+    }
+    // ── Auth ──────────────────────────────────────────────
+    async login(options) {
+        const tmpClient = matrixJsSdk.createClient({ baseUrl: options.homeserverUrl });
+        const res = await tmpClient.loginWithPassword(options.userId, options.password);
+        this.client = matrixJsSdk.createClient({
+            baseUrl: options.homeserverUrl,
+            accessToken: res.access_token,
+            userId: res.user_id,
+            deviceId: res.device_id,
+            cryptoCallbacks: this._cryptoCallbacks,
+        });
+        const session = {
+            accessToken: res.access_token,
+            userId: res.user_id,
+            deviceId: res.device_id,
+            homeserverUrl: options.homeserverUrl,
+        };
+        this.persistSession(session);
+        return session;
+    }
+    async loginWithToken(options) {
+        this.client = matrixJsSdk.createClient({
+            baseUrl: options.homeserverUrl,
+            accessToken: options.accessToken,
+            userId: options.userId,
+            deviceId: options.deviceId,
+            cryptoCallbacks: this._cryptoCallbacks,
+        });
+        const session = {
+            accessToken: options.accessToken,
+            userId: options.userId,
+            deviceId: options.deviceId,
+            homeserverUrl: options.homeserverUrl,
+        };
+        this.persistSession(session);
+        return session;
+    }
+    async logout() {
+        if (this.client) {
+            this.client.stopClient();
+            try {
+                await this.client.logout(true);
+            }
+            catch (_a) {
+                // ignore logout errors (e.g. token already invalidated)
+            }
+            this.client = undefined;
+        }
+        localStorage.removeItem(SESSION_KEY);
+    }
+    async getSession() {
+        const raw = localStorage.getItem(SESSION_KEY);
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    // ── Sync ──────────────────────────────────────────────
+    async startSync() {
+        this.requireClient();
+        this.client.on(matrixJsSdk.ClientEvent.Sync, (state, _prev, data) => {
+            var _a;
+            const mapped = this.mapSyncState(state);
+            this.notifyListeners('syncStateChange', {
+                state: mapped,
+                error: (_a = data === null || data === void 0 ? void 0 : data.error) === null || _a === void 0 ? void 0 : _a.message,
+            });
+        });
+        this.client.on(matrixJsSdk.RoomEvent.Timeline, (event, room) => {
+            var _a;
+            this.notifyListeners('messageReceived', {
+                event: this.serializeEvent(event, room === null || room === void 0 ? void 0 : room.roomId),
+            });
+            // When an encrypted event arrives, listen for decryption and re-notify
+            if (event.isBeingDecrypted() || event.getType() === 'm.room.encrypted') {
+                event.once('Event.decrypted', () => {
+                    this.notifyListeners('messageReceived', {
+                        event: this.serializeEvent(event, room === null || room === void 0 ? void 0 : room.roomId),
+                    });
+                });
+            }
+            // When a reaction or redaction arrives, re-emit the parent event with updated aggregated reactions
+            if (event.getType() === matrixJsSdk.EventType.Reaction || event.getType() === matrixJsSdk.EventType.RoomRedaction) {
+                const rel = (_a = event.getContent()) === null || _a === void 0 ? void 0 : _a['m.relates_to'];
+                const targetId = (rel === null || rel === void 0 ? void 0 : rel.event_id) || event.getAssociatedId();
+                if (targetId && room) {
+                    const targetEvent = room.findEventById(targetId);
+                    if (targetEvent) {
+                        // Small delay to let the SDK finish aggregation
+                        setTimeout(() => {
+                            this.notifyListeners('messageReceived', {
+                                event: this.serializeEvent(targetEvent, room.roomId),
+                            });
+                        }, 100);
+                    }
+                }
+            }
+        });
+        this.client.on(matrixJsSdk.RoomEvent.Receipt, (_event, room) => {
+            var _a;
+            this.notifyListeners('receiptReceived', {
+                roomId: room.roomId,
+            });
+            // Re-emit own sent messages with updated read status
+            const myUserId = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getUserId();
+            if (myUserId) {
+                const timeline = room.getLiveTimeline().getEvents();
+                // Walk backwards through recent events; stop after checking a reasonable batch
+                const limit = Math.min(timeline.length, 50);
+                for (let i = timeline.length - 1; i >= timeline.length - limit; i--) {
+                    const evt = timeline[i];
+                    if (evt.getSender() !== myUserId)
+                        continue;
+                    const serialized = this.serializeEvent(evt, room.roomId);
+                    if (serialized.status === 'read') {
+                        this.notifyListeners('messageReceived', { event: serialized });
+                    }
+                }
+            }
+        });
+        this.client.on(matrixJsSdk.RoomEvent.Name, (room) => {
+            this.notifyListeners('roomUpdated', {
+                roomId: room.roomId,
+                summary: this.serializeRoom(room),
+            });
+        });
+        this.client.on(matrixJsSdk.RoomMemberEvent.Typing, (_event, member) => {
+            var _a, _b;
+            const roomId = member === null || member === void 0 ? void 0 : member.roomId;
+            if (roomId) {
+                const room = this.client.getRoom(roomId);
+                if (room) {
+                    const typingEvent = room.currentState.getStateEvents('m.typing', '');
+                    const userIds = (_b = (_a = typingEvent === null || typingEvent === void 0 ? void 0 : typingEvent.getContent()) === null || _a === void 0 ? void 0 : _a.user_ids) !== null && _b !== void 0 ? _b : [];
+                    this.notifyListeners('typingChanged', { roomId, userIds });
+                }
+            }
+        });
+        this.client.on(matrixJsSdk.UserEvent.Presence, (_event, user) => {
+            var _a, _b, _c;
+            this.notifyListeners('presenceChanged', {
+                userId: user.userId,
+                presence: {
+                    presence: (_a = user.presence) !== null && _a !== void 0 ? _a : 'offline',
+                    statusMsg: (_b = user.presenceStatusMsg) !== null && _b !== void 0 ? _b : undefined,
+                    lastActiveAgo: (_c = user.lastActiveAgo) !== null && _c !== void 0 ? _c : undefined,
+                },
+            });
+        });
+        await this.client.startClient({ initialSyncLimit: 20 });
+    }
+    async stopSync() {
+        this.requireClient();
+        this.client.stopClient();
+    }
+    async getSyncState() {
+        this.requireClient();
+        const raw = this.client.getSyncState();
+        return { state: this.mapSyncState(raw) };
+    }
+    // ── Rooms ─────────────────────────────────────────────
+    async createRoom(options) {
+        var _a;
+        this.requireClient();
+        const createOpts = {
+            visibility: 'private',
+        };
+        if (options.name)
+            createOpts.name = options.name;
+        if (options.topic)
+            createOpts.topic = options.topic;
+        if ((_a = options.invite) === null || _a === void 0 ? void 0 : _a.length)
+            createOpts.invite = options.invite;
+        if (options.preset)
+            createOpts.preset = options.preset;
+        if (options.isDirect)
+            createOpts.is_direct = true;
+        const initialState = [];
+        if (options.isEncrypted) {
+            initialState.push({
+                type: 'm.room.encryption',
+                state_key: '',
+                content: { algorithm: 'm.megolm.v1.aes-sha2' },
+            });
+        }
+        if (options.historyVisibility) {
+            initialState.push({
+                type: 'm.room.history_visibility',
+                state_key: '',
+                content: { history_visibility: options.historyVisibility },
+            });
+        }
+        if (initialState.length > 0) {
+            createOpts.initial_state = initialState;
+        }
+        const res = await this.client.createRoom(createOpts);
+        return { roomId: res.room_id };
+    }
+    async getRooms() {
+        this.requireClient();
+        const rooms = this.client.getRooms().map((r) => this.serializeRoom(r));
+        return { rooms };
+    }
+    async getRoomMembers(options) {
+        this.requireClient();
+        const room = this.client.getRoom(options.roomId);
+        if (!room)
+            throw new Error(`Room ${options.roomId} not found`);
+        await room.loadMembersIfNeeded();
+        const members = room.getMembers().map((m) => {
+            var _a, _b;
+            return ({
+                userId: m.userId,
+                displayName: (_a = m.name) !== null && _a !== void 0 ? _a : undefined,
+                membership: m.membership,
+                avatarUrl: (_b = m.getMxcAvatarUrl()) !== null && _b !== void 0 ? _b : undefined,
+            });
+        });
+        return { members };
+    }
+    async joinRoom(options) {
+        this.requireClient();
+        const room = await this.client.joinRoom(options.roomIdOrAlias);
+        return { roomId: room.roomId };
+    }
+    async leaveRoom(options) {
+        this.requireClient();
+        await this.client.leave(options.roomId);
+    }
+    async forgetRoom(options) {
+        this.requireClient();
+        await this.client.forget(options.roomId);
+    }
+    // ── Messaging ─────────────────────────────────────────
+    async sendMessage(options) {
+        var _a, _b, _c;
+        this.requireClient();
+        const msgtype = (_a = options.msgtype) !== null && _a !== void 0 ? _a : 'm.text';
+        const mediaTypes = ['m.image', 'm.audio', 'm.video', 'm.file'];
+        if (mediaTypes.includes(msgtype) && options.fileUri) {
+            // Media message: upload file then send
+            const response = await fetch(options.fileUri);
+            const blob = await response.blob();
+            const uploadRes = await this.client.uploadContent(blob, {
+                name: options.fileName,
+                type: options.mimeType,
+            });
+            const mxcUrl = uploadRes.content_uri;
+            const content = {
+                msgtype,
+                body: options.body || options.fileName || 'file',
+                url: mxcUrl,
+                info: {
+                    mimetype: options.mimeType,
+                    size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size,
+                },
+            };
+            const res = await this.client.sendMessage(options.roomId, content);
+            return { eventId: res.event_id };
+        }
+        // Text message
+        const msgtypeMap = {
+            'm.text': matrixJsSdk.MsgType.Text,
+            'm.notice': matrixJsSdk.MsgType.Notice,
+            'm.emote': matrixJsSdk.MsgType.Emote,
+        };
+        const mappedType = (_c = msgtypeMap[msgtype]) !== null && _c !== void 0 ? _c : matrixJsSdk.MsgType.Text;
+        const res = await this.client.sendMessage(options.roomId, {
+            msgtype: mappedType,
+            body: options.body,
+        });
+        return { eventId: res.event_id };
+    }
+    async editMessage(options) {
+        this.requireClient();
+        const content = {
+            msgtype: matrixJsSdk.MsgType.Text,
+            body: `* ${options.newBody}`,
+            'm.new_content': {
+                msgtype: matrixJsSdk.MsgType.Text,
+                body: options.newBody,
+            },
+            '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 };
+    }
+    async sendReply(options) {
+        var _a, _b;
+        this.requireClient();
+        const msgtype = (_a = options.msgtype) !== null && _a !== void 0 ? _a : 'm.text';
+        const mediaTypes = ['m.image', 'm.audio', 'm.video', 'm.file'];
+        let content;
+        if (mediaTypes.includes(msgtype) && options.fileUri) {
+            // Media reply: upload file then send with reply relation
+            const response = await fetch(options.fileUri);
+            const blob = await response.blob();
+            const uploadRes = await this.client.uploadContent(blob, {
+                name: options.fileName,
+                type: options.mimeType,
+            });
+            content = {
+                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,
+                },
+                'm.relates_to': {
+                    'm.in_reply_to': {
+                        event_id: options.replyToEventId,
+                    },
+                },
+            };
+        }
+        else {
+            // Text reply
+            content = {
+                msgtype: matrixJsSdk.MsgType.Text,
+                body: options.body,
+                'm.relates_to': {
+                    'm.in_reply_to': {
+                        event_id: options.replyToEventId,
+                    },
+                },
+            };
+        }
+        const res = await this.client.sendMessage(options.roomId, content);
+        return { eventId: res.event_id };
+    }
+    async getRoomMessages(options) {
+        var _a, _b, _c, _d, _e;
+        this.requireClient();
+        const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 20;
+        const room = this.client.getRoom(options.roomId);
+        // If no explicit pagination token, return events from the synced timeline
+        if (!options.from && room) {
+            // Paginate backwards so we have enough events (initial sync may be small)
+            try {
+                await this.client.scrollback(room, limit);
+            }
+            catch (_f) {
+                // scrollback may fail if there's no more history
+            }
+            const timeline = room.getLiveTimeline();
+            const timelineEvents = timeline.getEvents();
+            // Filter out reactions and redactions before slicing — they're aggregated into parent events
+            const displayableEvents = timelineEvents.filter((e) => {
+                const t = e.getType();
+                return t !== matrixJsSdk.EventType.Reaction && t !== matrixJsSdk.EventType.RoomRedaction;
+            });
+            const events = displayableEvents
+                .slice(-limit)
+                .map((e) => this.serializeEvent(e, options.roomId))
+                .sort((a, b) => a.originServerTs - b.originServerTs);
+            const backToken = (_b = timeline.getPaginationToken(matrixJsSdk.Direction.Backward)) !== null && _b !== void 0 ? _b : undefined;
+            return { events, nextBatch: backToken };
+        }
+        // Paginate further back using the token
+        const fromToken = (_c = options.from) !== null && _c !== void 0 ? _c : null;
+        const res = await this.client.createMessagesRequest(options.roomId, fromToken, limit, matrixJsSdk.Direction.Backward);
+        const events = ((_d = res.chunk) !== null && _d !== void 0 ? _d : []).map((e) => {
+            var _a;
+            return ({
+                eventId: e.event_id,
+                roomId: options.roomId,
+                senderId: e.sender,
+                type: e.type,
+                content: ((_a = e.content) !== null && _a !== void 0 ? _a : {}),
+                originServerTs: e.origin_server_ts,
+            });
+        });
+        return { events, nextBatch: (_e = res.end) !== null && _e !== void 0 ? _e : undefined };
+    }
+    async markRoomAsRead(options) {
+        this.requireClient();
+        const room = this.client.getRoom(options.roomId);
+        if (room) {
+            const event = room.findEventById(options.eventId);
+            if (event) {
+                await this.client.sendReadReceipt(event);
+                return;
+            }
+        }
+        // Fallback to HTTP request if event not found locally
+        await this.client.setRoomReadMarkersHttpRequest(options.roomId, options.eventId, options.eventId);
+    }
+    async refreshEventStatuses(options) {
+        this.requireClient();
+        const room = this.client.getRoom(options.roomId);
+        if (!room)
+            return { events: [] };
+        const events = [];
+        for (const eid of options.eventIds) {
+            const event = room.findEventById(eid);
+            if (event) {
+                events.push(this.serializeEvent(event, options.roomId));
+            }
+        }
+        return { events };
+    }
+    // ── Redactions & Reactions ───────────────────────────────
+    async redactEvent(options) {
+        this.requireClient();
+        await this.client.redactEvent(options.roomId, options.eventId, undefined, {
+            reason: options.reason,
+        });
+    }
+    async sendReaction(options) {
+        this.requireClient();
+        const myUserId = this.client.getUserId();
+        // Check if the user already reacted with this key — if so, toggle off (redact)
+        const room = this.client.getRoom(options.roomId);
+        if (room && myUserId) {
+            try {
+                const relations = room.relations.getChildEventsForEvent(options.eventId, matrixJsSdk.RelationType.Annotation, matrixJsSdk.EventType.Reaction);
+                if (relations) {
+                    const existing = relations.getRelations().find((e) => { var _a, _b; return e.getSender() === myUserId && ((_b = (_a = e.getContent()) === null || _a === void 0 ? void 0 : _a['m.relates_to']) === null || _b === void 0 ? void 0 : _b.key) === options.key; });
+                    if (existing) {
+                        const existingId = existing.getId();
+                        if (existingId) {
+                            await this.client.redactEvent(options.roomId, existingId);
+                            return { eventId: existingId };
+                        }
+                    }
+                }
+            }
+            catch (_a) {
+                // fall through to send
+            }
+        }
+        const res = await this.client.sendEvent(options.roomId, matrixJsSdk.EventType.Reaction, {
+            'm.relates_to': {
+                rel_type: matrixJsSdk.RelationType.Annotation,
+                event_id: options.eventId,
+                key: options.key,
+            },
+        });
+        return { eventId: res.event_id };
+    }
+    // ── Room Management ────────────────────────────────────
+    async setRoomName(options) {
+        this.requireClient();
+        await this.client.setRoomName(options.roomId, options.name);
+    }
+    async setRoomTopic(options) {
+        this.requireClient();
+        await this.client.setRoomTopic(options.roomId, options.topic);
+    }
+    async setRoomAvatar(options) {
+        this.requireClient();
+        await this.client.sendStateEvent(options.roomId, 'm.room.avatar', { url: options.mxcUrl });
+    }
+    async inviteUser(options) {
+        this.requireClient();
+        await this.client.invite(options.roomId, options.userId);
+    }
+    async kickUser(options) {
+        this.requireClient();
+        await this.client.kick(options.roomId, options.userId, options.reason);
+    }
+    async banUser(options) {
+        this.requireClient();
+        await this.client.ban(options.roomId, options.userId, options.reason);
+    }
+    async unbanUser(options) {
+        this.requireClient();
+        await this.client.unban(options.roomId, options.userId);
+    }
+    // ── Typing ─────────────────────────────────────────────
+    async sendTyping(options) {
+        var _a;
+        this.requireClient();
+        await this.client.sendTyping(options.roomId, options.isTyping, (_a = options.timeout) !== null && _a !== void 0 ? _a : 30000);
+    }
+    // ── Media ──────────────────────────────────────────────
+    async getMediaUrl(options) {
+        this.requireClient();
+        // Use the authenticated media endpoint (Matrix v1.11+)
+        const mxcPath = options.mxcUrl.replace('mxc://', '');
+        const baseUrl = this.client.getHomeserverUrl().replace(/\/$/, '');
+        const accessToken = this.client.getAccessToken();
+        const httpUrl = `${baseUrl}/_matrix/client/v1/media/download/${mxcPath}?access_token=${accessToken}`;
+        return { httpUrl };
+    }
+    async getThumbnailUrl(options) {
+        var _a;
+        this.requireClient();
+        const mxcPath = options.mxcUrl.replace('mxc://', '');
+        const baseUrl = this.client.getHomeserverUrl().replace(/\/$/, '');
+        const accessToken = this.client.getAccessToken();
+        const method = (_a = options.method) !== null && _a !== void 0 ? _a : 'scale';
+        const httpUrl = `${baseUrl}/_matrix/client/v1/media/thumbnail/${mxcPath}?width=${options.width}&height=${options.height}&method=${method}&access_token=${accessToken}`;
+        return { httpUrl };
+    }
+    async uploadContent(options) {
+        this.requireClient();
+        const response = await fetch(options.fileUri);
+        const blob = await response.blob();
+        const res = await this.client.uploadContent(blob, {
+            name: options.fileName,
+            type: options.mimeType,
+        });
+        return { contentUri: res.content_uri };
+    }
+    // ── Presence ───────────────────────────────────────────
+    async setPresence(options) {
+        this.requireClient();
+        await this.client.setPresence({
+            presence: options.presence,
+            status_msg: options.statusMsg,
+        });
+    }
+    async getPresence(options) {
+        var _a, _b, _c;
+        this.requireClient();
+        const user = this.client.getUser(options.userId);
+        return {
+            presence: (_a = user === null || user === void 0 ? void 0 : user.presence) !== null && _a !== void 0 ? _a : 'offline',
+            statusMsg: (_b = user === null || user === void 0 ? void 0 : user.presenceStatusMsg) !== null && _b !== void 0 ? _b : undefined,
+            lastActiveAgo: (_c = user === null || user === void 0 ? void 0 : user.lastActiveAgo) !== null && _c !== void 0 ? _c : undefined,
+        };
+    }
+    // ── Device Management ──────────────────────────────────
+    async getDevices() {
+        var _a;
+        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 ({
+                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,
+            });
+        });
+        return { devices };
+    }
+    async deleteDevice(options) {
+        this.requireClient();
+        await this.client.deleteDevice(options.deviceId, options.auth);
+    }
+    // ── Push ──────────────────────────────────────────────
+    async setPusher(options) {
+        var _a;
+        this.requireClient();
+        await this.client.setPusher({
+            pushkey: options.pushkey,
+            kind: (_a = options.kind) !== null && _a !== void 0 ? _a : undefined,
+            app_id: options.appId,
+            app_display_name: options.appDisplayName,
+            device_display_name: options.deviceDisplayName,
+            lang: options.lang,
+            data: options.data,
+        });
+    }
+    // ── Encryption ──────────────────────────────────────────
+    async initializeCrypto() {
+        this.requireClient();
+        const userId = this.client.getUserId();
+        const deviceId = this.client.getDeviceId();
+        await this.client.initRustCrypto({
+            cryptoDatabasePrefix: `matrix-js-sdk/${userId}/${deviceId}`,
+        });
+    }
+    async getEncryptionStatus() {
+        this.requireClient();
+        const crypto = this.client.getCrypto();
+        if (!crypto) {
+            return {
+                isCrossSigningReady: false,
+                crossSigningStatus: { hasMaster: false, hasSelfSigning: false, hasUserSigning: false, isReady: false },
+                isKeyBackupEnabled: false,
+                isSecretStorageReady: false,
+            };
+        }
+        const csReady = await crypto.isCrossSigningReady();
+        const csStatus = await crypto.getCrossSigningStatus();
+        const backupVersion = await crypto.getActiveSessionBackupVersion();
+        // Use getSecretStorageStatus().defaultKeyId to check if secret storage was
+        // set up at all, rather than isSecretStorageReady() which also checks that
+        // cross-signing keys are stored (too strict for Phase 1).
+        const ssStatus = await crypto.getSecretStorageStatus();
+        const ssHasKey = ssStatus.defaultKeyId !== null;
+        return {
+            isCrossSigningReady: csReady,
+            crossSigningStatus: {
+                hasMaster: csStatus.publicKeysOnDevice,
+                hasSelfSigning: csStatus.privateKeysCachedLocally.selfSigningKey,
+                hasUserSigning: csStatus.privateKeysCachedLocally.userSigningKey,
+                isReady: csReady,
+            },
+            isKeyBackupEnabled: backupVersion !== null,
+            keyBackupVersion: backupVersion !== null && backupVersion !== void 0 ? backupVersion : undefined,
+            isSecretStorageReady: ssHasKey,
+        };
+    }
+    async bootstrapCrossSigning() {
+        const crypto = await this.ensureCrypto();
+        await crypto.bootstrapCrossSigning({
+            setupNewCrossSigning: true,
+            authUploadDeviceSigningKeys: async (makeRequest) => {
+                var _a;
+                // UIA flow: attempt with dummy auth, fall back to session-based retry
+                try {
+                    await makeRequest({ type: 'm.login.dummy' });
+                }
+                catch (e) {
+                    const session = (_a = e === null || e === void 0 ? void 0 : e.data) === null || _a === void 0 ? void 0 : _a.session;
+                    if (session) {
+                        await makeRequest({ type: 'm.login.dummy', session });
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            },
+        });
+    }
+    async setupKeyBackup() {
+        const crypto = await this.ensureCrypto();
+        await crypto.resetKeyBackup();
+        const version = await crypto.getActiveSessionBackupVersion();
+        return { exists: true, version: version !== null && version !== void 0 ? version : undefined, enabled: true };
+    }
+    async getKeyBackupStatus() {
+        this.requireClient();
+        const crypto = this.requireCrypto();
+        const version = await crypto.getActiveSessionBackupVersion();
+        return {
+            exists: version !== null,
+            version: version !== null && version !== void 0 ? version : undefined,
+            enabled: version !== null,
+        };
+    }
+    async restoreKeyBackup(_options) {
+        var _a;
+        this.requireClient();
+        const crypto = this.requireCrypto();
+        const result = await crypto.restoreKeyBackup();
+        return { importedKeys: (_a = result === null || result === void 0 ? void 0 : result.imported) !== null && _a !== void 0 ? _a : 0 };
+    }
+    async setupRecovery(options) {
+        var _a;
+        const crypto = await this.ensureCrypto();
+        const keyInfo = await crypto.createRecoveryKeyFromPassphrase(options === null || options === void 0 ? void 0 : options.passphrase);
+        this.secretStorageKey = keyInfo.privateKey;
+        await crypto.bootstrapSecretStorage({
+            createSecretStorageKey: async () => keyInfo,
+            setupNewSecretStorage: true,
+            setupNewKeyBackup: true,
+        });
+        return { recoveryKey: (_a = keyInfo.encodedPrivateKey) !== null && _a !== void 0 ? _a : '' };
+    }
+    async isRecoveryEnabled() {
+        const crypto = await this.ensureCrypto();
+        const ready = await crypto.isSecretStorageReady();
+        return { enabled: ready };
+    }
+    async recoverAndSetup(options) {
+        const crypto = await this.ensureCrypto();
+        // Derive/decode the secret storage key
+        if (options.recoveryKey) {
+            this.secretStorageKey = recoveryKey.decodeRecoveryKey(options.recoveryKey);
+        }
+        else if (options.passphrase) {
+            // Store passphrase — the getSecretStorageKey callback will derive
+            // the key using the server's stored PBKDF2 params (salt, iterations)
+            this.recoveryPassphrase = options.passphrase;
+            this.secretStorageKey = undefined; // Clear any stale raw key
+        }
+        else {
+            throw new Error('Either recoveryKey or passphrase must be provided');
+        }
+        // Load the backup decryption key from secret storage into the Rust crypto store.
+        // This triggers the getSecretStorageKey callback.
+        try {
+            await crypto.loadSessionBackupPrivateKeyFromSecretStorage();
+        }
+        catch (e) {
+            // Clear stale key material so the next attempt starts fresh
+            this.secretStorageKey = undefined;
+            this.recoveryPassphrase = undefined;
+            throw e;
+        }
+        // Now that the key is stored locally, activate backup in the running client
+        await crypto.checkKeyBackupAndEnable();
+    }
+    async resetRecoveryKey(options) {
+        return this.setupRecovery(options);
+    }
+    async exportRoomKeys(options) {
+        this.requireClient();
+        const crypto = this.requireCrypto();
+        const keys = await crypto.exportRoomKeysAsJson();
+        // The exported JSON is not encrypted by default; for passphrase encryption
+        // the caller should handle it, or we return the raw JSON
+        void options.passphrase; // passphrase encryption is handled natively; on web we return raw
+        return { data: keys };
+    }
+    async importRoomKeys(options) {
+        this.requireClient();
+        const crypto = this.requireCrypto();
+        void options.passphrase; // passphrase decryption handled natively; on web we import raw
+        await crypto.importRoomKeysAsJson(options.data);
+        return { importedKeys: -1 }; // count not available from importRoomKeysAsJson
+    }
+    // ── Helpers ───────────────────────────────────────────
+    requireClient() {
+        if (!this.client) {
+            throw new Error('Not logged in. Call login() or loginWithToken() first.');
+        }
+    }
+    requireCrypto() {
+        const crypto = this.client.getCrypto();
+        if (!crypto) {
+            throw new Error('Crypto not initialized. Call initializeCrypto() first.');
+        }
+        return crypto;
+    }
+    async ensureCrypto() {
+        this.requireClient();
+        if (!this.client.getCrypto()) {
+            await this.initializeCrypto();
+        }
+        return this.requireCrypto();
+    }
+    persistSession(session) {
+        localStorage.setItem(SESSION_KEY, JSON.stringify(session));
+    }
+    serializeEvent(event, fallbackRoomId) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const roomId = (_b = (_a = event.getRoomId()) !== null && _a !== void 0 ? _a : fallbackRoomId) !== null && _b !== void 0 ? _b : '';
+        // Redacted events should be marked clearly
+        if (event.isRedacted()) {
+            return {
+                eventId: (_c = event.getId()) !== null && _c !== void 0 ? _c : '',
+                roomId,
+                senderId: (_d = event.getSender()) !== null && _d !== void 0 ? _d : '',
+                type: 'm.room.redaction',
+                content: { body: 'Message deleted' },
+                originServerTs: event.getTs(),
+            };
+        }
+        const content = Object.assign({}, ((_e = event.getContent()) !== null && _e !== void 0 ? _e : {}));
+        // Include aggregated reactions from the room's relations container
+        const eventId = event.getId();
+        if (eventId && roomId) {
+            const room = (_f = this.client) === null || _f === void 0 ? void 0 : _f.getRoom(roomId);
+            if (room) {
+                try {
+                    const relations = room.relations.getChildEventsForEvent(eventId, matrixJsSdk.RelationType.Annotation, matrixJsSdk.EventType.Reaction);
+                    if (relations) {
+                        const sorted = relations.getSortedAnnotationsByKey();
+                        if (sorted && sorted.length > 0) {
+                            content.reactions = sorted.map(([key, events]) => ({
+                                key,
+                                count: events.size,
+                                senders: Array.from(events).map((e) => e.getSender()),
+                            }));
+                        }
+                    }
+                }
+                catch (_k) {
+                    // relations may not be available
+                }
+            }
+        }
+        // Determine delivery/read status
+        let status;
+        const readBy = [];
+        const myUserId = (_g = this.client) === null || _g === void 0 ? void 0 : _g.getUserId();
+        const sender = event.getSender();
+        const room = eventId && roomId ? (_h = this.client) === null || _h === void 0 ? void 0 : _h.getRoom(roomId) : undefined;
+        if (sender === myUserId && eventId) {
+            // Own message — check delivery status
+            const evtStatus = event.status; // null = sent & echoed, 'sending', 'sent', etc.
+            if (evtStatus === 'sending' || evtStatus === 'encrypting' || evtStatus === 'queued') {
+                status = 'sending';
+            }
+            else {
+                // Event is at least sent; check if anyone has read it
+                if (room) {
+                    try {
+                        const members = room.getJoinedMembers();
+                        for (const member of members) {
+                            if (member.userId === myUserId)
+                                continue;
+                            if (room.hasUserReadEvent(member.userId, eventId)) {
+                                readBy.push(member.userId);
+                            }
+                        }
+                    }
+                    catch (_l) {
+                        // ignore errors
+                    }
+                }
+                status = readBy.length > 0 ? 'read' : 'sent';
+            }
+        }
+        else if (eventId && room) {
+            // Other's message — collect who has read it
+            try {
+                const members = room.getJoinedMembers();
+                for (const member of members) {
+                    if (member.userId === sender)
+                        continue;
+                    if (room.hasUserReadEvent(member.userId, eventId)) {
+                        readBy.push(member.userId);
+                    }
+                }
+            }
+            catch (_m) {
+                // ignore
+            }
+        }
+        // Include unsigned data (e.g. m.relations for edits, transaction_id for local echo)
+        const unsignedData = (_j = event.getUnsigned) === null || _j === void 0 ? void 0 : _j.call(event);
+        const unsigned = unsignedData && Object.keys(unsignedData).length > 0
+            ? unsignedData
+            : undefined;
+        return {
+            eventId: eventId !== null && eventId !== void 0 ? eventId : '',
+            roomId,
+            senderId: sender !== null && sender !== void 0 ? sender : '',
+            type: event.getType(),
+            content,
+            originServerTs: event.getTs(),
+            status,
+            readBy: readBy.length > 0 ? readBy : undefined,
+            unsigned,
+        };
+    }
+    serializeRoom(room) {
+        var _a, _b, _c, _d, _e, _f;
+        // Detect DM: check m.direct account data or guess from room state
+        let isDirect = false;
+        try {
+            const directEvent = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getAccountData('m.direct');
+            if (directEvent) {
+                const directContent = directEvent.getContent();
+                for (const roomIds of Object.values(directContent)) {
+                    if (roomIds.includes(room.roomId)) {
+                        isDirect = true;
+                        break;
+                    }
+                }
+            }
+        }
+        catch (_g) {
+            // ignore
+        }
+        // Get avatar URL
+        let avatarUrl;
+        const avatarEvent = room.currentState.getStateEvents('m.room.avatar', '');
+        if (avatarEvent) {
+            const mxcUrl = (_b = avatarEvent.getContent()) === null || _b === void 0 ? void 0 : _b.url;
+            if (mxcUrl) {
+                avatarUrl = mxcUrl;
+            }
+        }
+        return {
+            roomId: room.roomId,
+            name: room.name,
+            topic: (_e = (_d = (_c = room.currentState.getStateEvents('m.room.topic', '')) === null || _c === void 0 ? void 0 : _c.getContent()) === null || _d === void 0 ? void 0 : _d.topic) !== null && _e !== void 0 ? _e : undefined,
+            memberCount: room.getJoinedMemberCount(),
+            isEncrypted: room.hasEncryptionStateEvent(),
+            unreadCount: (_f = room.getUnreadNotificationCount()) !== null && _f !== void 0 ? _f : 0,
+            lastEventTs: room.getLastActiveTimestamp() || undefined,
+            membership: room.getMyMembership(),
+            avatarUrl,
+            isDirect,
+        };
+    }
+    async searchUsers(options) {
+        var _a;
+        this.requireClient();
+        const resp = await this.client.searchUserDirectory({
+            term: options.searchTerm,
+            limit: (_a = options.limit) !== null && _a !== void 0 ? _a : 10,
+        });
+        return {
+            results: resp.results.map((u) => ({
+                userId: u.user_id,
+                displayName: u.display_name,
+                avatarUrl: u.avatar_url,
+            })),
+            limited: resp.limited,
+        };
+    }
+    mapSyncState(state) {
+        switch (state) {
+            case 'PREPARED':
+            case 'SYNCING':
+            case 'CATCHUP':
+            case 'RECONNECTING':
+                return 'SYNCING';
+            case 'ERROR':
+                return 'ERROR';
+            case 'STOPPED':
+                return 'STOPPED';
+            default:
+                return 'INITIAL';
+        }
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MatrixWeb: MatrixWeb
+});
+
+exports.Matrix = Matrix;
+//# sourceMappingURL=plugin.cjs.js.map