import type { CryptoCallbacks, MatrixClient, ISyncStateData } from '$types/matrix-sdk'; import { ClientEvent, createClient, Filter, IndexedDBStore, IndexedDBCryptoStore, SyncState, } from '$types/matrix-sdk'; import { clearNavToActivePathStore } from '$state/navToActivePath'; import type { Session, Sessions, SessionStoreName } from '$state/sessions'; import { getSessionStoreName, MATRIX_SESSIONS_KEY } from '$state/sessions'; import { getLocalStorageItem } from '$state/utils/atomWithLocalStorage'; import { createLogger } from '$utils/debug'; import { createDebugLogger } from '$utils/debugLogger'; import * as Sentry from '@sentry/react'; import { pushSessionToSW } from '../sw-session'; import { cryptoCallbacks } from './secretStorageKeys'; import type { SlidingSyncConfig, SlidingSyncDiagnostics } from './slidingSync'; import { SlidingSyncManager } from './slidingSync'; const log = createLogger('initMatrix'); const debugLog = createDebugLogger('initMatrix'); const slidingSyncByClient = new WeakMap(); const classicSyncObserverByClient = new WeakMap< MatrixClient, (state: SyncState, prevState: SyncState | null, data?: ISyncStateData) => void >(); const FAST_SYNC_POLL_TIMEOUT_MS = 30_000; const SLIDING_SYNC_POLL_TIMEOUT_MS = 20000; type SyncTransport = 'classic' | 'sliding'; type SyncTransportReason = | 'sliding_active' | 'sliding_disabled_server' | 'session_opt_out' | 'missing_proxy' | 'cold_cache_bootstrap' | 'probe_failed_fallback' | 'unknown'; type SyncTransportMeta = { transport: SyncTransport; slidingConfigured: boolean; slidingEnabledOnServer: boolean; sessionOptIn: boolean; slidingRequested: boolean; fallbackFromSliding: boolean; reason: SyncTransportReason; }; const syncTransportByClient = new WeakMap(); const fetchRoomEventStartupCleanupByClient = new WeakMap void>(); const COLD_CACHE_BOOTSTRAP_TIMEOUT_MS = 20000; type FetchRoomEventResult = Awaited>; type MatrixClientWithWritableFetchRoomEvent = MatrixClient & { fetchRoomEvent: (roomId: string, eventId: string) => Promise; }; // Replace fetchRoomEvent for first sync so thread roots don't each trigger GET /event // Uses cached timeline events when present otherwise a stub that fetches when user opens thread function installStartupFetchRoomEventPatch(mx: MatrixClient): void { fetchRoomEventStartupCleanupByClient.get(mx)?.(); const mxWritable = mx as MatrixClientWithWritableFetchRoomEvent; const origFetchRoomEvent = mx.fetchRoomEvent.bind(mx); let restored = false; const restore = () => { if (restored) return; restored = true; fetchRoomEventStartupCleanupByClient.delete(mx); // Put the real fetchRoomEvent back and detach this mxWritable.fetchRoomEvent = origFetchRoomEvent; mx.off(ClientEvent.Sync, onSync); }; const onSync = (state: SyncState) => { // Initial sync burst is over, let normal server fetches run again if (state === SyncState.Prepared || state === SyncState.Syncing) { restore(); } }; mxWritable.fetchRoomEvent = (roomId: string, eventId: string) => { if (restored) return origFetchRoomEvent(roomId, eventId); const cachedEvent = mx.getRoom(roomId)?.findEventById(eventId); // Reuse sync payload instead of another GET when we already have the root. const payload: FetchRoomEventResult = cachedEvent?.event ?? { event_id: eventId, room_id: roomId, }; return Promise.resolve(payload); }; mx.on(ClientEvent.Sync, onSync); fetchRoomEventStartupCleanupByClient.set(mx, restore); } export const resolveSlidingEnabled = (enabled: SlidingSyncConfig['enabled']): boolean => { if (enabled === undefined) return false; if (typeof enabled === 'boolean') return enabled; const normalized = String(enabled).trim().toLowerCase(); if (normalized === 'false' || normalized === '0' || normalized === 'off' || normalized === 'no') return false; if (normalized === 'true' || normalized === '1' || normalized === 'on' || normalized === 'yes') return true; return false; }; const deleteDatabase = (name: string): Promise => new Promise((resolve) => { const req = window.indexedDB.deleteDatabase(name); req.addEventListener('success', () => resolve()); req.addEventListener('error', () => resolve()); // resolve anyway — we tried req.addEventListener('blocked', () => resolve()); }); const deleteSyncStoreGroup = async (syncStoreName: string): Promise => { await Promise.all([ deleteDatabase(syncStoreName), deleteDatabase(syncStoreName.replace(/^sync/, 'crypto')), deleteDatabase(`${syncStoreName}::matrix-sdk-crypto`), ]); }; const deleteSessionStores = async (storeName: SessionStoreName): Promise => { await Promise.all([ deleteDatabase(storeName.sync), deleteDatabase(storeName.crypto), deleteDatabase(`${storeName.rustCryptoPrefix}::matrix-sdk-crypto`), ]); }; /** * Reads the account stored in an IndexedDB sync store without opening a full MatrixClient. * Returns undefined if the database doesn't exist or has no account record. */ const readStoredAccount = (dbName: string): Promise => new Promise((resolve) => { let settled = false; const finish = (value: string | undefined) => { if (settled) return; settled = true; resolve(value); }; const req = window.indexedDB.open(dbName); req.addEventListener('error', () => finish(undefined)); req.addEventListener('success', () => { const db = req.result; try { if (!db.objectStoreNames.contains('account')) { db.close(); finish(undefined); } else { const tx = db.transaction('account', 'readonly'); const store = tx.objectStore('account'); const getReq = store.get('account'); getReq.addEventListener('success', () => { db.close(); const record = getReq.result; if (!record?.account_data) { finish(undefined); } else { try { const data = JSON.parse(record.account_data); finish(data?.user_id ?? undefined); } catch { finish(undefined); } } }); getReq.addEventListener('error', () => { db.close(); finish(undefined); }); } } catch { try { db.close(); } catch { /* ignore */ } finish(undefined); } }); }); const databaseExists = async (dbName: string): Promise => { try { const dbs = await window.indexedDB.databases(); return dbs.some((db) => db.name === dbName); } catch { return false; } }; const isClientReadyForUi = (syncState: string | null): boolean => syncState === 'PREPARED' || syncState === 'SYNCING' || syncState === 'CATCHUP'; const isMismatch = (err: unknown): boolean => { const msg = err instanceof Error ? err.message : String(err); return ( msg.includes("doesn't match") || msg.includes('does not match') || msg.includes('account in the store') || msg.includes('account in the constructor') ); }; const waitForClientReady = (mx: MatrixClient, timeoutMs: number): Promise => /* oxlint-disable promise/no-multiple-resolved */ new Promise((resolve) => { const waitStart = performance.now(); let settled = false; const finish = () => { if (settled) return; settled = true; mx.removeListener(ClientEvent.Sync, onSync); clearTimeout(timer); const waitMs = performance.now() - waitStart; Sentry.metrics.distribution('sable.sync.client_ready_ms', waitMs, { attributes: { timed_out: String(timedOut) }, }); if (timedOut) { Sentry.addBreadcrumb({ category: 'sync', message: 'waitForClientReady timed out — client may be stuck', level: 'warning', data: { timeout_ms: timeoutMs }, }); } resolve(); }; /* oxlint-enable promise/no-multiple-resolved */ if (isClientReadyForUi(mx.getSyncState())) { Sentry.metrics.distribution('sable.sync.client_ready_ms', 0, { attributes: { timed_out: 'false' }, }); finish(); return; } let timer = 0; let timedOut = false; const onSync = (state: string) => { debugLog.info('sync', `Sync state changed: ${state}`, { state, ready: isClientReadyForUi(state), }); if (isClientReadyForUi(state)) finish(); }; timer = window.setTimeout(() => { timedOut = true; finish(); }, timeoutMs); mx.on(ClientEvent.Sync, onSync); }); /** * Pre-flight check: scans every IndexedDB database and deletes any that * belong to a userId not present in the stored sessions list, or whose * sync-store data contradicts the expected session userId. * Call this once on startup before initClient. */ export const clearMismatchedStores = async (): Promise => { const sessions = getLocalStorageItem(MATRIX_SESSIONS_KEY, []); const knownUserIds = new Set(sessions.map((s) => s.userId)); const knownStoreNames = new Set( sessions.flatMap((s) => { const sn = getSessionStoreName(s); return [sn.sync, sn.crypto, `${sn.rustCryptoPrefix}::matrix-sdk-crypto`]; }) ); let allDbs: IDBDatabaseInfo[] = []; try { allDbs = await window.indexedDB.databases(); } catch { // databases() not supported in all browsers } await Promise.all( allDbs.map(async ({ name }) => { if (!name) return; const containsKnownUser = Array.from(knownUserIds).some((uid) => name.includes(uid)); const looksLikeUserDb = name.includes('@'); if (looksLikeUserDb && !containsKnownUser && !knownStoreNames.has(name)) { log.warn(`clearMismatchedStores: "${name}" has unknown user — deleting`); await deleteDatabase(name); return; } if (!name.startsWith('sync')) return; const storedUserId = await readStoredAccount(name); if (!storedUserId) return; if (!knownUserIds.has(storedUserId)) { log.warn(`clearMismatchedStores: "${name}" has unknown user ${storedUserId} — deleting`); await deleteSyncStoreGroup(name); return; } const expectedStore = `sync${storedUserId}`; if (name !== expectedStore && !knownStoreNames.has(name)) { log.warn(`clearMismatchedStores: "${name}" is misplaced for ${storedUserId} — deleting`); await deleteSyncStoreGroup(name); } }) ); await Promise.all( sessions.map(async (session) => { const sn = getSessionStoreName(session); const storedUserId = await readStoredAccount(sn.sync); if (storedUserId && storedUserId !== session.userId) { log.warn( `clearMismatchedStores: "${sn.sync}" has ${storedUserId} but session is ${session.userId} — deleting` ); await deleteSessionStores(sn); } }) ); }; const buildClient = async (session: Session): Promise => { const storeName = getSessionStoreName(session); const indexedDBStore = new IndexedDBStore({ indexedDB: global.indexedDB, localStorage: global.localStorage, dbName: storeName.sync, }); const legacyCryptoStore = new IndexedDBCryptoStore(global.indexedDB, storeName.crypto); const mx = createClient({ baseUrl: session.baseUrl, accessToken: session.accessToken, userId: session.userId, store: indexedDBStore, cryptoStore: legacyCryptoStore, deviceId: session.deviceId, timelineSupport: true, cryptoCallbacks: cryptoCallbacks as unknown as CryptoCallbacks, verificationMethods: ['m.sas.v1'], }); await indexedDBStore.startup(); return mx; }; export const initClient = async (session: Session): Promise => { const storeName = getSessionStoreName(session); debugLog.info('sync', 'Initializing Matrix client', { userId: session.userId, baseUrl: session.baseUrl, }); const wipeAllStores = async () => { log.warn('initClient: wiping all stores for', session.userId); debugLog.warn('sync', 'Wiping all stores due to mismatch', { userId: session.userId, }); Sentry.addBreadcrumb({ category: 'crypto', message: 'Crypto store mismatch — wiping local stores and retrying', level: 'warning', }); Sentry.metrics.count('sable.crypto.store_wipe', 1); await deleteSessionStores(storeName); try { const allDbs = await window.indexedDB.databases(); await Promise.all( allDbs.map(async ({ name }) => { if (name && name.includes(session.userId)) { log.warn('initClient: also wiping db', name); await deleteDatabase(name); } }) ); } catch { // databases() not available in all browsers } }; let mx: MatrixClient; try { mx = await buildClient(session); } catch (err) { if (!isMismatch(err)) { debugLog.error('sync', 'Failed to build client', { error: err }); throw err; } log.warn('initClient: mismatch on buildClient — wiping and retrying:', err); debugLog.warn('sync', 'Client build mismatch - wiping stores and retrying', { error: err }); await wipeAllStores(); mx = await buildClient(session); } try { await mx.initRustCrypto({ cryptoDatabasePrefix: storeName.rustCryptoPrefix, }); } catch (err) { if (!isMismatch(err)) { debugLog.error('sync', 'Failed to initialize crypto', { error: err }); throw err; } log.warn('initClient: mismatch on initRustCrypto — wiping and retrying:', err); debugLog.warn('sync', 'Crypto init mismatch - wiping stores and retrying', { error: err, }); mx.stopClient(); await wipeAllStores(); mx = await buildClient(session); await mx.initRustCrypto({ cryptoDatabasePrefix: storeName.rustCryptoPrefix, }); } mx.setMaxListeners(50); return mx; }; export type StartClientConfig = { baseUrl?: string; slidingSync?: SlidingSyncConfig; sessionSlidingSyncOptIn?: boolean; pollTimeoutMs?: number; timelineLimit?: number; }; export type ClientSyncDiagnostics = SyncTransportMeta & { syncState: string | null; sliding?: SlidingSyncDiagnostics; }; const disposeSlidingSync = (mx: MatrixClient): void => { const manager = slidingSyncByClient.get(mx); if (!manager) return; manager.dispose(); slidingSyncByClient.delete(mx); }; export const getSlidingSyncManager = (mx: MatrixClient): SlidingSyncManager | undefined => slidingSyncByClient.get(mx); export const startClient = async (mx: MatrixClient, config?: StartClientConfig): Promise => { debugLog.info('sync', 'Starting Matrix client', { userId: mx.getUserId() }); disposeSlidingSync(mx); const slidingConfig = config?.slidingSync; const slidingEnabledOnServer = resolveSlidingEnabled(slidingConfig?.enabled); const slidingRequested = slidingEnabledOnServer && config?.sessionSlidingSyncOptIn === true; const proxyBaseUrl = slidingConfig?.proxyBaseUrl ?? config?.baseUrl; const hasSlidingProxy = typeof proxyBaseUrl === 'string' && proxyBaseUrl.trim().length > 0; log.log('startClient sliding config', { userId: mx.getUserId(), enabled: slidingConfig?.enabled, enabledOnServer: slidingEnabledOnServer, sessionOptIn: config?.sessionSlidingSyncOptIn === true, requestedEnabled: slidingRequested, proxyBaseUrl, hasSlidingProxy, }); debugLog.info('sync', 'Sliding sync configuration', { enabledOnServer: slidingEnabledOnServer, requested: slidingRequested, hasProxy: hasSlidingProxy, }); const CLASSIC_SYNC_STARTUP_TIMEOUT_MS = 45_000; const startClassicSync = async ( fallbackFromSliding: boolean, reason: SyncTransportReason ): Promise => { syncTransportByClient.set(mx, { transport: 'classic', slidingConfigured: slidingEnabledOnServer, slidingEnabledOnServer, sessionOptIn: config?.sessionSlidingSyncOptIn === true, slidingRequested, fallbackFromSliding, reason, }); Sentry.metrics.count('sable.sync.transport', 1, { attributes: { transport: 'classic', reason, fallback: String(fallbackFromSliding), }, }); const startupTimeout = new Promise((resolve) => { window.setTimeout(() => { debugLog.warn('sync', 'Classic sync startup timed out', { userId: mx.getUserId(), timeoutMs: CLASSIC_SYNC_STARTUP_TIMEOUT_MS, }); resolve(); }, CLASSIC_SYNC_STARTUP_TIMEOUT_MS); }); const effectivePollTimeout = config?.pollTimeoutMs ?? FAST_SYNC_POLL_TIMEOUT_MS; const effectiveTimelineLimit = config?.timelineLimit ?? 10; const classicFilter = new Filter(mx.getUserId() ?? undefined); classicFilter.setTimelineLimit(effectiveTimelineLimit); // Ensure lazy loading stays on (carried by buildDefaultFilter but explicit here // since we replace the filter entirely rather than merging). const filterDefinition = classicFilter.getDefinition(); if (filterDefinition.room) { filterDefinition.room.timeline = filterDefinition.room.timeline ?? {}; (filterDefinition.room.timeline as { lazy_load_members?: boolean }).lazy_load_members = true; } installStartupFetchRoomEventPatch(mx); let syncStarted: Promise; try { syncStarted = mx.startClient({ lazyLoadMembers: true, pollTimeout: effectivePollTimeout, threadSupport: true, filter: classicFilter, }); } catch (syncErr) { fetchRoomEventStartupCleanupByClient.get(mx)?.(); throw syncErr; } await Promise.race([syncStarted, startupTimeout]); // Attach an ongoing classic-sync observer — equivalent to SlidingSyncManager's // onLifecycle listener. Tracks state transitions, initial-sync timing, and errors. let classicSyncCount = 0; const classicSyncStartMs = performance.now(); let classicInitialSyncDone = false; const classicSyncListener = ( state: SyncState, prevState: SyncState | null, data?: ISyncStateData ) => { classicSyncCount += 1; Sentry.metrics.count('sable.sync.cycle', 1, { attributes: { transport: 'classic', state }, }); debugLog.info('sync', `Classic sync state: ${state}`, { state, prevState: prevState ?? 'null', syncNumber: classicSyncCount, error: data?.error?.message, }); if (state === SyncState.Error || state === SyncState.Reconnecting) { debugLog.warn('sync', `Classic sync problem: ${state}`, { state, prevState: prevState ?? 'null', errorMessage: data?.error?.message, syncNumber: classicSyncCount, }); Sentry.metrics.count('sable.sync.error', 1, { attributes: { transport: 'classic', state }, }); Sentry.addBreadcrumb({ category: 'sync.classic', message: `Classic sync problem: ${state}`, level: 'warning', data: { state, prevState, error: data?.error?.message, syncNumber: classicSyncCount, }, }); } if ( !classicInitialSyncDone && (state === SyncState.Syncing || state === SyncState.Prepared) ) { classicInitialSyncDone = true; const elapsed = performance.now() - classicSyncStartMs; debugLog.info('sync', 'Classic sync initial ready', { state, syncNumber: classicSyncCount, elapsed: `${elapsed.toFixed(0)}ms`, }); Sentry.metrics.distribution('sable.sync.initial_ms', elapsed, { attributes: { transport: 'classic' }, }); } }; classicSyncObserverByClient.set(mx, classicSyncListener); mx.on(ClientEvent.Sync, classicSyncListener); }; const shouldBootstrapClassicOnColdCache = async (): Promise => { if (slidingConfig?.bootstrapClassicOnColdCache === false) return false; const userId = mx.getUserId(); if (!userId) return false; const [storeHasAccount, fallbackStoreHasAccount, hasStoreDb, hasFallbackStoreDb] = await Promise.all([ readStoredAccount(`sync${userId}`), readStoredAccount('web-sync-store'), databaseExists(`sync${userId}`), databaseExists('web-sync-store'), ]); const hasWarmCache = storeHasAccount === userId || fallbackStoreHasAccount === userId || hasStoreDb || hasFallbackStoreDb; return !hasWarmCache; }; if (!slidingEnabledOnServer || !slidingRequested) { await startClassicSync( false, slidingEnabledOnServer ? 'session_opt_out' : 'sliding_disabled_server' ); return; } if (!hasSlidingProxy) { await startClassicSync(false, 'missing_proxy'); return; } if (await shouldBootstrapClassicOnColdCache()) { log.log('startClient cold-cache bootstrap: using classic sync for this run', mx.getUserId()); await startClassicSync(false, 'cold_cache_bootstrap'); waitForClientReady(mx, COLD_CACHE_BOOTSTRAP_TIMEOUT_MS).catch((err) => { debugLog.warn('network', 'Cold cache bootstrap timed out', { userId: mx.getUserId(), timeout: `${COLD_CACHE_BOOTSTRAP_TIMEOUT_MS}ms`, error: err instanceof Error ? err.message : String(err), }); }); return; } const resolvedProxyBaseUrl = proxyBaseUrl; const probeTimeoutMs = (() => { const v = slidingConfig?.probeTimeoutMs; return typeof v === 'number' && !Number.isNaN(v) && v > 0 ? Math.round(v) : 5000; })(); const supported = await SlidingSyncManager.probe(mx, resolvedProxyBaseUrl, probeTimeoutMs); log.log('startClient sliding probe result', { userId: mx.getUserId(), requestedEnabled: slidingRequested, hasSlidingProxy, proxyBaseUrl: resolvedProxyBaseUrl, supported, }); if (!supported) { log.warn('Sliding Sync unavailable, falling back to classic sync for', mx.getUserId()); debugLog.warn('network', 'Sliding Sync probe failed, falling back to classic sync', { userId: mx.getUserId(), proxyBaseUrl: resolvedProxyBaseUrl, probeTimeout: `${probeTimeoutMs}ms`, }); await startClassicSync(true, 'probe_failed_fallback'); return; } const manager = new SlidingSyncManager(mx, resolvedProxyBaseUrl, { ...slidingConfig, includeInviteList: true, pollTimeoutMs: slidingConfig?.pollTimeoutMs ?? SLIDING_SYNC_POLL_TIMEOUT_MS, }); manager.attach(); slidingSyncByClient.set(mx, manager); syncTransportByClient.set(mx, { transport: 'sliding', slidingConfigured: true, slidingEnabledOnServer, sessionOptIn: config?.sessionSlidingSyncOptIn === true, slidingRequested, fallbackFromSliding: false, reason: 'sliding_active', }); Sentry.metrics.count('sable.sync.transport', 1, { attributes: { transport: 'sliding', reason: 'sliding_active', fallback: 'false', }, }); try { installStartupFetchRoomEventPatch(mx); await mx.startClient({ lazyLoadMembers: true, slidingSync: manager.slidingSync, threadSupport: true, }); } catch (err) { fetchRoomEventStartupCleanupByClient.get(mx)?.(); debugLog.error('network', 'Failed to start client with sliding sync', { error: err instanceof Error ? err.message : String(err), userId: mx.getUserId(), proxyBaseUrl: resolvedProxyBaseUrl, stack: err instanceof Error ? err.stack : undefined, }); disposeSlidingSync(mx); throw err; } }; export const stopClient = (mx: MatrixClient): void => { log.log('stopClient', mx.getUserId()); debugLog.info('sync', 'Stopping client', { userId: mx.getUserId() }); fetchRoomEventStartupCleanupByClient.get(mx)?.(); disposeSlidingSync(mx); const classicSyncListener = classicSyncObserverByClient.get(mx); if (classicSyncListener) { mx.removeListener(ClientEvent.Sync, classicSyncListener); classicSyncObserverByClient.delete(mx); } mx.stopClient(); syncTransportByClient.delete(mx); }; export const clearCacheAndReload = async (mx: MatrixClient) => { log.log('clearCacheAndReload', mx.getUserId()); stopClient(mx); clearNavToActivePathStore(mx.getSafeUserId()); await mx.store.deleteAllData(); window.location.reload(); }; export const getClientSyncDiagnostics = (mx: MatrixClient): ClientSyncDiagnostics => { const meta = syncTransportByClient.get(mx) ?? { transport: 'classic', slidingConfigured: false, slidingEnabledOnServer: false, sessionOptIn: false, slidingRequested: false, fallbackFromSliding: false, reason: 'unknown', }; return { ...meta, syncState: mx.getSyncState(), sliding: slidingSyncByClient.get(mx)?.getDiagnostics(), }; }; /** * Logs out a Matrix client and cleans up its SDK stores + IndexedDB databases. * Does NOT touch the Jotai sessions atom — callers must do that themselves * so the correct Jotai Provider store is used. */ export const logoutClient = async (mx: MatrixClient, session?: Session) => { log.log('logoutClient', { userId: mx.getUserId(), sessionUserId: session?.userId, }); debugLog.info('general', 'Logging out client', { userId: mx.getUserId() }); pushSessionToSW(); stopClient(mx); try { await mx.logout(); debugLog.info('general', 'Logout successful', { userId: mx.getUserId() }); } catch { // ignore } if (session) { const storeName: SessionStoreName = getSessionStoreName(session); await mx.clearStores({ cryptoDatabasePrefix: storeName.rustCryptoPrefix }); await deleteDatabase(storeName.sync); await deleteDatabase(storeName.crypto); await deleteDatabase(`${storeName.rustCryptoPrefix}::matrix-sdk-crypto`); } else { await mx.clearStores(); window.localStorage.clear(); } }; export const clearLoginData = async () => { debugLog.info('general', 'Clearing all login data and reloading'); const dbs = await window.indexedDB.databases(); dbs.forEach((idbInfo) => { const { name } = idbInfo; if (name) window.indexedDB.deleteDatabase(name); }); window.localStorage.clear(); window.location.reload(); };