feat(pkit-compat): some steps towards recognizing proxies, not entirely there yet

Author: dozro

src/app/features/room/RoomInput.tsx

@@ -161,7 +161,8 @@ import {
 import { Microphone, Stop } from '@phosphor-icons/react';
 import { getSupportedAudioExtension } from '$plugins/voice-recorder-kit/supportedCodec';
 import { sanitizeCustomHtml } from '$utils/sanitize';
-import { PluralKitCommandMessageHandler } from '$plugins/pluralkit-handler/pluralkitMessageHandler';
+import { PKitCommandMessageHandler } from '$plugins/pluralkit-handler/PKitCommandMessageHandler';
+import { PKitProxyMessageHandler } from '$plugins/pluralkit-handler/PKitProxyMessageHandler';
 import { SchedulePickerDialog } from './schedule-send';
 import * as css from './schedule-send/SchedulePickerDialog.css';
 import {
@@ -265,9 +266,15 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
      * handle pluralkit-style messages
      */
     const pluralkitCmdMessageHandler = useMemo(
-      () => new PluralKitCommandMessageHandler(mx, room),
+      () => new PKitCommandMessageHandler(mx, room),
       [mx, room]
     );
+    const pluralkitProxyMessageHandler = useMemo(() => new PKitProxyMessageHandler(mx), [mx]);
+    useEffect(() => {
+      pluralkitProxyMessageHandler.init();
+    }, [pluralkitProxyMessageHandler]);
+
+    const pkCompatEnable = useSetting(settingsAtom, 'pkCompat');
     const emojiBtnRef = useRef<HTMLButtonElement>(null);
     const micBtnRef = useRef<HTMLButtonElement>(null);
     const roomToParents = useAtomValue(roomToParentsAtom);
@@ -718,7 +725,8 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
         return;
       }
 
-      if (PluralKitCommandMessageHandler.isPKCommand(plainText)) {
+      // check if its a pk command
+      if (pkCompatEnable && PKitCommandMessageHandler.isPKCommand(plainText)) {
         pluralkitCmdMessageHandler.handleMessage(plainText);
       }
 
@@ -778,8 +786,13 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
        * This allows the server to apply the correct profile-based transformations (e.g. font size adjustments) when processing the message,
        * and also allows clients to display an accurate preview of how the message will look with the profile applied while it's being composed.
        */
-      const perMessageProfile = await getCurrentlyUsedPerMessageProfileForRoom(mx, roomId);
+      const perMessageProfile =
+        pkCompatEnable && pluralkitProxyMessageHandler.isAProxiedMessage(plainText)
+          ? await pluralkitProxyMessageHandler.getPmpBasedOnMessage(plainText)
+          : await getCurrentlyUsedPerMessageProfileForRoom(mx, roomId);
 
+      if (pkCompatEnable && pluralkitProxyMessageHandler.isAProxiedMessage(plainText))
+        plainText = pluralkitProxyMessageHandler.stripProxyFromMessage(plainText) ?? plainText;
       if (perMessageProfile) {
         content['com.beeper.per_message_profile'] =
           convertPerMessageProfileToBeeperFormat(perMessageProfile);
@@ -909,6 +922,8 @@ export const RoomInput = forwardRef<HTMLDivElement, RoomInputProps>(
       roomId,
       isMarkdown,
       canSendReaction,
+      pkCompatEnable,
+      pluralkitProxyMessageHandler,
       replyDraft,
       silentReply,
       scheduledTime,

src/app/hooks/usePerMessageProfile.ts

@@ -1,7 +1,8 @@
+import { AccountDataCompatVersion, AccountDataEvent } from '$types/matrix/accountData';
 import { PronounSet } from '$utils/pronouns';
 import { MatrixClient } from 'matrix-js-sdk';
 
-const ACCOUNT_DATA_PREFIX = 'fyi.cisnt.permessageprofile';
+const ACCOUNT_DATA_PREFIX = AccountDataEvent.SablePerProfileMessageProfiles;
 
 /**
  * a per message profile
@@ -26,6 +27,7 @@ export type PerMessageProfile = {
    * @see PronounSet for the format of the pronouns, and how to parse them from a string input
    */
   pronouns?: PronounSet[];
+  compat?: AccountDataCompatVersion;
 };
 
 /**
@@ -96,6 +98,7 @@ type PerMessageProfileIndex = {
    * a list of all profile ids, used to list all profiles when the user wants to manage them.
    */
   profileIds: string[];
+  compat: AccountDataCompatVersion;
 };
 
 /**
@@ -106,6 +109,64 @@ type PerMessageProfileRoomAssociation = {
   validUntil?: number;
 };
 
+/**
+ * associating a profile by proxy
+ * @author Rye
+ */
+export type PerMessageProfileProxyAssociation = {
+  /**
+   * the profile associated with the proxy
+   */
+  profileId: string;
+  /**
+   * regex (string representation of it) to handle the proxy
+   */
+  regexString: string;
+  /**
+   * optional parameter to save when the proxy was added
+   */
+  setAt?: number;
+};
+
+export type InternalPerMessageProfileProxyAssociation = {
+  /**
+   * the profile associated with the proxy
+   */
+  profileId: string;
+  /**
+   * regex to handle the proxy
+   */
+  regex: RegExp;
+  /**
+   * optional parameter to save when the proxy was added
+   */
+  setAt?: number;
+};
+
+export function parsePerMessageProfileProxyAssociation(
+  assoc: PerMessageProfileProxyAssociation
+): InternalPerMessageProfileProxyAssociation {
+  return {
+    profileId: assoc.profileId,
+    // we need to remove artifacts from the toString conversion
+    regex: new RegExp(assoc.regexString.slice(1, -1)),
+    setAt: assoc.setAt,
+  } satisfies InternalPerMessageProfileProxyAssociation;
+}
+
+type PerMessageProfileProxyAssociationWrapper = {
+  /**
+   * the associations saved in the wrapper
+   */
+  associations:
+    | Map<string, PerMessageProfileProxyAssociation>
+    | Record<string, PerMessageProfileProxyAssociation>;
+  /**
+   * optional parameter to save compatibility information
+   */
+  compat?: AccountDataCompatVersion;
+};
+
 /**
  * the shape of the account data for room associations, which is a wrapper around a list of associations.
  * This is used to store the associations in account data, and allows us to easily add additional fields in the future if needed without breaking the existing data structure.
@@ -120,9 +181,14 @@ type PerMessageProfileRoomAssociationWrapper = {
   associations:
     | Map<string, PerMessageProfileRoomAssociation>
     | Record<string, PerMessageProfileRoomAssociation>;
+  compat?: AccountDataCompatVersion;
 };
 
-// Helper to always get a Map from wrapper
+/**
+ * unwrap a profile-room-associations-wrapper
+ * @param wrapper the wrapper to unwrap
+ * @returns unwrapped map for profile-room-associations
+ */
 function getAssociationsMap(
   wrapper?: PerMessageProfileRoomAssociationWrapper
 ): Map<string, PerMessageProfileRoomAssociation> {
@@ -138,6 +204,33 @@ function associationsMapToObject(
   return Object.fromEntries(map);
 }
 
+/**
+ * helper function (similar to getAssociationsMap for Room associations)
+ * @param wrapper the wrapper to unwrap
+ * @returns unwrapped map of proxy associations
+ */
+function getProxyAssociationMap(
+  wrapper?: PerMessageProfileProxyAssociationWrapper
+): Map<string, PerMessageProfileProxyAssociation> {
+  if (!wrapper?.associations) return new Map();
+  if (wrapper.associations instanceof Map) return wrapper.associations;
+  return new Map(Object.entries(wrapper.associations));
+}
+
+function proxyAssociationsMapToObject(
+  map: Map<string, PerMessageProfileProxyAssociation>
+): Record<string, PerMessageProfileProxyAssociation> {
+  return Object.fromEntries(map);
+}
+
+/**
+ * getting a profile from the account data where the profile matches a given id
+ *
+ * @export
+ * @param {MatrixClient} mx the matrix client
+ * @param {string} id the profile id
+ * @return {*}  {(Promise<PerMessageProfile | undefined>)} the profile, with the profile Id, if it exists
+ */
 export async function getPerMessageProfileById(
   mx: MatrixClient,
   id: string
@@ -146,24 +239,47 @@ export async function getPerMessageProfileById(
   return profile ? (profile.getContent() as unknown as PerMessageProfile) : undefined;
 }
 
+/**
+ * getting an array of all PerMessageProfile's saved in the account data
+ *
+ * @export
+ * @param {MatrixClient} mx the matrix client
+ * @return {*}  {Promise<PerMessageProfile[]>} a array containing all per-message-profiles saved
+ */
 export async function getAllPerMessageProfiles(mx: MatrixClient): Promise<PerMessageProfile[]> {
   const profileData = mx.getAccountData(`${ACCOUNT_DATA_PREFIX}.index` as any);
   const profileIds = (profileData?.getContent() as PerMessageProfileIndex)?.profileIds || [];
   const profiles = await Promise.all(profileIds.map((id) => getPerMessageProfileById(mx, id)));
   return profiles.filter((profile): profile is PerMessageProfile => profile !== undefined);
 }
 
+/**
+ * add or update a pmp
+ * @param mx the matrix client
+ * @param profile the profile to add/update
+ * @returns void
+ */
 export function addOrUpdatePerMessageProfile(mx: MatrixClient, profile: PerMessageProfile) {
   const profileListIndex = mx.getAccountData(`${ACCOUNT_DATA_PREFIX}.index` as any);
+  const profileWithCompat = {
+    ...profile,
+    compat: {
+      version: 1,
+      compatDate: '2026-03-26',
+    } satisfies AccountDataCompatVersion,
+  } satisfies PerMessageProfile;
   if (profileListIndex?.getContent()?.profileIds.includes(profile.id)) {
     // profile already exists, just update it
-    return mx.setAccountData(`${ACCOUNT_DATA_PREFIX}.${profile.id}` as any, profile as any);
+    return mx.setAccountData(
+      `${ACCOUNT_DATA_PREFIX}.${profile.id}` as any,
+      profileWithCompat as any
+    );
   }
   // profile doesn't exist, add it to the index and then add the profile data
   const newProfileIds = [...(profileListIndex?.getContent()?.profileIds || []), profile.id];
   return Promise.all([
     mx.setAccountData(`${ACCOUNT_DATA_PREFIX}.index` as any, { profileIds: newProfileIds } as any),
-    mx.setAccountData(`${ACCOUNT_DATA_PREFIX}.${profile.id}` as any, profile as any),
+    mx.setAccountData(`${ACCOUNT_DATA_PREFIX}.${profile.id}` as any, profileWithCompat as any),
   ]);
 }
 
@@ -235,6 +351,77 @@ export async function setCurrentlyUsedPerMessageProfileIdForRoom(
 }
 
 /**
+ *
+ * @param mx the matrix client
+ * @param profileId the profile id which the prefix should be attached to
+ * @param proxy the prefix to use as index
+ * @param proxyRegExp the regex we can use to match the prefix
+ * @param reset wheather to delete the prefix
+ */
+export async function associateProxyWithProfile(
+  mx: MatrixClient,
+  profileId: string | undefined,
+  proxy: string,
+  proxyRegExp: RegExp,
+  reset: boolean
+) {
+  const associations = getProxyAssociationMap(
+    mx.getAccountData(`${ACCOUNT_DATA_PREFIX}.proxyassociation` as any)?.getContent()
+  );
+
+  if (reset) associations.delete(proxy);
+
+  if (!profileId) throw new Error('profileId might not be undefined');
+  if (profileId)
+    associations.set(proxy, {
+      profileId,
+      regexString: proxyRegExp.toString(),
+    } satisfies PerMessageProfileProxyAssociation);
+  mx.setAccountData(
+    `${ACCOUNT_DATA_PREFIX}.proxyassociation` as any,
+    { associations: proxyAssociationsMapToObject(associations) } as any
+  );
+}
+
+/**
+ * get a profile based on a proxy
+ * @param mx the matrix client
+ * @param proxy the proxy to look for
+ * @returns the profile, if any, associated with the prefix
+ */
+export async function getProfileAssociatedWithProxy(
+  mx: MatrixClient,
+  proxy: string
+): Promise<PerMessageProfile | undefined> {
+  const profileId = getAssociationsMap(
+    mx.getAccountData(`${ACCOUNT_DATA_PREFIX}.proxyassociation` as any)?.getContent()
+  ).get(proxy)?.profileId;
+  if (!profileId) return undefined;
+  return getPerMessageProfileById(mx, profileId);
+}
+
+/**
+ *
+ *
+ * @export
+ * @param {MatrixClient} mx the matrix client
+ * @return {*}  {Promise<PerMessageProfileProxyAssociation[]>}
+ */
+export async function getAllPerMessageProfileProxies(
+  mx: MatrixClient
+): Promise<PerMessageProfileProxyAssociation[]> {
+  const cont: PerMessageProfileProxyAssociationWrapper | undefined = mx
+    .getAccountData(`${ACCOUNT_DATA_PREFIX}.proxyassociation` as any)
+    ?.getContent();
+  if (!cont) return [];
+  const pmap = getProxyAssociationMap(cont);
+  const parr = new Array<PerMessageProfileProxyAssociation>();
+  pmap.values().forEach((v) => parr.push(v));
+  return parr;
+}
+
+/**
+ *
  * drops all room associations for a profile, used when deleting a profile to make sure there are no dangling associations left that point to a non existing profile, which could cause issues when trying to apply the profile to a message in a room that still has an association for the deleted profile.
  *
  * @param {MatrixClient} mx the matrix client