mirror of
https://github.com/SableClient/Sable.git
synced 2026-11-20 09:01:17 -08:00
796 lines
26 KiB
TypeScript
796 lines
26 KiB
TypeScript
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<MatrixClient, SlidingSyncManager>();
|
|
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<MatrixClient, SyncTransportMeta>();
|
|
const fetchRoomEventStartupCleanupByClient = new WeakMap<MatrixClient, () => void>();
|
|
const COLD_CACHE_BOOTSTRAP_TIMEOUT_MS = 20000;
|
|
|
|
type FetchRoomEventResult = Awaited<ReturnType<MatrixClient['fetchRoomEvent']>>;
|
|
type MatrixClientWithWritableFetchRoomEvent = MatrixClient & {
|
|
fetchRoomEvent: (roomId: string, eventId: string) => Promise<FetchRoomEventResult>;
|
|
};
|
|
|
|
// 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<void> =>
|
|
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<void> => {
|
|
await Promise.all([
|
|
deleteDatabase(syncStoreName),
|
|
deleteDatabase(syncStoreName.replace(/^sync/, 'crypto')),
|
|
deleteDatabase(`${syncStoreName}::matrix-sdk-crypto`),
|
|
]);
|
|
};
|
|
|
|
const deleteSessionStores = async (storeName: SessionStoreName): Promise<void> => {
|
|
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<string | undefined> =>
|
|
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<boolean> => {
|
|
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<void> =>
|
|
/* 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<void> => {
|
|
const sessions = getLocalStorageItem<Sessions>(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<MatrixClient> => {
|
|
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<MatrixClient> => {
|
|
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<void> => {
|
|
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<void> => {
|
|
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<void>((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<void>;
|
|
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<boolean> => {
|
|
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();
|
|
};
|