Skip to content

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

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

import {randomBytes} from 'node:crypto';
import type {ApiContext} from '@app/api/ApiContext';
import type {AdminAuditService} from '@app/api/admin/services/AdminAuditService';
import {createGuildIDSet, createUserIDSet, type UserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import type {VoiceJoinTokenRow} from '@app/api/database/types/VoiceTypes';
import type {ISnowflakeService} from '@app/api/infrastructure/ISnowflakeService';
import {REXCTL_TEST_ROOM_PREFIX} from '@app/api/infrastructure/LiveKitWebhookService';
import {getVoiceServerHealth} from '@app/api/middleware/ServiceRegistry';
import {VOICE_CONFIGURATION_CHANNEL} from '@app/api/voice/VoiceConstants';
import type {VoiceJoinTokenRepository} from '@app/api/voice/VoiceJoinTokenRepository';
import type {VoiceRegionRecord, VoiceRegionWithServers, VoiceServerRecord} from '@app/api/voice/VoiceModel';
import {
	hashJoinSecret,
	joinTokenStatus,
	VOICE_JOIN_TOKEN_PREFIX,
	voiceJoinCommand,
} from '@app/api/voice/VoiceNodeService';
import type {VoiceRepository} from '@app/api/voice/VoiceRepository';
import {bundledVoiceServerId} from '@app/api/voice/VoiceServerEndpoints';
import {healthOf, toHealthResponse} from '@app/api/voice/VoiceServerHealth';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {UnknownVoiceRegionError} from '@fluxer/errors/src/domains/voice/UnknownVoiceRegionError';
import {UnknownVoiceServerError} from '@fluxer/errors/src/domains/voice/UnknownVoiceServerError';
import {VoiceJoinTokenInvalidError} from '@fluxer/errors/src/domains/voice/VoiceJoinTokenInvalidError';
import {VoiceServerApiKeyInUseError} from '@fluxer/errors/src/domains/voice/VoiceServerApiKeyInUseError';
import {VoiceServerIdInUseError} from '@fluxer/errors/src/domains/voice/VoiceServerIdInUseError';
import type {
	CreateVoiceJoinTokenRequest,
	CreateVoiceJoinTokenResponse,
	CreateVoiceRegionRequest,
	CreateVoiceServerRequest,
	DeleteVoiceRegionRequest,
	DeleteVoiceServerRequest,
	GetVoiceRegionRequest,
	GetVoiceServerRequest,
	ListVoiceRegionsRequest,
	ListVoiceServersRequest,
	UpdateVoiceRegionRequest,
	UpdateVoiceServerRequest,
	VoiceJoinTokenAdminResponse,
	VoiceRegionAdminResponse,
	VoiceServerAdminResponse,
} from '@fluxer/schema/src/domains/admin/AdminVoiceSchemas';
import {AccessToken, TrackSource} from 'livekit-server-sdk';

interface AdminVoiceServiceDeps {
	apiContext: ApiContext;
	voiceRepository: VoiceRepository;
	joinTokenRepository: VoiceJoinTokenRepository;
	snowflakeService: ISnowflakeService;
	auditService: AdminAuditService;
}

const TEST_TOKEN_TTL_SECONDS = 60;

interface VoiceRestrictionData {
	vip_only?: boolean;
	required_guild_features?: Array<string>;
	allowed_guild_ids?: Array<bigint | string>;
	allowed_user_ids?: Array<bigint | string>;
}

interface VoiceConfigurationMessage {
	type: string;
	regionId: string;
	serverId?: string;
}

function buildVoiceRestrictions(data: VoiceRestrictionData): VoiceRegionRecord['restrictions'] {
	return {
		vipOnly: data.vip_only ?? false,
		requiredGuildFeatures: new Set(data.required_guild_features ?? []),
		allowedGuildIds: createGuildIDSet(new Set((data.allowed_guild_ids ?? []).map(BigInt))),
		allowedUserIds: createUserIDSet(new Set((data.allowed_user_ids ?? []).map(BigInt))),
	};
}

function patchVoiceRestrictions(
	restrictions: VoiceRegionRecord['restrictions'],
	data: VoiceRestrictionData,
): VoiceRegionRecord['restrictions'] {
	if (
		data.vip_only === undefined &&
		data.required_guild_features === undefined &&
		data.allowed_guild_ids === undefined &&
		data.allowed_user_ids === undefined
	) {
		return restrictions;
	}
	const updatedRestrictions = {...restrictions};
	if (data.vip_only !== undefined) updatedRestrictions.vipOnly = data.vip_only;
	if (data.required_guild_features !== undefined)
		updatedRestrictions.requiredGuildFeatures = new Set(data.required_guild_features);
	if (data.allowed_guild_ids !== undefined) {
		updatedRestrictions.allowedGuildIds = createGuildIDSet(new Set(data.allowed_guild_ids.map(BigInt)));
	}
	if (data.allowed_user_ids !== undefined) {
		updatedRestrictions.allowedUserIds = createUserIDSet(new Set(data.allowed_user_ids.map(BigInt)));
	}
	return updatedRestrictions;
}

export class AdminVoiceService {
	constructor(private readonly deps: AdminVoiceServiceDeps) {}

	async listVoiceRegions(data: ListVoiceRegionsRequest) {
		const {voiceRepository} = this.deps;
		const regions = data.include_servers
			? await voiceRepository.listRegionsWithServers()
			: await voiceRepository.listRegions();
		regions.sort((a, b) => a.name.localeCompare(b.name));
		const duplicates = await this.duplicateApiKeys();
		if (data.include_servers) {
			const regionsWithServers = regions as Array<VoiceRegionWithServers>;
			return {
				regions: regionsWithServers.map((region) => ({
					...this.mapVoiceRegionToAdminResponse(region),
					servers: region.servers
						.sort((a, b) => a.serverId.localeCompare(b.serverId))
						.map((server) => this.mapVoiceServerToAdminResponse(server, duplicates)),
				})),
			};
		}
		const voiceRegions = regions as Array<VoiceRegionRecord>;
		return {
			regions: voiceRegions.map((region) => this.mapVoiceRegionToAdminResponse(region)),
		};
	}

	async getVoiceRegion(data: GetVoiceRegionRequest) {
		const {voiceRepository} = this.deps;
		const region = data.include_servers
			? await voiceRepository.getRegionWithServers(data.id)
			: await voiceRepository.getRegion(data.id);
		if (!region) {
			return {region: null};
		}
		if (data.include_servers && 'servers' in region) {
			const regionWithServers = region as VoiceRegionWithServers;
			const duplicates = await this.duplicateApiKeys();
			return {
				region: {
					...this.mapVoiceRegionToAdminResponse(regionWithServers),
					servers: regionWithServers.servers.map((server) => this.mapVoiceServerToAdminResponse(server, duplicates)),
				},
			};
		}
		return {
			region: this.mapVoiceRegionToAdminResponse(region),
		};
	}

	async createVoiceRegion(data: CreateVoiceRegionRequest, adminUserId: UserID, auditLogReason: string | null) {
		const {voiceRepository} = this.deps;
		const region = await voiceRepository.createRegion({
			id: data.id,
			name: data.name,
			emoji: data.emoji,
			latitude: data.latitude,
			longitude: data.longitude,
			isDefault: data.is_default ?? false,
			restrictions: buildVoiceRestrictions(data),
		});
		await this.publishVoiceConfiguration({type: 'region_created', regionId: region.id});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_region',
			action: 'create_voice_region',
			auditLogReason,
			metadata: new Map([
				['region_id', region.id],
				['name', region.name],
			]),
		});
		return {
			region: this.mapVoiceRegionToAdminResponse(region),
		};
	}

	async updateVoiceRegion(data: UpdateVoiceRegionRequest, adminUserId: UserID, auditLogReason: string | null) {
		const {voiceRepository} = this.deps;
		const existing = await voiceRepository.getRegion(data.id);
		if (!existing) {
			throw new UnknownVoiceRegionError();
		}
		const updates: VoiceRegionRecord = {...existing};
		if (data.name !== undefined) updates.name = data.name;
		if (data.emoji !== undefined) updates.emoji = data.emoji;
		if (data.latitude !== undefined) updates.latitude = data.latitude;
		if (data.longitude !== undefined) updates.longitude = data.longitude;
		if (data.is_default !== undefined) updates.isDefault = data.is_default;
		updates.restrictions = patchVoiceRestrictions(existing.restrictions, data);
		updates.updatedAt = new Date();
		await voiceRepository.upsertRegion(updates);
		await this.publishVoiceConfiguration({type: 'region_updated', regionId: data.id});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_region',
			action: 'update_voice_region',
			auditLogReason,
			metadata: new Map([['region_id', data.id]]),
		});
		return {
			region: this.mapVoiceRegionToAdminResponse(updates),
		};
	}

	async deleteVoiceRegion(data: DeleteVoiceRegionRequest, adminUserId: UserID, auditLogReason: string | null) {
		const {voiceRepository} = this.deps;
		const existing = await voiceRepository.getRegion(data.id);
		if (!existing) {
			throw new UnknownVoiceRegionError();
		}
		await voiceRepository.deleteRegion(data.id);
		await this.publishVoiceConfiguration({type: 'region_deleted', regionId: data.id});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_region',
			action: 'delete_voice_region',
			auditLogReason,
			metadata: new Map([
				['region_id', data.id],
				['name', existing.name],
			]),
		});
		return {success: true};
	}

	async listVoiceServers(data: ListVoiceServersRequest) {
		const {voiceRepository} = this.deps;
		const servers = await voiceRepository.listServers(data.region_id);
		const duplicates = await this.duplicateApiKeys();
		return {
			servers: servers.map((server) => this.mapVoiceServerToAdminResponse(server, duplicates)),
		};
	}

	async getVoiceServer(data: GetVoiceServerRequest) {
		const {voiceRepository} = this.deps;
		const server = await voiceRepository.getServer(data.region_id, data.server_id);
		return {
			server: server ? this.mapVoiceServerToAdminResponse(server, await this.duplicateApiKeys()) : null,
		};
	}

	async createVoiceServer(data: CreateVoiceServerRequest, adminUserId: UserID, auditLogReason: string | null) {
		const {voiceRepository} = this.deps;
		const region = await voiceRepository.getRegion(data.region_id);
		if (!region) {
			throw new UnknownVoiceRegionError();
		}
		const existing = await voiceRepository.listAllServers();
		if (existing.some((server) => server.regionId === data.region_id && server.serverId === data.server_id)) {
			throw new VoiceServerIdInUseError();
		}
		if (data.server_id === bundledVoiceServerId() && data.api_key !== Config.voice.apiKey) {
			throw new VoiceServerIdInUseError();
		}
		if (existing.some((server) => server.apiKey === data.api_key)) {
			throw new VoiceServerApiKeyInUseError();
		}
		const server = await voiceRepository.createServer({
			regionId: data.region_id,
			serverId: data.server_id,
			endpoint: data.endpoint,
			isActive: data.is_active ?? true,
			softConnectionLimit: data.soft_connection_limit ?? null,
			notes: data.notes ?? null,
			apiKey: data.api_key ?? null,
			apiSecret: data.api_secret ?? null,
			latitude: data.latitude ?? null,
			longitude: data.longitude ?? null,
			internalEndpoint: data.internal_endpoint ?? null,
			draining: data.draining ?? false,
			pinnedHostname: null,
			pinnedSoftLimit: false,
			publicIpv4: data.public_ipv4 ?? null,
			publicIpv6: data.public_ipv6 ?? null,
			restrictions: buildVoiceRestrictions(data),
		});
		await this.publishVoiceConfiguration({type: 'server_created', regionId: data.region_id, serverId: data.server_id});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_server',
			action: 'create_voice_server',
			auditLogReason,
			metadata: new Map([
				['region_id', server.regionId],
				['server_id', server.serverId],
				['endpoint', server.endpoint],
			]),
		});
		return {
			server: this.mapVoiceServerToAdminResponse(server, await this.duplicateApiKeys()),
		};
	}

	async updateVoiceServer(data: UpdateVoiceServerRequest, adminUserId: UserID, auditLogReason: string | null) {
		const {voiceRepository} = this.deps;
		const existing = await voiceRepository.getServer(data.region_id, data.server_id);
		if (!existing) {
			throw new UnknownVoiceServerError();
		}
		const updates: VoiceServerRecord = {...existing};
		if (data.endpoint !== undefined) updates.endpoint = data.endpoint;
		if (data.api_key !== undefined && data.api_key !== '' && data.api_key !== existing.apiKey) {
			const servers = await voiceRepository.listAllServers();
			if (servers.some((server) => server.apiKey === data.api_key)) {
				throw new VoiceServerApiKeyInUseError();
			}
			updates.apiKey = data.api_key;
		}
		if (data.api_secret !== undefined && data.api_secret !== '') updates.apiSecret = data.api_secret;
		if (data.latitude !== undefined) updates.latitude = data.latitude;
		if (data.longitude !== undefined) updates.longitude = data.longitude;
		if (data.is_active !== undefined) updates.isActive = data.is_active;
		if (data.soft_connection_limit !== undefined) updates.softConnectionLimit = data.soft_connection_limit;
		if (data.notes !== undefined) updates.notes = data.notes;
		if (data.internal_endpoint !== undefined) updates.internalEndpoint = data.internal_endpoint;
		if (data.draining !== undefined) updates.draining = data.draining;
		if (data.public_ipv4 !== undefined) updates.publicIpv4 = data.public_ipv4;
		if (data.public_ipv6 !== undefined) updates.publicIpv6 = data.public_ipv6;
		updates.restrictions = patchVoiceRestrictions(existing.restrictions, data);
		updates.updatedAt = new Date();
		await voiceRepository.upsertServer(updates);
		await this.publishVoiceConfiguration({type: 'server_updated', regionId: data.region_id, serverId: data.server_id});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_server',
			action: 'update_voice_server',
			auditLogReason,
			metadata: new Map([
				['region_id', data.region_id],
				['server_id', data.server_id],
			]),
		});
		return {
			server: this.mapVoiceServerToAdminResponse(updates, await this.duplicateApiKeys()),
		};
	}

	async deleteVoiceServer(data: DeleteVoiceServerRequest, adminUserId: UserID, auditLogReason: string | null) {
		const {voiceRepository} = this.deps;
		const existing = await voiceRepository.getServer(data.region_id, data.server_id);
		if (!existing) {
			throw new UnknownVoiceServerError();
		}
		await voiceRepository.deleteServer(data.region_id, data.server_id);
		await this.publishVoiceConfiguration({type: 'server_deleted', regionId: data.region_id, serverId: data.server_id});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_server',
			action: 'delete_voice_server',
			auditLogReason,
			metadata: new Map([
				['region_id', data.region_id],
				['server_id', data.server_id],
				['endpoint', existing.endpoint],
			]),
		});
		return {success: true};
	}

	private mapVoiceRegionToAdminResponse(region: VoiceRegionRecord): VoiceRegionAdminResponse {
		const allowedGuildIds = Array.from(region.restrictions.allowedGuildIds).map((id) => id.toString());
		return {
			id: region.id,
			name: region.name,
			emoji: region.emoji,
			latitude: region.latitude,
			longitude: region.longitude,
			is_default: region.isDefault,
			vip_only: region.restrictions.vipOnly,
			required_guild_features: Array.from(region.restrictions.requiredGuildFeatures),
			allowed_guild_ids: allowedGuildIds,
			allowed_user_ids: Array.from(region.restrictions.allowedUserIds).map((id) => id.toString()),
			created_at: region.createdAt?.toISOString() ?? null,
			updated_at: region.updatedAt?.toISOString() ?? null,
		};
	}

	private async duplicateApiKeys(): Promise<Set<string>> {
		const seen = new Set<string>();
		const duplicates = new Set<string>();
		for (const server of await this.deps.voiceRepository.listAllServers()) {
			if (seen.has(server.apiKey)) duplicates.add(server.apiKey);
			seen.add(server.apiKey);
		}
		return duplicates;
	}

	private mapVoiceServerToAdminResponse(server: VoiceServerRecord, duplicates: Set<string>): VoiceServerAdminResponse {
		const allowedGuildIds = Array.from(server.restrictions.allowedGuildIds).map((id) => id.toString());
		return {
			region_id: server.regionId,
			server_id: server.serverId,
			endpoint: server.endpoint,
			latitude: server.latitude ?? null,
			longitude: server.longitude ?? null,
			is_active: server.isActive,
			soft_connection_limit: server.softConnectionLimit ?? null,
			notes: server.notes,
			vip_only: server.restrictions.vipOnly,
			required_guild_features: Array.from(server.restrictions.requiredGuildFeatures),
			allowed_guild_ids: allowedGuildIds,
			allowed_user_ids: Array.from(server.restrictions.allowedUserIds).map((id) => id.toString()),
			internal_endpoint: server.internalEndpoint,
			draining: server.draining,
			public_ipv4: server.publicIpv4,
			public_ipv6: server.publicIpv6,
			health: toHealthResponse(healthOf(getVoiceServerHealth(), server)),
			duplicate_api_key: duplicates.has(server.apiKey),
			created_at: server.createdAt?.toISOString() ?? null,
			updated_at: server.updatedAt?.toISOString() ?? null,
		};
	}

	async createJoinToken(
		data: CreateVoiceJoinTokenRequest,
		adminUserId: UserID,
		auditLogReason: string | null,
	): Promise<CreateVoiceJoinTokenResponse> {
		if (data.region_name && !data.region_id) {
			throw new UnknownVoiceRegionError();
		}
		if ((data.region_latitude === null) !== (data.region_longitude === null)) {
			throw InputValidationError.create('region_latitude', 'Pass region_latitude and region_longitude together.');
		}
		if (data.region_latitude !== null && !data.region_name) {
			throw InputValidationError.create(
				'region_latitude',
				'Region coordinates only apply to a new region in region_name.',
			);
		}
		if (data.region_id && !data.region_name && !(await this.deps.voiceRepository.getRegion(data.region_id))) {
			throw new UnknownVoiceRegionError();
		}
		if (data.server_id && data.server_id === bundledVoiceServerId()) {
			throw new VoiceServerIdInUseError();
		}
		const tokenId = await this.deps.snowflakeService.generate();
		const secret = randomBytes(32).toString('base64url');
		const now = new Date();
		const row: VoiceJoinTokenRow = {
			token_id: tokenId,
			secret_hash: hashJoinSecret(secret),
			created_by: adminUserId,
			created_at: now,
			expires_at: new Date(now.getTime() + data.expires_in_seconds * 1000),
			claim_id: null,
			claimed_at: null,
			used_at: null,
			used_by_ip: null,
			used_server_id: null,
			revoked_at: null,
			region_id: data.region_id,
			region_name: data.region_name,
			region_emoji: data.region_emoji,
			region_latitude: data.region_latitude,
			region_longitude: data.region_longitude,
			server_id: data.server_id,
			hostname: data.hostname,
			internal_endpoint: data.internal_endpoint,
			soft_connection_limit: data.soft_connection_limit,
			notes: data.notes,
			vip_only: data.vip_only,
			required_guild_features: new Set(data.required_guild_features),
			allowed_guild_ids: new Set(data.allowed_guild_ids.map(BigInt)),
			allowed_user_ids: new Set(data.allowed_user_ids.map(BigInt)),
		};
		await this.deps.joinTokenRepository.create(row);
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_join_token',
			action: 'create_voice_join_token',
			auditLogReason,
			metadata: new Map([
				['token_id', tokenId.toString()],
				['region_id', data.region_id ?? ''],
			]),
		});
		const token = `${VOICE_JOIN_TOKEN_PREFIX}${tokenId}_${secret}`;
		return {
			token_id: tokenId.toString(),
			token,
			expires_at: row.expires_at.toISOString(),
			command: voiceJoinCommand(Config.endpoints.webApp, Config.instance.baseDomain, token),
		};
	}

	async listJoinTokens(): Promise<{tokens: Array<VoiceJoinTokenAdminResponse>}> {
		const rows = await this.deps.joinTokenRepository.list();
		rows.sort((a, b) => b.created_at.getTime() - a.created_at.getTime());
		return {
			tokens: rows.map((row) => ({
				token_id: row.token_id.toString(),
				status: joinTokenStatus(row),
				created_at: row.created_at.toISOString(),
				expires_at: row.expires_at.toISOString(),
				used_at: row.used_at?.toISOString() ?? null,
				used_server_id: row.used_server_id,
				revoked_at: row.revoked_at?.toISOString() ?? null,
				region_id: row.region_id,
				region_name: row.region_name,
				server_id: row.server_id,
				hostname: row.hostname,
				notes: row.notes,
			})),
		};
	}

	async revokeJoinToken(tokenId: bigint, adminUserId: UserID, auditLogReason: string | null) {
		const row = await this.deps.joinTokenRepository.get(tokenId);
		if (!row || joinTokenStatus(row) !== 'pending' || !(await this.deps.joinTokenRepository.revoke(row, new Date()))) {
			throw new VoiceJoinTokenInvalidError();
		}
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_join_token',
			action: 'revoke_voice_join_token',
			auditLogReason,
			metadata: new Map([['token_id', tokenId.toString()]]),
		});
		return {success: true};
	}

	async createServerTestToken(
		data: GetVoiceServerRequest,
		adminUserId: UserID,
		auditLogReason: string | null,
	): Promise<{token: string; endpoint: string; room: string}> {
		const server = await this.deps.voiceRepository.getServer(data.region_id, data.server_id);
		if (!server) {
			throw new UnknownVoiceServerError();
		}
		const room = `${REXCTL_TEST_ROOM_PREFIX}${randomBytes(6).toString('hex')}`;
		const token = new AccessToken(server.apiKey, server.apiSecret, {
			identity: `rexctl-test-${randomBytes(4).toString('hex')}`,
			ttl: TEST_TOKEN_TTL_SECONDS,
		});
		token.addGrant({
			room,
			roomJoin: true,
			hidden: true,
			canPublish: true,
			canSubscribe: true,
			canPublishData: false,
			canPublishSources: [TrackSource.MICROPHONE],
		});
		await this.deps.auditService.createAuditLog({
			targetId: 0n,
			adminUserId,
			targetType: 'voice_server',
			action: 'create_voice_server_test_token',
			auditLogReason,
			metadata: new Map([
				['region_id', server.regionId],
				['server_id', server.serverId],
			]),
		});
		return {token: await token.toJwt(), endpoint: server.endpoint, room};
	}

	private async publishVoiceConfiguration(message: VoiceConfigurationMessage): Promise<void> {
		await this.deps.apiContext.services.cache.publish(VOICE_CONFIGURATION_CHANNEL, JSON.stringify(message));
	}
}