cinny/src/app/features/room/message/forwardContent.ts

import { MatrixClient, MatrixEvent } from 'matrix-js-sdk';
import { getEditedEvent, trimReplyFromBody, trimReplyFromFormattedBody } from '../../../utils/room';
import { decryptFile, downloadEncryptedMedia, mxcUrlToHttp } from '../../../utils/matrix';
import { FALLBACK_MIMETYPE } from '../../../utils/mimeTypes';
import { IEncryptedFile } from '../../../../types/matrix/common';

/**
 * Build the content to forward:
 * - undecryptable events are refused (would forward `m.bad.encrypted` junk)
 * - edited messages forward the LATEST edit (`m.new_content`), not the
 *   original pre-edit body
 * - reply fallbacks (`> <@user> …` quote + `<mx-reply>` block) are stripped
 *   along with the `m.relates_to` reply/thread relation, so the forwarded
 *   message stands alone in the target room
 */
/**
 * Provenance stamped onto a forwarded event so the receiving client can show
 * "Forwarded from <sender> in <room> · <time>" and jump to the original
 * (Discord-style). `room_id`/`event_id` let a recipient who is also in the
 * source room jump there; a recipient who is not just sees the sender + time
 * (the source room's NAME is deliberately not included — it is not theirs to
 * see). Other Matrix clients ignore the key and show the plain content.
 */
export const FORWARDED_KEY = 'io.lotus.forwarded';
export type ForwardedMeta = {
  sender: string;
  origin_server_ts: number;
  room_id: string;
  event_id: string;
};
export const getForwardedMeta = (content: Record<string, unknown>): ForwardedMeta | undefined => {
  const raw = content[FORWARDED_KEY];
  if (!raw || typeof raw !== 'object') return undefined;
  const m = raw as Partial<ForwardedMeta>;
  if (typeof m.sender !== 'string' || typeof m.origin_server_ts !== 'number') return undefined;
  return {
    sender: m.sender,
    origin_server_ts: m.origin_server_ts,
    room_id: typeof m.room_id === 'string' ? m.room_id : '',
    event_id: typeof m.event_id === 'string' ? m.event_id : '',
  };
};

export function buildForwardContent(
  mx: MatrixClient,
  mEvent: MatrixEvent,
): Record<string, unknown> | undefined {
  if (mEvent.isDecryptionFailure()) return undefined;

  let content = { ...mEvent.getContent() };

  const eventId = mEvent.getId();
  const room = mx.getRoom(mEvent.getRoomId());
  if (eventId && room) {
    const editedEvent = getEditedEvent(eventId, mEvent, room.getUnfilteredTimelineSet());
    const newContent = editedEvent?.getContent()['m.new_content'];
    if (newContent && typeof newContent === 'object') {
      content = { ...(newContent as Record<string, unknown>) };
    }
  }

  delete content['m.relates_to'];
  // Drop intentional mentions so forwarding a message doesn't re-ping the
  // originally-mentioned users (they're not in the destination room's context).
  delete content['m.mentions'];
  if (typeof content.body === 'string') {
    content.body = trimReplyFromBody(content.body);
  }
  if (typeof content.formatted_body === 'string') {
    content.formatted_body = trimReplyFromFormattedBody(content.formatted_body);
  }

  // Forwarding a forward keeps the ORIGINAL provenance rather than chaining.
  const existing = getForwardedMeta(content);
  const meta: ForwardedMeta = existing ?? {
    sender: mEvent.getSender() ?? '',
    origin_server_ts: mEvent.getTs(),
    room_id: mEvent.getRoomId() ?? '',
    event_id: eventId ?? '',
  };
  content[FORWARDED_KEY] = meta;
  return content;
}

/**
 * `content.file` on an encrypted attachment carries the AES key/iv/hashes
 * needed to decrypt it. Forwarding that content verbatim into a room that
 * isn't itself encrypted would publish the key in plaintext to anyone who can
 * read the destination room (Gitea #63). Re-encrypting for the destination is
 * out of scope, so instead download+decrypt the attachment here and re-upload
 * it as a plain (unencrypted) upload, sending `url` in place of `file`.
 *
 * Throws if the attachment can't be fetched/decrypted — callers must treat
 * that as a hard failure for this forward rather than falling back to
 * sending the encrypted `file` block into the plaintext room.
 */
export async function buildPlaintextAttachmentContent(
  mx: MatrixClient,
  content: Record<string, unknown>,
  useAuthentication: boolean,
): Promise<Record<string, unknown>> {
  const file = content.file as IEncryptedFile;
  const info = content.info as Record<string, unknown> | undefined;
  const mimeType = (info?.mimetype as string | undefined) ?? FALLBACK_MIMETYPE;

  const mediaUrl = mxcUrlToHttp(mx, file.url, useAuthentication);
  if (!mediaUrl) throw new Error('Invalid attachment URL');
  const blob = await downloadEncryptedMedia(mediaUrl, (buf) => decryptFile(buf, mimeType, file));
  const uploadResult = await mx.uploadContent(blob, { type: mimeType });

  const plainContent = { ...content };
  delete plainContent.file;
  plainContent.url = uploadResult.content_uri;

  // The thumbnail can carry its own encryption key (`thumbnail_file`); drop it
  // rather than leak it too — the full attachment still forwards fine without
  // a thumbnail.
  if (info && (info.thumbnail_file || info.thumbnail_url)) {
    const { thumbnail_file: _tf, thumbnail_url: _tu, ...restInfo } = info;
    plainContent.info = restInfo;
  }

  return plainContent;
}