Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
11.6 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {Endpoints} from '@app/features/app/constants/Endpoints';
import {detectDomainMigrationInstallKind} from '@app/features/app/domain_migration/DomainMigrationBrowser';
import RuntimeConfig from '@app/features/app/state/RuntimeConfig';
import {isDesktopLocalAppDocument} from '@app/features/platform/DesktopLocalAppRuntime';
import AppStorage from '@app/features/platform/state/PersistentStorage';
import {http} from '@app/features/platform/transport/RestTransport';
import {Logger} from '@app/features/platform/utils/AppLogger';
import {hasUnavailableElectronNativeContext, isElectron} from '@app/features/ui/utils/NativeUtils';
import {isInstalledPwa} from '@app/features/ui/utils/PwaUtils';

interface PushSubscriptionListResponse {
	subscriptions: Array<{
		subscription_id: string;
		user_agent: string | null;
	}>;
}

const logger = new Logger('PushSubscriptionService');
const LAST_PUSH_ENDPOINT_KEY = 'fluxer.lastPushEndpoint';
const readLastEndpoint = (): string | null => {
	try {
		return AppStorage.getItem(LAST_PUSH_ENDPOINT_KEY);
	} catch (error) {
		logger.warn('Failed to read the last registered push endpoint', error);
		return null;
	}
};
const writeLastEndpoint = (endpoint: string | null): void => {
	try {
		if (endpoint) AppStorage.setItem(LAST_PUSH_ENDPOINT_KEY, endpoint);
		else AppStorage.removeItem(LAST_PUSH_ENDPOINT_KEY);
	} catch (error) {
		logger.warn('Failed to persist the last registered push endpoint', error);
	}
};

let registerPromise: Promise<string | null> | null = null;
let unregisterPromise: Promise<void> | null = null;
let nativeDesktopCleanupPromise: Promise<void> | null = null;

export function isWebPushBlockedForNativeDesktop(): boolean {
	return isElectron() || hasUnavailableElectronNativeContext();
}

const getPublicVapidKey = (): string | null => {
	return RuntimeConfig.getSnapshotOrNull()?.publicPushVapidKey ?? null;
};
const isWebPushSupported = (): boolean => {
	if (isDesktopLocalAppDocument()) {
		return false;
	}
	return 'serviceWorker' in navigator && 'PushManager' in window && typeof Notification !== 'undefined';
};
const logWebPushUnavailable = (): void => {
	logger.debug('Web push not supported in this environment', {
		installedPwa: isInstalledPwa(),
		nativeDesktop: isWebPushBlockedForNativeDesktop(),
	});
};
const arrayBufferToBase64Url = (buffer: ArrayBuffer | null): string | null => {
	if (!buffer) return null;
	const bytes = new Uint8Array(buffer);
	let binary = '';
	for (let i = 0; i < bytes.length; i += 1) {
		binary += String.fromCharCode(bytes[i]);
	}
	const base64 = btoa(binary);
	return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
};
const buffersEqual = (a: ArrayBuffer | Uint8Array, b: ArrayBuffer | Uint8Array): boolean => {
	const viewA = a instanceof Uint8Array ? a : new Uint8Array(a);
	const viewB = b instanceof Uint8Array ? b : new Uint8Array(b);
	if (viewA.byteLength !== viewB.byteLength) return false;
	for (let i = 0; i < viewA.byteLength; i += 1) {
		if (viewA[i] !== viewB[i]) return false;
	}
	return true;
};
const urlBase64ToUint8Array = (base64String: string): Uint8Array => {
	const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
	const base64 = (base64String + padding).replace(/-/g, '+').replace(/_/g, '/');
	const rawData = atob(base64);
	const outputArray = new Uint8Array(rawData.length);
	for (let i = 0; i < rawData.length; i += 1) {
		outputArray[i] = rawData.charCodeAt(i);
	}
	return outputArray;
};
const getServiceWorkerRegistration = async ({
	waitUntilReady = true,
}: {
	waitUntilReady?: boolean;
} = {}): Promise<ServiceWorkerRegistration | undefined> => {
	if (!isWebPushSupported()) {
		return undefined;
	}
	try {
		const existingRegistration = await navigator.serviceWorker.getRegistration();
		if (existingRegistration) return existingRegistration;
		if (!waitUntilReady) return undefined;
		return await navigator.serviceWorker.ready;
	} catch (error) {
		logger.error('Failed to get service worker registration', {error});
		return undefined;
	}
};

async function getLocalBrowserPushSubscription(reason: string): Promise<PushSubscription | null> {
	const registration = await getServiceWorkerRegistration({waitUntilReady: false});
	if (!registration) return null;
	try {
		return await registration.pushManager.getSubscription();
	} catch (error) {
		logger.error('Failed to read local Web Push registration for native desktop client', {reason, error});
		return null;
	}
}

async function unsubscribeLocalBrowserPushRegistration(
	reason: string,
	subscription?: PushSubscription | null,
): Promise<string | null> {
	const existingSubscription =
		subscription === undefined ? await getLocalBrowserPushSubscription(reason) : subscription;
	if (!existingSubscription) return null;
	const endpoint = existingSubscription.endpoint;
	try {
		await existingSubscription.unsubscribe();
		writeLastEndpoint(null);
		logger.warn('Unsubscribed local Web Push registration because this client uses native desktop notifications', {
			reason,
			endpoint,
		});
		return endpoint;
	} catch (error) {
		logger.error('Failed to unsubscribe local Web Push registration for native desktop client', {reason, error});
		return endpoint;
	}
}

export async function cleanupNativeDesktopWebPushSubscriptions(reason = 'native-desktop'): Promise<void> {
	if (!isWebPushBlockedForNativeDesktop()) return;
	if (nativeDesktopCleanupPromise) return nativeDesktopCleanupPromise;
	const promise = (async () => {
		try {
			const existingSubscription = await getLocalBrowserPushSubscription(reason);
			const lastEndpoint = readLastEndpoint();
			const endpointToDelete = existingSubscription?.endpoint ?? lastEndpoint;
			if (endpointToDelete) {
				const localSubscriptionId = await createWebPushSubscriptionId(endpointToDelete);
				try {
					await http.delete(Endpoints.USER_PUSH_SUBSCRIPTION(localSubscriptionId));
					logger.warn('Deleted legacy desktop Web Push subscription on backend', {
						reason,
						subscriptionId: localSubscriptionId,
					});
				} catch (error) {
					logger.warn('Failed to delete legacy desktop Web Push subscription on backend', {
						reason,
						subscriptionId: localSubscriptionId,
						error,
					});
				}
			}
			await unsubscribeLocalBrowserPushRegistration(reason, existingSubscription);
			writeLastEndpoint(null);
		} finally {
			nativeDesktopCleanupPromise = null;
		}
	})();
	nativeDesktopCleanupPromise = promise;
	return promise;
}

async function createWebPushSubscriptionId(endpoint: string): Promise<string> {
	const encoder = new TextEncoder();
	const digest = await crypto.subtle.digest('SHA-256', encoder.encode(endpoint));
	const bytes = new Uint8Array(digest);
	let hex = '';
	for (const byte of bytes) {
		hex += byte.toString(16).padStart(2, '0');
	}
	return hex.slice(0, 32);
}

export async function registerPushSubscription(): Promise<string | null> {
	if (isWebPushBlockedForNativeDesktop()) {
		logger.error('Blocked Web Push registration in native desktop client; native notifications must be used', {
			installedPwa: isInstalledPwa(),
			userAgent: navigator.userAgent,
		});
		await cleanupNativeDesktopWebPushSubscriptions('register-blocked-native-desktop');
		return null;
	}
	if (!isWebPushSupported()) {
		logWebPushUnavailable();
		return null;
	}
	let publicVapidKey: string | null;
	try {
		publicVapidKey = getPublicVapidKey();
	} catch (error) {
		logger.error('Failed to resolve runtime configuration before push registration', {error});
		return null;
	}
	if (!publicVapidKey) {
		logger.debug('VAPID public key is not configured');
		return null;
	}
	if (Notification.permission !== 'granted') {
		logger.debug('Notification permission is not granted; skipping push subscription');
		return null;
	}
	if (registerPromise) return registerPromise;
	const promise = (async () => {
		try {
			const registration = await getServiceWorkerRegistration();
			if (!registration) {
				logger.debug('No active service worker registration');
				return null;
			}
			const existingSubscription = await registration.pushManager.getSubscription();
			const applicationServerKey = urlBase64ToUint8Array(publicVapidKey) as BufferSource;
			const existingKey = existingSubscription?.options?.applicationServerKey ?? null;
			const expectedKeyBytes = urlBase64ToUint8Array(publicVapidKey);
			const keyMatches = existingKey ? buffersEqual(existingKey, expectedKeyBytes) : false;
			if (existingSubscription && !keyMatches) {
				logger.info('VAPID key mismatch; resubscribing push');
				try {
					await existingSubscription.unsubscribe();
				} catch (error) {
					logger.warn('Failed to unsubscribe stale push subscription', {error});
				}
			}
			const subscription =
				existingSubscription && keyMatches
					? existingSubscription
					: await registration.pushManager.subscribe({
							userVisibleOnly: true,
							applicationServerKey,
						});
			const p256dh = arrayBufferToBase64Url(subscription.getKey('p256dh'));
			const auth = arrayBufferToBase64Url(subscription.getKey('auth'));
			if (!subscription.endpoint || !p256dh || !auth) {
				logger.error('Push subscription did not contain expected data', {
					endpoint: subscription.endpoint,
					p256dh,
					auth,
				});
				return null;
			}
			const installedApp = detectDomainMigrationInstallKind() !== 'none';
			const lastEndpoint = readLastEndpoint();
			const isRotation = lastEndpoint !== null && lastEndpoint !== subscription.endpoint;
			const response = isRotation
				? await http.post<{
						subscription_id: string;
					}>(Endpoints.USER_PUSH_ROTATE, {
						body: {
							old_endpoint: lastEndpoint,
							endpoint: subscription.endpoint,
							keys: {p256dh, auth},
							user_agent: navigator.userAgent,
							installed_app: installedApp,
						},
					})
				: await http.post<{
						subscription_id: string;
					}>(Endpoints.USER_PUSH_SUBSCRIBE, {
						body: {
							endpoint: subscription.endpoint,
							keys: {p256dh, auth},
							user_agent: navigator.userAgent,
							installed_app: installedApp,
						},
					});
			writeLastEndpoint(subscription.endpoint);
			logger.info('Registered push subscription', {
				subscriptionId: response.body.subscription_id,
				rotated: isRotation,
			});
			return response.body.subscription_id;
		} catch (error) {
			logger.error('Failed to register push subscription', {error});
			return null;
		} finally {
			registerPromise = null;
		}
	})();
	registerPromise = promise;
	return promise;
}

export async function unregisterAllPushSubscriptions(): Promise<void> {
	if (isWebPushBlockedForNativeDesktop()) {
		await cleanupNativeDesktopWebPushSubscriptions('unregister-all-blocked-native-desktop');
		return;
	}
	if (!isWebPushSupported()) {
		logWebPushUnavailable();
		return;
	}
	if (unregisterPromise) return unregisterPromise;
	const promise = (async () => {
		try {
			const response = await http.get<PushSubscriptionListResponse>(Endpoints.USER_PUSH_SUBSCRIPTIONS);
			const subscriptions = response.body.subscriptions ?? [];
			await Promise.all(
				subscriptions.map(async (subscription) => {
					try {
						await http.delete(Endpoints.USER_PUSH_SUBSCRIPTION(subscription.subscription_id));
					} catch (error) {
						logger.warn('Failed to delete push subscription on backend', {
							subscriptionId: subscription.subscription_id,
							error,
						});
					}
				}),
			);
			const registration = await getServiceWorkerRegistration();
			if (!registration) return;
			const existingSubscription = await registration.pushManager.getSubscription();
			if (existingSubscription) {
				await existingSubscription.unsubscribe();
			}
			writeLastEndpoint(null);
		} catch (error) {
			logger.error('Failed to unregister push subscriptions', {error});
		} finally {
			unregisterPromise = null;
		}
	})();
	unregisterPromise = promise;
	return promise;
}