Skip to content

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

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

import {createHash} from 'node:crypto';
import {Config} from '@app/api/Config';
import type {AgePolicyConfig} from '@app/api/config/APIConfig';
import type {NatsGifProvider} from '@app/api/gif/NatsGifProvider';
import {withAccountIdentitySetupLock} from '@app/api/instance/AccountIdentitySetupLock';
import {type CustomBadge, compareBigInts} from '@app/api/instance/custom_badges/CustomBadgeRepository';
import {
	type DiscoveryValidators,
	isDiscoveryNotModified,
	nextDiscoveryValidators,
} from '@app/api/instance/DiscoveryValidators';
import {customBadgeImageUrl} from '@app/api/instance/InstanceAssetReferences';
import type {BuiltInBadgeImages} from '@app/api/instance/InstanceConfigRepository';
import {assertSetupToken} from '@app/api/instance/SetupToken';
import {getStatusPageDetector} from '@app/api/instance/StatusPageDetector';
import {RateLimitMiddleware} from '@app/api/middleware/RateLimitMiddleware';
import {OpenAPI} from '@app/api/middleware/ResponseTypeMiddleware';
import {getVoiceTopology} from '@app/api/middleware/ServiceRegistry';
import {getCustomBadgeCatalog} from '@app/api/middleware/ServiceSingletons';
import {listHiddenLabsRoleIds} from '@app/api/operator_pass/OperatorPassLabsRole';
import {RateLimitConfigs} from '@app/api/RateLimitConfig';
import {isBillingActive, isPremiumTieringActive, isStripeServiceable} from '@app/api/stripe/BillingConfigCache';
import type {HonoEnv} from '@app/api/types/HonoEnv';
import {entityTagMatches} from '@app/api/utils/EntityTag';
import {requireConfiguredClientIp} from '@app/api/utils/RequestClientIp';
import {Validator} from '@app/api/Validator';
import {endpointOrigin} from '@app/api/voice/VoiceServerEndpoints';
import {
	type EmailDeliveryState,
	EmailDeliveryStates,
	InstantAccountAvailability,
} from '@fluxer/constants/src/AccountConfigConstants';
import {
	type AccountIdentity,
	AccountIdentityDecisionSources,
	AccountIdentityModes,
	TagStyles,
} from '@fluxer/constants/src/AccountIdentityConstants';
import {resolveEffectiveVerificationBasis, resolveIdentifierFirst} from '@fluxer/constants/src/AccountTierRules';
import {API_CODE_VERSION} from '@fluxer/constants/src/AppConstants';
import {BUILT_IN_GUILD_BADGE_KINDS, type HideableBuiltInBadgeKind} from '@fluxer/constants/src/BadgeConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {AccountIdentityLockedError} from '@fluxer/errors/src/domains/auth/AccountIdentityLockedError';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {buildDiscoveryResponse, type DiscoveryStaticInput} from '@fluxer/instance_bootstrap/src/BuildDiscovery';
import type {InstanceAppPublic} from '@fluxer/instance_bootstrap/src/Types';
import type {AccountsConfig, AuthConfig} from '@fluxer/schema/src/domains/admin/AccountsConfigSchemas';
import type {CaptchaConfig} from '@fluxer/schema/src/domains/admin/CaptchaSchemas';
import {toDomainMigrationDiscovery} from '@fluxer/schema/src/domains/admin/DomainMigrationSchemas';
import type {GeoEntry} from '@fluxer/schema/src/domains/geolocation/GeolocationSchemas';
import {
	InstanceAccountIdentityResponse,
	InstanceAccountIdentityUpdateRequest,
	type InstanceAgePolicy,
	type InstanceAgePolicyAction,
	type InstanceBadge,
	InstanceBadgesQuery,
	InstanceBadgesResponse,
	type InstanceBuiltInGuildBadgeImages,
	type InstanceHiddenBuiltInGuildBadges,
	InstanceSetupTokenCheckRequest,
	WellKnownFluxerResponse,
} from '@fluxer/schema/src/domains/instance/InstanceSchemas';
import type {Hono} from 'hono';
import {getDomain} from 'tldts';

let discoveryValidators: DiscoveryValidators | null = null;

function toAgePolicyDiscovery(agePolicy: AgePolicyConfig): InstanceAgePolicy {
	const geos = (entries: Array<GeoEntry>, action: InstanceAgePolicyAction) =>
		entries.map((entry) => ({country_code: entry.countryCode, region_code: entry.regionCode, action}));
	return {geos: geos(agePolicy.restricted, 'restrict')};
}

function buildDiscoveryStaticInput(
	gifService: NatsGifProvider | undefined,
	appPublic: InstanceAppPublic,
	runtime: {
		captcha: CaptchaConfig;
		emailDeliveryState: EmailDeliveryState;
		accountIdentity: AccountIdentity;
		auth: AuthConfig;
		accounts: AccountsConfig;
		instantAccountAvailability: InstantAccountAvailability;
	},
): DiscoveryStaticInput {
	const signIn = resolveIdentifierFirst({
		mode: runtime.auth.identifier_first,
		identityMode: runtime.accountIdentity.mode,
		deliveryState: runtime.emailDeliveryState,
	});
	const apiClientEndpoint = Config.endpoints.apiClient;
	const apiPublicEndpoint = Config.endpoints.apiPublicDiscovery;
	let gifProvider: NatsGifProvider | undefined;
	if (gifService !== undefined) {
		gifProvider = gifService;
	}
	let gifProviderName = 'klipy';
	let gifDisplayName = 'Klipy';
	let gifAttributionRequired = false;
	if (gifProvider !== undefined) {
		gifProviderName = gifProvider.meta.name;
		gifDisplayName = gifProvider.meta.displayName;
		gifAttributionRequired = gifProvider.meta.attributionRequired;
	}
	return {
		apiCodeVersion: API_CODE_VERSION,
		endpoints: {
			api: apiClientEndpoint,
			api_client: apiClientEndpoint,
			api_public: apiPublicEndpoint,
			...(Config.endpoints.apiTransportDiscovery ? {api_transport: Config.endpoints.apiTransportDiscovery} : {}),
			gateway: Config.endpoints.gateway,
			media: Config.endpoints.media,
			upload_relay: Config.mediaProxy.uploadRelay.endpoint,
			static_cdn: Config.endpoints.staticCdn,
			marketing: Config.endpoints.marketing,
			admin: Config.endpoints.admin,
			invite: Config.endpoints.invite,
			gift: Config.endpoints.gift,
			webapp: Config.endpoints.webApp,
		},
		captcha: {
			provider: runtime.captcha.provider,
		},
		features: {
			voice_enabled: Config.voice.enabled,
			stripe_enabled: isBillingActive(),
			premium_enabled: isPremiumTieringActive(),
			stripe_serviceable: isStripeServiceable(),
			self_hosted: Config.instance.selfHosted,
			presigned_attachment_uploads: Config.presignedAttachmentUploadsEnabled,
			emails_enabled: runtime.emailDeliveryState === EmailDeliveryStates.ON,
			phone_verification_enabled: false,
			discovery_enabled: Config.discovery.enabled,
			account_identity: runtime.accountIdentity.mode,
			tag_style: runtime.accountIdentity.tagStyle,
			identifier_first: signIn.identifierFirst,
			instant_accounts: runtime.instantAccountAvailability === InstantAccountAvailability.AVAILABLE,
			email_codes: signIn.emailCodes,
			date_of_birth_step: true,
			instant_account_availability: runtime.instantAccountAvailability,
			interaction_tier: runtime.accounts.interaction_tier,
			guild_join_gate: runtime.accounts.guild_join_gate,
			email_delivery_state: runtime.emailDeliveryState,
			verification_basis: resolveEffectiveVerificationBasis({
				identityMode: runtime.accountIdentity.mode,
				basis: runtime.accounts.verification_basis,
				deliveryState: runtime.emailDeliveryState,
			}),
		},
		gif: {
			provider: gifProviderName,
			display_name: gifDisplayName,
			attribution_required: gifAttributionRequired,
		},
		push: {
			public_vapid_key: Config.push.publicVapidKey ?? null,
		},
		appPublic,
		agePolicy: toAgePolicyDiscovery(Config.instance.agePolicy),
	};
}

function listVoiceOrigins(): Array<string> {
	const topology = getVoiceTopology();
	if (!topology) return [];
	const origins = new Set<string>();
	for (const region of topology.getAllRegions()) {
		for (const server of topology.getServersForRegion(region.id)) {
			const origin = endpointOrigin(server.endpoint);
			if (origin) origins.add(origin);
		}
	}
	return collapseVoiceOrigins(origins);
}

function collapseVoiceOrigins(origins: Iterable<string>): Array<string> {
	const groups = new Map<string, Array<URL>>();
	const out = new Set<string>();
	for (const origin of origins) {
		const url = new URL(origin);
		const domain = getDomain(url.hostname);
		if (!domain) {
			out.add(origin);
			continue;
		}
		const key = `${url.protocol}//${domain}:${url.port}`;
		groups.set(key, [...(groups.get(key) ?? []), url]);
	}
	for (const urls of groups.values()) {
		if (urls.length === 1) {
			out.add(urls[0].origin);
			continue;
		}
		const labels = urls.map((url) => url.hostname.split('.').reverse());
		let shared = 0;
		while (labels.every((host) => shared < host.length && host[shared] === labels[0][shared])) shared++;
		const parent = labels[0].slice(0, shared).reverse().join('.');
		const port = urls[0].port ? `:${urls[0].port}` : '';
		for (const url of urls) {
			if (url.hostname === parent) out.add(url.origin);
		}
		out.add(`${urls[0].protocol}//*.${parent}${port}`);
	}
	return Array.from(out).sort();
}

function mapBuiltInGuildBadgeImagesForDiscovery(images: BuiltInBadgeImages): InstanceBuiltInGuildBadgeImages {
	const url = (asset: string | undefined) => (asset ? customBadgeImageUrl(asset, Config.endpoints.media) : null);
	return {
		verified: url(images.guild_verified),
		partnered: url(images.guild_partnered),
		discoverable: url(images.guild_discoverable),
	};
}

function mapHiddenBuiltInGuildBadgesForDiscovery(
	hidden: ReadonlySet<HideableBuiltInBadgeKind>,
): InstanceHiddenBuiltInGuildBadges {
	return BUILT_IN_GUILD_BADGE_KINDS.filter((kind) => hidden.has(`guild_${kind}`));
}

const INT64_MAX = (1n << 63n) - 1n;
const BADGE_CACHE_CURRENT = 'public, max-age=86400, immutable';
const BADGE_CACHE_REVALIDATE = 'public, max-age=60, must-revalidate';

function mapGuildBadge(badge: CustomBadge): InstanceBadge {
	return {
		id: badge.id,
		name: badge.name,
		description: badge.description,
		asset_url: customBadgeImageUrl(badge.asset, Config.endpoints.media),
		href: badge.href,
		position: badge.position.toString(),
	};
}

function parseBadgeIds(ids: string): Array<bigint> {
	return [...new Set(ids.split(','))].map((id) => BigInt(id)).filter((id) => id <= INT64_MAX);
}

function badgeEntityTag(version: string, query: string): string {
	return `"${createHash('sha256').update(`${version}\n${query}`).digest('hex').slice(0, 32)}"`;
}

export function InstanceController(app: Hono<HonoEnv>) {
	app.get(
		'/.well-known/fluxer',
		RateLimitMiddleware(RateLimitConfigs.INSTANCE_INFO),
		OpenAPI({
			operationId: 'get_well_known_fluxer',
			summary: 'Get instance discovery document',
			responseSchema: WellKnownFluxerResponse,
			statusCode: 200,
			security: [],
			tags: ['Instance'],
			description:
				'Returns the instance discovery document including API endpoints, feature flags, and limits. This is the canonical discovery endpoint for all Fluxer clients.',
		}),
		async (ctx) => {
			ctx.header('Access-Control-Allow-Origin', '*');
			const gifService = ctx.get('gifService') as NatsGifProvider | undefined;
			const limits = ctx.get('limitConfigService').getConfigWireFormat();
			const sso = await ctx.get('ssoService').getPublicStatus();
			const instanceConfigRepository = ctx.get('instanceConfigRepository');
			const [
				registration,
				community,
				services,
				appPublicConfig,
				captcha,
				emailDeliveryState,
				domainMigration,
				accountIdentity,
				auth,
				accounts,
				instantAccountAvailability,
				notice,
				badgeHead,
				builtInBadgeImages,
				hiddenBuiltInBadges,
			] = await Promise.all([
				instanceConfigRepository.getRegistrationPublicConfig(),
				instanceConfigRepository.getInstanceCommunityPublicConfig(),
				instanceConfigRepository.getResolvedServicesConfig(),
				instanceConfigRepository.getAppPublicConfig(),
				instanceConfigRepository.getCaptchaConfig(),
				instanceConfigRepository.getEmailDeliveryState(),
				instanceConfigRepository.getDomainMigrationConfig(),
				instanceConfigRepository.getAccountIdentity(),
				instanceConfigRepository.getAuthConfig(),
				instanceConfigRepository.getAccountsConfig(),
				instanceConfigRepository.getInstantAccountAvailability(),
				instanceConfigRepository.getActiveInstanceNotice(),
				getCustomBadgeCatalog().readDiscoveryHead(),
				instanceConfigRepository.getBuiltInBadgeImages(),
				instanceConfigRepository.getHiddenBuiltInBadges(),
			]);
			const statusPageInstatus = await getStatusPageDetector().isInstatus(appPublicConfig.branding.status_page_url);
			const lockReason =
				Config.instance.selfHosted && !appPublicConfig.setup.configured
					? await instanceConfigRepository.getAccountIdentityLockReason()
					: undefined;
			const openSetup =
				lockReason === undefined
					? {}
					: {
							account_identity_locked: lockReason !== null,
							account_identity_lock_reason: lockReason,
							setup_token_required: await instanceConfigRepository.isSetupTokenRequired(),
						};
			const discovery = buildDiscoveryResponse(
				buildDiscoveryStaticInput(
					gifService,
					{
						...appPublicConfig,
						branding: {...appPublicConfig.branding, status_page_instatus: statusPageInstatus},
						setup: {
							...appPublicConfig.setup,
							admin_url: Config.endpoints.admin || null,
							...openSetup,
						},
					},
					{
						captcha,
						emailDeliveryState,
						accountIdentity,
						auth,
						accounts,
						instantAccountAvailability,
					},
				),
				{
					sso,
					registration,
					community,
					services,
					limits,
				},
			);
			const response = {
				...discovery,
				notice,
				domain_migration: toDomainMigrationDiscovery(domainMigration),
				guild_badges: badgeHead.value.badges.map(mapGuildBadge),
				guild_badges_partial: badgeHead.value.partial,
				custom_badges_version: getCustomBadgeCatalog().clientVersion(badgeHead.version),
				built_in_guild_badge_images: mapBuiltInGuildBadgeImagesForDiscovery(builtInBadgeImages),
				hidden_built_in_guild_badges: mapHiddenBuiltInGuildBadgesForDiscovery(hiddenBuiltInBadges),
				hidden_role_ids: listHiddenLabsRoleIds(),
				voice_origins: listVoiceOrigins(),
			};
			discoveryValidators = nextDiscoveryValidators(response, discoveryValidators);
			ctx.header('ETag', discoveryValidators.etag);
			ctx.header('Last-Modified', discoveryValidators.lastModified.toUTCString());
			if (
				isDiscoveryNotModified(
					discoveryValidators,
					ctx.req.header('If-None-Match'),
					ctx.req.header('If-Modified-Since'),
				)
			) {
				return ctx.body(null, 304);
			}
			return ctx.json(response);
		},
	);
	app.get(
		'/instance/badges',
		RateLimitMiddleware(RateLimitConfigs.INSTANCE_BADGES),
		Validator('query', InstanceBadgesQuery),
		OpenAPI({
			operationId: 'list_instance_badges',
			summary: 'List community badges',
			description:
				'Lists the custom badges that communities on this instance can show, in display order. Send ids to look up the badges listed in badge_ids of a community, or page through every badge with after and limit. Send the custom_badges_version from discovery as version. While that is still the current version, the response can be cached for a day.',
			responseSchema: InstanceBadgesResponse,
			statusCode: 200,
			security: [],
			tags: ['Instance'],
		}),
		async (ctx) => {
			ctx.header('Access-Control-Allow-Origin', '*');
			const query = ctx.req.valid('query');
			if (query.ids !== undefined && query.after !== undefined) {
				throw InputValidationError.create('after', 'Send either ids or after');
			}
			const catalog = getCustomBadgeCatalog();
			const read =
				query.ids !== undefined
					? await catalog.readByIds(parseBadgeIds(query.ids)).then((result) => ({
							...result,
							value: {badges: result.value.filter((badge) => badge.type === 'guild'), next: null},
						}))
					: await catalog.readPage({type: 'guild', after: query.after, limit: query.limit});
			const version = catalog.clientVersion(read.version);
			const normalizedQuery =
				query.ids !== undefined
					? `ids=${parseBadgeIds(query.ids).sort(compareBigInts).join(',')}`
					: `after=${query.after ?? ''}&limit=${query.limit}`;
			ctx.header(
				'Cache-Control',
				read.stable && query.version === version ? BADGE_CACHE_CURRENT : BADGE_CACHE_REVALIDATE,
			);
			if (read.stable) {
				const etag = badgeEntityTag(version, normalizedQuery);
				ctx.header('ETag', etag);
				const ifNoneMatch = ctx.req.header('If-None-Match');
				if (ifNoneMatch !== undefined && entityTagMatches(ifNoneMatch, etag)) {
					return ctx.body(null, 304);
				}
			}
			return ctx.json({
				version,
				badges: read.value.badges.map(mapGuildBadge),
				next: read.value.next,
			});
		},
	);
	app.post(
		'/instance/setup/token-checks',
		RateLimitMiddleware(RateLimitConfigs.INSTANCE_SETUP_TOKEN_CHECK),
		Validator('json', InstanceSetupTokenCheckRequest),
		OpenAPI({
			operationId: 'check_instance_setup_token',
			summary: 'Check the setup token of a new instance',
			responseSchema: null,
			statusCode: 204,
			security: [],
			tags: ['Instance'],
			description:
				'Checks a setup token before the setup wizard asks for anything else. It returns 204 when the token is correct, and also when the instance no longer needs one. A missing or wrong token fails with the same field codes as registration and counts toward the same allowance of wrong tokens. The check never uses up the token.',
		}),
		async (ctx) => {
			const {setup_token} = ctx.req.valid('json');
			const {config, rateLimit} = ctx.get('apiContext').services;
			await assertSetupToken({
				rateLimit,
				config,
				repository: ctx.get('instanceConfigRepository'),
				presented: setup_token,
				clientIp: requireConfiguredClientIp(ctx.req.raw, config.proxy),
			});
			return ctx.body(null, 204);
		},
	);
	app.put(
		'/instance/setup/account-identity',
		RateLimitMiddleware(RateLimitConfigs.INSTANCE_SETUP_ACCOUNT_IDENTITY),
		Validator('json', InstanceAccountIdentityUpdateRequest),
		OpenAPI({
			operationId: 'set_instance_account_identity',
			summary: 'Choose the sign-in method for a new instance',
			responseSchema: InstanceAccountIdentityResponse,
			statusCode: 200,
			security: [],
			tags: ['Instance'],
			description:
				'Sets how people sign in on a new self-hosted instance, and for email sign-in whether usernames are unique with no tag. Username sign-in always uses unique usernames. It works only before setup is finished and before the first account exists. After that it fails with ACCOUNT_IDENTITY_LOCKED. While the instance requires a setup token, the request must send it as setup_token.',
		}),
		async (ctx) => {
			const {mode, tag_style, setup_token} = ctx.req.valid('json');
			const instanceConfigRepository = ctx.get('instanceConfigRepository');
			const {config, rateLimit, cache} = ctx.get('apiContext').services;
			await assertSetupToken({
				rateLimit,
				config,
				repository: instanceConfigRepository,
				presented: setup_token,
				clientIp: requireConfiguredClientIp(ctx.req.raw, config.proxy),
			});
			if (mode === AccountIdentityModes.USERNAME && tag_style === TagStyles.RANDOM) {
				throw InputValidationError.fromCode('tag_style', ValidationErrorCodes.TAG_STYLE_REQUIRES_EMAIL_SIGN_IN);
			}
			const identity = await withAccountIdentitySetupLock(cache, async () => {
				if (await instanceConfigRepository.isAccountIdentityLocked()) {
					throw new AccountIdentityLockedError();
				}
				await instanceConfigRepository.setAccountIdentityMode(
					mode,
					AccountIdentityDecisionSources.SETUP,
					tag_style ?? TagStyles.NONE,
				);
				return await instanceConfigRepository.getAccountIdentity();
			});
			return ctx.json({mode: identity.mode, tag_style: identity.tagStyle});
		},
	);
}