Skip to content

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

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

export const ACCOUNT_ENGINE_CHANNELS = Object.freeze({
	connect: 'account-engine:connect',
	port: 'account-engine:port',
	accounts: 'account-engine:accounts',
} as const);

export const ACCOUNT_ENGINE_AVAILABLE_RENDERER_ARG = '--fluxer-account-engine=1';

export const ACCOUNT_ENGINE_LIMITS = Object.freeze({
	accountKeyMaxChars: 4096,
	endpointMaxChars: 2048,
	requestTimeoutMs: 30_000,
	promotionTimeoutMs: 15_000,
	activityChannelLimitMax: 200,
	activityMentionLimitMax: 100,
	mentionContentMaxChars: 2000,
	recipientsMax: 10,
	summaryCoalesceMs: 150,
	demotionCaptureMaxBytes: 256 * 1024 * 1024,
	providedAccountsMax: 1024,
} as const);

export const AccountEngineConnectionState = Object.freeze({
	STARTING: 'starting',
	CONNECTING: 'connecting',
	READY: 'ready',
	RESUMING: 'resuming',
	BACKOFF: 'backoff',
	OFFLINE: 'offline',
	AUTH_FAILED: 'auth_failed',
	FOREGROUND: 'foreground',
	STOPPED: 'stopped',
} as const);
export type AccountEngineConnectionState =
	(typeof AccountEngineConnectionState)[keyof typeof AccountEngineConnectionState];

export const AccountEngineCacheState = Object.freeze({EMPTY: 'empty', STALE: 'stale', LIVE: 'live'} as const);
export type AccountEngineCacheState = (typeof AccountEngineCacheState)[keyof typeof AccountEngineCacheState];

export interface AccountEngineUser {
	readonly id: string;
	readonly username: string;
	readonly globalName: string | null;
	readonly avatar: string | null;
	readonly discriminator: string | null;
}

export interface AccountEngineAccountSummary {
	readonly accountKey: string;
	readonly instanceKey: string;
	readonly userId: string;
	readonly user: AccountEngineUser | null;
	readonly state: AccountEngineConnectionState;
	readonly stateChangedAt: number;
	readonly nextRetryAt: number | null;
	readonly mentionCount: number;
	readonly unreadChannelCount: number;
	readonly lastMessageAt: number | null;
	readonly cache: AccountEngineCacheState;
	readonly cacheUpdatedAt: number | null;
	readonly degraded: boolean;
	readonly revision: number;
}

export interface AccountEngineChannelActivity {
	readonly channelId: string;
	readonly guildId: string | null;
	readonly parentId: string | null;
	readonly type: number;
	readonly name: string | null;
	readonly guildName: string | null;
	readonly guildIcon: string | null;
	readonly recipients: ReadonlyArray<AccountEngineUser>;
	readonly mentionCount: number;
	readonly unread: boolean;
	readonly lastMessageId: string | null;
	readonly ackMessageId: string | null;
}

export interface AccountEngineMention {
	readonly messageId: string;
	readonly channelId: string;
	readonly guildId: string | null;
	readonly channelType: number | null;
	readonly channelName: string | null;
	readonly guildName: string | null;
	readonly author: AccountEngineUser;
	readonly content: string;
	readonly gated: boolean;
	readonly timestamp: string;
}

export interface AccountEngineAccountActivity {
	readonly accountKey: string;
	readonly channels: ReadonlyArray<AccountEngineChannelActivity>;
	readonly totalChannelCount: number;
	readonly mentions: ReadonlyArray<AccountEngineMention>;
}

export interface AccountEngineNotification {
	readonly accountKey: string;
	readonly message: unknown;
	readonly guildName: string | null;
	readonly channelName: string | null;
	readonly channelType: number | null;
	readonly mentioned: boolean;
	readonly gated: boolean;
}

export interface AccountEngineResumeSession {
	readonly sessionId: string;
	readonly sequence: number;
	readonly gatewayUrl: string;
}

export interface AccountEngineSnapshotCursor {
	readonly sessionId: string | null;
	readonly schemaEpoch: number | null;
	readonly updatedAt: number;
}

export type AccountEngineSnapshotEntries = Record<string, Record<string, string>>;

export interface AccountEngineSnapshotCapture {
	readonly entries: AccountEngineSnapshotEntries;
	readonly cursor: AccountEngineSnapshotCursor;
}

export interface AccountEnginePromotion {
	readonly accountKey: string;
	readonly capture: AccountEngineSnapshotCapture | null;
	readonly mentionCounts: Readonly<Record<string, number>>;
	readonly session: AccountEngineResumeSession | null;
}

export interface AccountEngineGuildSubscriptionRelease {
	readonly member_list_channels?: Readonly<Record<string, readonly []>>;
	readonly members?: readonly [];
	readonly threads?: false;
	readonly thread_member_lists?: readonly [];
	readonly focused_channel_id?: null;
}

export type AccountEngineSubscriptionRelease = Readonly<Record<string, AccountEngineGuildSubscriptionRelease>>;

export interface AccountEngineDemotion {
	readonly accountKey: string;
	readonly session: AccountEngineResumeSession | null;
	readonly release: AccountEngineSubscriptionRelease | null;
	readonly capture: AccountEngineSnapshotCapture | null;
	readonly mentionCounts: Readonly<Record<string, number>> | null;
}

export interface AccountEngineClientConfig {
	readonly properties: Readonly<Record<string, unknown>>;
	readonly apiVersion: number;
	readonly identifyFlags: number;
}

export interface AccountEngineRequests {
	configure: {params: AccountEngineClientConfig; result: null};
	claimForeground: {params: {readonly accountKey: string | null}; result: null};
	getSummaries: {params: null; result: ReadonlyArray<AccountEngineAccountSummary>};
	getActivity: {
		params: {
			readonly accountKeys: ReadonlyArray<string> | null;
			readonly channelLimit: number;
			readonly mentionLimit: number;
		};
		result: ReadonlyArray<AccountEngineAccountActivity>;
	};
	beginPromotion: {params: {readonly accountKey: string}; result: AccountEnginePromotion | null};
	completePromotion: {params: {readonly accountKey: string}; result: null};
	abortPromotion: {params: {readonly accountKey: string}; result: null};
	demote: {params: AccountEngineDemotion; result: null};
	ackChannel: {
		params: {readonly accountKey: string; readonly channelId: string; readonly messageId: string};
		result: boolean;
	};
	reconnect: {params: {readonly accountKey: string}; result: null};
	setUnreadBadgeCustomization: {params: {readonly enabledAccountKeys: ReadonlyArray<string>}; result: null};
}

export type AccountEngineRequestMethod = keyof AccountEngineRequests;

export type AccountEngineEvent =
	| {readonly type: 'summaries'; readonly summaries: ReadonlyArray<AccountEngineAccountSummary>}
	| {readonly type: 'removed'; readonly accountKeys: ReadonlyArray<string>}
	| {readonly type: 'notification'; readonly notification: AccountEngineNotification}
	| {readonly type: 'channel-read'; readonly accountKey: string; readonly channelId: string}
	| {readonly type: 'auth-failed'; readonly accountKey: string; readonly tokenTag: string}
	| {readonly type: 'account-record-changed'; readonly accountKey: string}
	| {
			readonly type: 'account-token-rotated';
			readonly accountKey: string;
			readonly previousTokenTag: string;
			readonly token: string;
	  }
	| {readonly type: 'restarted'};

export const AccountEngineErrorCode = Object.freeze({
	UNKNOWN_ACCOUNT: 'unknown_account',
	NOT_READY: 'not_ready',
	BUSY: 'busy',
	INVALID_REQUEST: 'invalid_request',
	UNAVAILABLE: 'unavailable',
	TIMEOUT: 'timeout',
} as const);
export type AccountEngineErrorCode = (typeof AccountEngineErrorCode)[keyof typeof AccountEngineErrorCode];

export class AccountEngineRequestError extends Error {
	readonly code: AccountEngineErrorCode;
	constructor(code: AccountEngineErrorCode, message: string) {
		super(message);
		this.name = 'AccountEngineRequestError';
		this.code = code;
	}
}

export interface AccountEngineRendererAPI {
	readonly isAvailable: boolean;
	request<M extends AccountEngineRequestMethod>(
		method: M,
		params: AccountEngineRequests[M]['params'],
	): Promise<AccountEngineRequests[M]['result']>;
	onEvent(listener: (event: AccountEngineEvent) => void): () => void;
	provideAccounts(accounts: ReadonlyArray<AccountEngineProvidedAccount>): Promise<boolean>;
}

export interface AccountEngineProvidedAccount {
	readonly storageKey: string;
	readonly record: {
		readonly userId: string;
		readonly token: string;
		readonly isValid: boolean;
		readonly lastActive: number;
		readonly userData: {readonly username: string; readonly globalName: string | null} | null;
		readonly instance: {
			readonly apiEndpoint: string;
			readonly gatewayEndpoint: string;
			readonly apiCodeVersion: number;
		};
	};
}

export function accountEngineInstanceKey(accountKey: string): string | null {
	const index = accountKey.lastIndexOf('::');
	return index <= 0 ? null : accountKey.slice(0, index);
}

const USER_MENTION_PATTERN = /<@!?(\d+)>/g;

function mentionedUserName(value: unknown): string | null {
	if (typeof value !== 'object' || value === null) return null;
	const user = value as {member?: {nick?: unknown} | null; global_name?: unknown; username?: unknown};
	for (const name of [user.member?.nick, user.global_name, user.username]) {
		if (typeof name === 'string' && name.length > 0) return name;
	}
	return null;
}

export function inlineMentionedUserNames(
	content: string,
	mentions: unknown,
	formatName: (name: string) => string = (name) => name,
): string {
	if (!content || !Array.isArray(mentions) || mentions.length === 0) return content;
	const names = new Map<string, string>();
	for (const mention of mentions) {
		const id = (mention as {id?: unknown} | null)?.id;
		const name = mentionedUserName(mention);
		if (typeof id === 'string' && name !== null) names.set(id, name);
	}
	return content.replace(USER_MENTION_PATTERN, (token, userId: string) => {
		const name = names.get(userId);
		return name === undefined ? token : `@${formatName(name)}`;
	});
}