malice

// Backend-agnostic API surface. Every call forwards to whichever transport

// this build was compiled for, hosted (fetch + SSE) or on-device (worker).

import { parseEventContextPage, parseEventContextSession } from './types';

import type { EventContextPage, EventContextSession, MemberSummary, RoomSummary } from './types';

import type { Emote } from './emotes';

import type { MentionKey, MentionsBoundary, MentionsPage, SavedMentionContext } from './mentions-model';

export { mentionKey, parseMentionsPage, parseSavedMentionContext, parseMentionsUpdate } from './mentions-model';

export type { MentionKey, MentionReason, MentionCaptureState, MentionEntry, MentionCoverage, MentionGap, MentionsBoundary, MentionsPage, SavedMentionContext, MentionsUpdate } from './mentions-model';

import { formatBody } from './markdown';

import { mentionedUserIds, type Mention } from './mentions';

import { HttpTransport } from './transport-http';

import { parseSearchPage, parseSearchSession, scopeWire, type SearchPage, type SearchScope, type SearchSession } from './search-model';

import type { CommandRequest, SendKind, SessionInfo, Transport, VerifyAction } from './transport';

export type { HistoryRequest } from './transport';

import { createDeviceTransport } from 'malice:device-transport';

import { ApiError } from './transport';

import { isRecord } from './guards';

export { ApiError } from './transport';

export type { SessionInfo, SoftLogout, VerifyAction } from './transport';

function createTransport(): Transport {

  if (import.meta.env.VITE_MALICE_TARGET === 'device') return createDeviceTransport();

  return new HttpTransport();

}

const transport: Transport = createTransport();

export function getSession(): Promise<SessionInfo> {

  return transport.getSession();

}

export function login(homeserver: string, username: string, password: string): Promise<{ user_id: string }> {

  return transport.login(homeserver, username, password);

}

export function logout(): Promise<void> {

  return transport.logout();

}

export function getRooms(): Promise<{ rooms: RoomSummary[] }> {

  return transport.getRooms();

}

export const openRoom = (room_id: string) => transport.openRoom(room_id);

export const closeRoom = (room_id: string) => transport.closeRoom(room_id);

export const sendMessage = (

  room_id: string,

  body: string,

  reply_to: string | null = null,

  mentions: Mention[] = [],

  kind: SendKind = 'text',

  emotes: Emote[] = [],

  thread_root: string | null = null

) => transport.sendMessage(room_id, body, formatBody(body, mentions, true, emotes), reply_to, mentionedUserIds(mentions), kind, thread_root);

export const runCommand = (request: CommandRequest) => transport.command(request);

export const uploadAvatar = (file: File) => transport.uploadAvatar(file);

export const uploadRoomAvatar = (room_id: string, file: File) => transport.uploadRoomAvatar(room_id, file);

export const uploadMedia = (file: File) => transport.uploadMedia(file);

export const paginateRoom = (room_id: string, thread_root: string | null = null) => transport.paginateRoom(room_id, thread_root);

export async function eventContext(room_id: string, event_id: string, limit = 20): Promise<EventContextSession> {

  const parsed = parseEventContextSession(

    await transport.command({ op: 'event_context', room_id, event_id, before_limit: limit, after_limit: limit })

  );

  if (!parsed) throw new ApiError(502, 'Invalid event context response');

  return parsed;

}

async function eventContextPage(op: 'event_context_before' | 'event_context_after', context_id: string, token: string, limit: number): Promise<EventContextPage> {

  const parsed = parseEventContextPage(await transport.command({ op, context_id, token, limit }));

  if (!parsed) throw new ApiError(502, 'Invalid event context page response');

  return parsed;

}

export const eventContextBefore = (context_id: string, token: string, limit = 20): Promise<EventContextPage> =>

  eventContextPage('event_context_before', context_id, token, limit);

export const eventContextAfter = (context_id: string, token: string, limit = 20): Promise<EventContextPage> =>

  eventContextPage('event_context_after', context_id, token, limit);

export async function closeEventContext(context_id: string): Promise<void> {

  await transport.command({ op: 'close_event_context', context_id });

}

export const mentionsPage = (cursor: string | null = null, limit = 50): Promise<MentionsPage> => transport.mentionsPage(cursor, limit);

export const mentionContext = (room_id: string, event_id: string): Promise<SavedMentionContext> => transport.mentionContext(room_id, event_id);

export const retryMentionContext = (room_id: string, event_id: string): Promise<SavedMentionContext> => transport.retryMentionContext(room_id, event_id);

export const setMentionsRead = (keys: MentionKey[], read: boolean) => transport.setMentionsRead(keys, read);

export const markMentionsReadThrough = (boundary: MentionsBoundary) => transport.markMentionsReadThrough(boundary);

export const recoverMentions = () => transport.recoverMentions();

export async function searchMessages(query: string, scope: SearchScope, limit = 30): Promise<SearchSession> {

  const session = parseSearchSession(await transport.command({ op: 'search', query, scope: scopeWire(scope), limit }));

  if (!session) throw new ApiError(502, 'Invalid search response');

  return session;

}

export async function searchMore(search_id: string, cursor: string, limit = 30): Promise<SearchPage> {

  const page = parseSearchPage(await transport.command({ op: 'search_more', search_id, cursor, limit }));

  if (!page) throw new ApiError(502, 'Invalid search response');

  return page;

}

export async function closeSearch(search_id: string): Promise<void> {

  await transport.command({ op: 'close_search', search_id });

}

export async function retryRecentHistory(room_id: string): Promise<void> {

  await transport.command({ op: 'retry_recent_history', room_id });

}

export async function fillHistoryGap(room_id: string, gap_id: string): Promise<void> {

  await transport.command({ op: 'fill_history_gap', room_id, gap_id });

}

export async function openThreadList(room_id: string): Promise<void> {

  await transport.command({ op: 'open_thread_list', room_id });

}

export async function paginateThreadList(room_id: string, limit = 20): Promise<void> {

  await transport.command({ op: 'paginate_thread_list', room_id, limit });

}

export async function closeThreadList(room_id: string): Promise<void> {

  await transport.command({ op: 'close_thread_list', room_id });

}

export const setTyping = (room_id: string, typing: boolean) => transport.setTyping(room_id, typing);

export const getAccountData = (eventType: string) => transport.getAccountData(eventType);

export const getUrlPreview = (room_id: string, url: string) => transport.getUrlPreview(room_id, url);

export const setAccountData = (eventType: string, content: Record<string, unknown>) =>

  transport.setAccountData(eventType, content);

export function joinRoom(room: string): Promise<{ room_id: string }> {

  return transport.joinRoom(room);

}

export function createRoom(name: string, topic?: string): Promise<{ room_id: string }> {

  return transport.createRoom(name, topic);

}

export const leaveRoom = (room_id: string) => transport.leaveRoom(room_id);

export const reactToMessage = (room_id: string, event_id: string, key: string, shortcode?: string, thread_root: string | null = null) =>

  transport.reactToMessage(room_id, event_id, key, shortcode, thread_root);

export const editMessage = (room_id: string, event_id: string, body: string, mentions: Mention[] = [], emotes: Emote[] = [], thread_root: string | null = null) =>

  transport.editMessage(room_id, event_id, body, formatBody(body, mentions, true, emotes), mentionedUserIds(mentions), thread_root);

export const markRead = (room_id: string, event_id: string, thread_root: string | null = null) => transport.markRead(room_id, event_id, thread_root);

export function getMembers(room_id: string): Promise<{ members: MemberSummary[] }> {

  return transport.getMembers(room_id);

}

/** Same URL shape in both builds: the hosted server and the device service worker both answer it. */

export function mediaUrl(mxc: string | null, size = 256): string | null {

  if (!mxc) return null;

  return `/api/media?mxc=${encodeURIComponent(mxc)}&size=${Math.max(16, Math.min(512, Math.round(size)))}`;

}

export function messageMediaUrl(mediaId: string, size: 'Thumbnail' | 'Full'): string {

  return `/api/message-media?media_id=${encodeURIComponent(mediaId)}&size=${size}`;

}

export function getProfile(): Promise<{ display_name: string | null; avatar_url: string | null }> {

  return transport.getProfile();

}

export function getSpaceChildren(room_id: string): Promise<{ room_ids: string[] }> {

  return transport.getSpaceChildren(room_id);

}

export function getEncryption(): Promise<{ state: unknown; verification: unknown }> {

  return transport.getEncryption();

}

export function recoverEncryption(recovery_key: string): Promise<void> {

  return transport.recoverEncryption(recovery_key);

}

export type KeyBackupAction = 'enable_key_backup' | 'disable_key_backup';

export async function runKeyBackup(op: KeyBackupAction, deleteFromServer = false): Promise<void> {

  await transport.command(op === 'disable_key_backup' ? { op, delete_from_server: deleteFromServer } : { op });

}

export async function setupRecovery(op: 'enable_recovery' | 'reset_recovery_key', passphrase: string | null): Promise<string> {

  const reply = await transport.command({ op, passphrase });

  const key = isRecord(reply) ? reply['recovery_key'] : null;

  if (typeof key !== 'string' || !key) throw new Error('No recovery key returned');

  return key;

}

export const isBackupExists = (e: unknown): boolean => e instanceof ApiError && e.kind === 'key_backup_exists';

export async function disableRecovery(): Promise<void> {

  await transport.command({ op: 'disable_recovery' });

}

export async function verifyRecoveryKey(recovery_key: string): Promise<boolean> {

  const reply = await transport.command({ op: 'verify_recovery_key', recovery_key });

  return isRecord(reply) && reply['valid'] === true;

}

export function startVerification(): Promise<void> {

  return transport.startVerification();

}

export function verifyEncryption(action: VerifyAction): Promise<void> {

  return transport.verifyEncryption(action);

}

export function uploadAttachment(

  room_id: string,

  file: File,

  caption: string | null = null,

  reply_to: string | null = null,

  mentions: Mention[] = [],

  emotes: Emote[] = [],

  thread_root: string | null = null

): Promise<void> {

  return transport.uploadAttachment(room_id, file, {

    caption,

    formatted_caption: caption ? formatBody(caption, mentions, true, emotes) : null,

    reply_to,

    mentions: mentionedUserIds(mentions),

    thread_root

  });

}

export function subscribeEvents(onEvent: (data: string) => void, onDisconnect: () => void): () => void {

  return transport.subscribeEvents(onEvent, onDisconnect);

}