# matrix-appservice-kakaotalk - A Matrix-KakaoTalk puppeting bridge. # Copyright (C) 2022 Tulir Asokan, Andrew Ferrazzutti # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . from __future__ import annotations from typing import ( TYPE_CHECKING, Any, AsyncGenerator, Awaitable, Callable, Coroutine, Generic, Pattern, TypeVar, cast, ) from io import BytesIO from mimetypes import guess_extension import asyncio import re import time from attr import dataclass, evolve from mautrix.appservice import IntentAPI from mautrix.bridge import BasePortal, NotificationDisabler, async_getter_lock from mautrix.errors import MatrixError, MForbidden, MNotFound, SessionNotFound from mautrix.types import ( AudioInfo, ContentURI, EncryptedFile, EventID, EventType, FileInfo, ImageInfo, LocationMessageEventContent, MediaInfo, MediaMessageEventContent, Membership, MessageEventContent, MessageType, PowerLevelStateEventContent, RoomAvatarStateEventContent, RoomNameStateEventContent, RoomTopicStateEventContent, RelationType, RoomCreatePreset, RoomID, StateEvent, StateEventContent, TextMessageEventContent, UserID, VideoInfo, ) from mautrix.util import ffmpeg, magic from mautrix.util.message_send_checkpoint import MessageSendCheckpointStatus from mautrix.util.simple_lock import SimpleLock from . import matrix as m, puppet as p, user as u from .config import Config from .db import ( Message as DBMessage, Portal as DBPortal, ) from .formatter import kakaotalk_to_matrix, matrix_to_kakaotalk from .kt.types.bson import Long from .kt.types.channel.channel_info import ChannelInfo from .kt.types.channel.channel_type import KnownChannelType, ChannelType from .kt.types.chat import Chatlog, ChatType, KnownChatType from .kt.types.chat.attachment import ( Attachment, AudioAttachment, FileAttachment, MediaAttachment, MultiPhotoAttachment, PhotoAttachment, ReplyAttachment, VideoAttachment, ) from .kt.types.openlink.open_link_type import OpenChannelUserPerm from .kt.types.user.channel_user_info import OpenChannelUserInfo from .kt.client.types import ( UserInfoUnion, PortalChannelInfo, PortalChannelParticipantInfo, ChannelProps, TO_MSGTYPE_MAP, FROM_PERM_MAP, TO_PERM_MAP, ) from .kt.client.errors import CommandException if TYPE_CHECKING: from .__main__ import KakaoTalkBridge try: from PIL import Image except ImportError: Image = None try: from mautrix.crypto.attachments import decrypt_attachment, encrypt_attachment except ImportError: decrypt_attachment = encrypt_attachment = None geo_uri_regex: Pattern = re.compile(r"^geo:(-?\d+.\d+),(-?\d+.\d+)$") class FakeLock: async def __aenter__(self) -> None: pass async def __aexit__(self, exc_type, exc, tb) -> None: pass T = TypeVar("T") ACallable = Coroutine[None, None, T] StateEventHandlerContentType = TypeVar("StateEventHandlerContentType", bound=StateEventContent) @dataclass class StateEventHandler(Generic[StateEventHandlerContentType]): apply: Callable[[Portal, u.User, StateEventHandlerContentType, StateEventHandlerContentType], ACallable[None]] revert: Callable[[Portal, StateEventHandlerContentType], ACallable[None]] action_name: str StateBridge = EventType.find("m.bridge", EventType.Class.STATE) StateHalfShotBridge = EventType.find("uk.half-shot.bridge", EventType.Class.STATE) class Portal(DBPortal, BasePortal): invite_own_puppet_to_pm: bool = False by_mxid: dict[RoomID, Portal] = {} by_ktid: dict[tuple[int, int], Portal] = {} matrix: m.MatrixHandler config: Config _main_intent: IntentAPI | None _kt_sender: Long | None _create_room_lock: asyncio.Lock _send_locks: dict[int, asyncio.Lock] _noop_lock: FakeLock = FakeLock() backfill_lock: SimpleLock _backfill_leave: set[IntentAPI] | None _sleeping_to_resync: bool _scheduled_resync: asyncio.Task | None _resync_targets: dict[int, p.Puppet] _CHAT_TYPE_HANDLER_MAP: dict[ChatType, Callable[..., ACallable[list[EventID]]]] _STATE_EVENT_HANDLER_MAP: dict[EventType, StateEventHandler] def __init__( self, ktid: Long, kt_receiver: Long, kt_type: ChannelType, mxid: RoomID | None = None, name: str | None = None, description: str | None = None, photo_id: str | None = None, avatar_url: ContentURI | None = None, encrypted: bool = False, name_set: bool = False, topic_set: bool = False, avatar_set: bool = False, fully_read_kt_chat: Long | None = None, relay_user_id: UserID | None = None, ) -> None: super().__init__( ktid, kt_receiver, kt_type, mxid, name, description, photo_id, avatar_url, encrypted, name_set, topic_set, avatar_set, fully_read_kt_chat, relay_user_id, ) self.log = self.log.getChild(self.ktid_log) self._main_intent = None self._kt_sender = None self._create_room_lock = asyncio.Lock() self._send_locks = {} self._sleeping_to_resync = False self._scheduled_resync = None self._resync_targets = {} self.backfill_lock = SimpleLock( "Waiting for backfilling to finish before handling %s", log=self.log ) self._backfill_leave = None self._relay_user = None @classmethod def init_cls(cls, bridge: KakaoTalkBridge) -> None: BasePortal.bridge = bridge cls.az = bridge.az cls.config = bridge.config cls.loop = bridge.loop cls.matrix = bridge.matrix cls.invite_own_puppet_to_pm = cls.config["bridge.invite_own_puppet_to_pm"] NotificationDisabler.puppet_cls = p.Puppet NotificationDisabler.config_enabled = cls.config["bridge.backfill.disable_notifications"] cls._CHAT_TYPE_HANDLER_MAP = { KnownChatType.FEED: cls._handle_kakaotalk_feed, KnownChatType.TEXT: cls._handle_kakaotalk_text, KnownChatType.REPLY: cls._handle_kakaotalk_reply, KnownChatType.PHOTO: cls._handle_kakaotalk_photo, KnownChatType.MULTIPHOTO: cls._handle_kakaotalk_multiphoto, KnownChatType.VIDEO: cls._handle_kakaotalk_video, KnownChatType.AUDIO: cls._handle_kakaotalk_audio, KnownChatType.FILE: cls._handle_kakaotalk_file, 16385: cls._handle_kakaotalk_deleted, } cls._STATE_EVENT_HANDLER_MAP = { EventType.ROOM_POWER_LEVELS: StateEventHandler( cls._handle_matrix_power_levels, cls._revert_matrix_power_levels, "power level" ), EventType.ROOM_NAME: StateEventHandler( cls._handle_matrix_room_name, cls._revert_matrix_room_name, "room name" ), EventType.ROOM_TOPIC: StateEventHandler( cls._handle_matrix_room_topic, cls._revert_matrix_room_topic, "room topic" ), EventType.ROOM_AVATAR: StateEventHandler( cls._handle_matrix_room_avatar, cls._revert_matrix_room_avatar, "room avatar" ), } @classmethod def supports_state_event(cls, evt_type: EventType) -> bool: return evt_type in cls._STATE_EVENT_HANDLER_MAP # region DB conversion async def delete(self) -> None: if self.mxid: await DBMessage.delete_all_by_room(self.mxid) self.by_mxid.pop(self.mxid, None) self.by_ktid.pop(self.ktid_full, None) self.mxid = None self.name_set = False self.avatar_set = False self.relay_user_id = None self.encrypted = False await super().save() # endregion # region Properties @property def ktid_full(self) -> tuple[Long, Long]: return self.ktid, self.kt_receiver @property def ktid_log(self) -> str: if self.is_direct: return f"{self.ktid}->{self.kt_receiver}" return str(self.ktid) @property def is_direct(self) -> bool: return KnownChannelType.is_direct(self.kt_type) @property def is_open(self) -> bool: return KnownChannelType.is_open(self.kt_type) @property def kt_sender(self) -> int | None: if self.is_direct: if not self._kt_sender: raise ValueError("Direct chat portal must set sender") else: if self._kt_sender: raise ValueError(f"Non-direct chat portal should have no sender, but has sender {self._kt_sender}") return self._kt_sender @property def channel_props(self) -> ChannelProps: return ChannelProps( id=self.ktid, type=self.kt_type ) @property def main_intent(self) -> IntentAPI: if not self._main_intent: raise ValueError("Portal must be postinit()ed before main_intent can be used") return self._main_intent async def get_dm_puppet(self) -> p.Puppet | None: if not self.is_direct: return None return await p.Puppet.get_by_ktid(self.kt_sender) # endregion # region Chat info updating def schedule_resync(self, source: u.User, target: p.Puppet) -> None: self._resync_targets[target.ktid] = target if ( self._sleeping_to_resync and self._scheduled_resync and not self._scheduled_resync.done() ): return self._sleeping_to_resync = True self.log.debug(f"Scheduling resync through {source.mxid}/{source.ktid}") self._scheduled_resync = asyncio.create_task(self._sleep_and_resync(source, 10)) async def _sleep_and_resync(self, source: u.User, sleep: int) -> None: await asyncio.sleep(sleep) targets = self._resync_targets self._sleeping_to_resync = False self._resync_targets = {} for puppet in targets.values(): if not puppet.name or not puppet.name_set: break else: self.log.debug( f"Cancelled resync through {source.mxid}/{source.ktid}, all puppets have names" ) return self.log.debug(f"Resyncing chat through {source.mxid}/{source.ktid} after sleeping") await self.update_info(source) self._scheduled_resync = None self.log.debug(f"Completed scheduled resync through {source.mxid}/{source.ktid}") async def update_info( self, source: u.User, info: PortalChannelInfo | None = None, force_save: bool = False, ) -> PortalChannelInfo: if not info: self.log.debug("Called update_info with no info, fetching it now...") info = await source.client.get_portal_channel_info(self.channel_props) changed = False if not self.is_direct: changed = any( await asyncio.gather( self._update_name(info.name), self._update_description(info.description), self._update_photo(source, info.photoURL), ) ) if info.participantInfo: changed = await self._update_participants(source, info.participantInfo) or changed if changed or force_save: await self.update_bridge_info() await self.save() return info async def _get_mapped_participant_power_levels(self, participants: list[UserInfoUnion]) -> dict[UserID, int]: user_power_levels: dict[UserID, int] = {} for participant in participants: if not isinstance(participant, OpenChannelUserInfo): self.log.warning(f"Info object for participant {participant.userId} of open channel is not an OpenChannelUserInfo") continue await self._update_mapped_ktid_power_levels(user_power_levels, participant.userId, participant.perm) return user_power_levels @staticmethod async def _update_mapped_ktid_power_levels(user_power_levels: dict[UserID, int], ktid: int, perm: OpenChannelUserPerm) -> None: power_level = FROM_PERM_MAP[perm] user = await u.User.get_by_ktid(ktid) if user: user_power_levels[user.mxid] = power_level puppet = await p.Puppet.get_by_ktid(ktid) if puppet: user_power_levels[puppet.mxid] = power_level async def _set_user_power_levels(self, sender: p.Puppet | None, user_power_levels: dict[UserID, int]) -> None: if not self.mxid: return orig_power_levels = await self.main_intent.get_power_levels(self.mxid) user_power_levels = {k: v for k, v in user_power_levels.items() if orig_power_levels.get_user_level(k) != v} if not user_power_levels: return joined_puppets = { puppet.mxid: puppet for puppet in [ await p.Puppet.get_by_custom_mxid(mxid) or await p.Puppet.get_by_mxid(mxid) for mxid in await self.main_intent.get_room_members(self.mxid) ] if puppet } sender_intent = sender.intent_for(self) if sender else self.main_intent admin_level = orig_power_levels.get_user_level(sender_intent.mxid) demoter_ids: list[UserID] = [] power_levels = evolve(orig_power_levels) for user_id, new_level in user_power_levels.items(): curr_level = orig_power_levels.get_user_level(user_id) if curr_level < admin_level or user_id == sender_intent.mxid: # TODO Consider capping the power level here, instead of letting the attempt fail later power_levels.set_user_level(user_id, new_level) elif user_id in joined_puppets: demoter_ids.append(user_id) else: # This is either a non-joined puppet or a non-puppet user self.log.warning(f"Can't change power level of more powerful user {user_id}") try: await sender_intent.set_power_levels(self.mxid, power_levels) except: self.log.exception("Failed to set power level") if demoter_ids: power_levels = evolve(orig_power_levels) for demoter_id in demoter_ids: power_levels.set_user_level(demoter_id, user_power_levels[demoter_id]) try: await joined_puppets[demoter_id].intent_for(self).set_power_levels(self.mxid, power_levels) except: self.log.exception("Failed to set power level") power_levels.set_user_level(demoter_id, orig_power_levels[demoter_id]) @classmethod async def _reupload_kakaotalk_file_from_url( cls, url: str, source: u.User, intent: IntentAPI, *, filename: str | None = None, mimetype: str | None, encrypt: bool = False, find_size: bool = False, convert_audio: bool = False, ) -> tuple[ContentURI, FileInfo | VideoInfo | AudioInfo | ImageInfo, EncryptedFile | None]: if not url: raise ValueError("URL not provided") sandbox = cls.config["bridge.sandbox_media_download"] # TODO Referer header? async with source.client.get(url, sandbox=sandbox) as resp: length = int(resp.headers["Content-Length"]) if length > cls.matrix.media_config.upload_size: raise ValueError("File not available: too large") data = await resp.read() return await cls._reupload_kakaotalk_file_from_bytes( data, intent, filename=filename, mimetype=mimetype, encrypt=encrypt, find_size=find_size, convert_audio=convert_audio, ) @classmethod async def _reupload_kakaotalk_file_from_bytes( cls, data: bytes, intent: IntentAPI, *, filename: str | None = None, mimetype: str | None = None, encrypt: bool = False, find_size: bool = False, convert_audio: bool = False, ) -> tuple[ContentURI, FileInfo | VideoInfo | AudioInfo | ImageInfo, EncryptedFile | None]: if not mimetype: mimetype = magic.mimetype(data) if convert_audio and mimetype != "audio/ogg": data = await ffmpeg.convert_bytes( data, ".ogg", output_args=("-c:a", "libopus"), input_mime=mimetype ) mimetype = "audio/ogg" info = FileInfo(mimetype=mimetype, size=len(data)) if Image and mimetype.startswith("image/") and find_size: with Image.open(BytesIO(data)) as img: width, height = img.size info = ImageInfo(mimetype=mimetype, size=len(data), width=width, height=height) upload_mime_type = mimetype decryption_info = None if encrypt and encrypt_attachment: data, decryption_info = encrypt_attachment(data) upload_mime_type = "application/octet-stream" filename = None url = await intent.upload_media( data, mime_type=upload_mime_type, filename=filename, async_upload=cls.config["homeserver.async_media"], ) if decryption_info: decryption_info.url = url return url, info, decryption_info async def _update_name(self, name: str | None) -> bool: if not name: self.log.warning("Got empty name in _update_name call") return False if self.name != name or not self.name_set: self.log.trace("Updating name %s -> %s", self.name, name) self.name = name if self.mxid and (self.encrypted or not self.is_direct): try: await self.main_intent.set_room_name(self.mxid, self.name) self.name_set = True except Exception: self.log.exception("Failed to set room name") self.name_set = False return True return False async def _update_description(self, description: str | None) -> bool: if self.description != description or not self.topic_set: self.log.trace("Updating description %s -> %s", self.description, description) self.description = description if self.mxid and (self.encrypted or not self.is_direct): try: await self.main_intent.set_room_topic(self.mxid, self.description or "") self.topic_set = True except Exception: self.log.exception("Failed to set room description") self.topic_set = False return True return False async def _update_photo(self, source: u.User, photo_id: str | None) -> bool: if self.is_direct and not self.encrypted: return False if self.photo_id is not None and photo_id is None: self.log.warning("Portal previously had a photo_id, but new photo_id is None. Leaving it as it is") return False if self.photo_id != photo_id or not self.avatar_set: self.photo_id = photo_id if photo_id: if self.photo_id != photo_id or not self.avatar_url: # Reset avatar_url first in case the upload fails self.avatar_url = None self.avatar_url = await p.Puppet.reupload_avatar( source, self.main_intent, photo_id, self.ktid, ) else: self.avatar_url = ContentURI("") if self.mxid: try: await self.main_intent.set_room_avatar(self.mxid, self.avatar_url) self.avatar_set = True except Exception: self.log.exception("Failed to set room avatar") self.avatar_set = False return True return False async def _update_photo_from_puppet(self, puppet: p.Puppet) -> bool: if self.photo_id == puppet.photo_id and self.avatar_set: return False self.photo_id = puppet.photo_id if puppet.photo_mxc: self.avatar_url = puppet.photo_mxc elif self.photo_id: profile = await self.main_intent.get_profile(puppet.default_mxid) self.avatar_url = profile.avatar_url puppet.photo_mxc = profile.avatar_url else: self.avatar_url = ContentURI("") if self.mxid: try: await self.main_intent.set_room_avatar(self.mxid, self.avatar_url) self.avatar_set = True except Exception: self.log.exception("Failed to set room avatar") self.avatar_set = False return True async def update_info_from_puppet(self, puppet: p.Puppet | None = None) -> bool: if not self.is_direct: return False if not puppet: puppet = await self.get_dm_puppet() if not puppet: return False changed = await self._update_name(puppet.name) changed = await self._update_photo_from_puppet(puppet) or changed return changed """ async def sync_per_room_nick(self, puppet: p.Puppet, name: str) -> None: intent = puppet.intent_for(self) content = MemberStateEventContent( membership=Membership.JOIN, avatar_url=puppet.photo_mxc, displayname=name or puppet.name, ) content[DOUBLE_PUPPET_SOURCE_KEY] = self.bridge.name current_state = await intent.state_store.get_member(self.mxid, intent.mxid) if not current_state or current_state.displayname != content.displayname: self.log.debug( "Syncing %s's per-room nick %s to the room", puppet.ktid, content.displayname, ) await intent.send_state_event( self.mxid, EventType.ROOM_MEMBER, content, state_key=intent.mxid ) """ async def _update_participant( self, source: u.User, participant: UserInfoUnion ) -> bool: # TODO nick map? self.log.trace(f"Syncing participant {participant.userId}") puppet = await p.Puppet.get_by_ktid(participant.userId) await puppet.update_info_from_participant(source, participant) changed = False if self.is_direct and self._kt_sender == puppet.ktid and self.encrypted: changed = await self.update_info_from_puppet(puppet.name) or changed if self.mxid: if puppet.ktid != self.kt_receiver or puppet.is_real_user: await puppet.intent_for(self).ensure_joined(self.mxid, bot=self.main_intent) #if puppet.ktid in nick_map: # await self.sync_per_room_nick(puppet, nick_map[puppet.ktid]) return changed async def _update_participants( self, source: u.User, participant_info: PortalChannelParticipantInfo | None = None, ) -> bool: # NOTE This handles only non-logged-in users, because logged-in users should be handled by the channel list listeners # TODO nick map? if participant_info is None: self.log.debug("Called _update_participants with no participant info, fetching it now...") participant_info = await source.client.get_portal_channel_participant_info(self.channel_props) if self.mxid: # NOTE KakaoTalk kick = Matrix ban prev_banned_mxids = { cast(UserID, event.state_key) for event in await self.main_intent.get_members(self.mxid, membership=Membership.BAN) } results = await asyncio.gather(*[ self.handle_kakaotalk_user_left(source, None, puppet) for puppet in [ await p.Puppet.get_by_ktid(ktid) for ktid in participant_info.kickedUserIds ] if puppet and puppet.mxid not in prev_banned_mxids ], return_exceptions=True) for e in filter(lambda x: isinstance(x, Exception), results): self.log.exception(e) joined_ktids = {pcp.userId for pcp in participant_info.participants} results = await asyncio.gather(*[ self.handle_kakaotalk_user_left(source, puppet, puppet) for puppet in [ await p.Puppet.get_by_mxid(mxid) for mxid in await self.main_intent.get_room_members(self.mxid) ] if puppet and puppet.ktid not in joined_ktids ], return_exceptions=True) for e in filter(lambda x: isinstance(x, Exception), results): self.log.exception(e) kicked_ktids = set(participant_info.kickedUserIds) results = await asyncio.gather(*[ self.handle_kakaotalk_user_unkick(source, None, puppet) for puppet in [ await p.Puppet.get_by_mxid(mxid) for mxid in prev_banned_mxids ] if puppet and puppet.ktid not in kicked_ktids ], return_exceptions=True) for e in filter(lambda x: isinstance(x, Exception), results): self.log.exception(e) changed = False results = await asyncio.gather(*[ self._update_participant(source, pcp) for pcp in participant_info.participants ], return_exceptions=True) for result in results: if isinstance(result, Exception): self.log.exception(result) else: changed = result or changed if self.mxid and self.is_open: # TODO Find whether perms apply to any non-direct channel, or just open ones user_power_levels = await self._get_mapped_participant_power_levels(participant_info.participants) await self._set_user_power_levels(None, user_power_levels) return changed # endregion # region Matrix room creation async def update_matrix_room(self, source: u.User, info: PortalChannelInfo | None = None) -> None: try: await self._update_matrix_room(source, info) except Exception: self.log.exception("Failed to update portal") def _get_invite_content(self, double_puppet: p.Puppet | None) -> dict[str, Any]: invite_content = {} if double_puppet: invite_content["fi.mau.will_auto_accept"] = True if self.is_direct: invite_content["is_direct"] = True return invite_content async def _update_matrix_room( self, source: u.User, info: PortalChannelInfo | None = None ) -> None: puppet = await p.Puppet.get_by_custom_mxid(source.mxid) await self.main_intent.invite_user( self.mxid, source.mxid, check_cache=True, extra_content=self._get_invite_content(puppet), ) if puppet: did_join = await puppet.intent.ensure_joined(self.mxid) if did_join and self.is_direct: await source.update_direct_chats({self.main_intent.mxid: [self.mxid]}) info = await self.update_info(source, info) await self._sync_read_receipts(source) async def _sync_read_receipts(self, source: u.User) -> None: messages = await DBMessage.get_all_since(self.ktid, self.kt_receiver, self.fully_read_kt_chat) receipts = await source.client.get_read_receipts( self.channel_props, [m.ktid for m in messages if m.ktid] ) if not receipts: return for receipt in receipts: message = await DBMessage.get_closest_before( self.ktid, self.kt_receiver, receipt.chatId ) if not message: continue puppet = await p.Puppet.get_by_ktid(receipt.userId, create=False) if not puppet: continue try: await puppet.intent_for(self).mark_read(message.mx_room, message.mxid) except Exception: self.log.warning( f"Failed to mark {message.mxid} in {message.mx_room} " f"as read by {puppet.intent.mxid}", exc_info=True, ) fully_read_kt_chat = min(receipt.chatId for receipt in receipts) if not self.fully_read_kt_chat or self.fully_read_kt_chat < fully_read_kt_chat: self.fully_read_kt_chat = fully_read_kt_chat await self.save() async def create_matrix_room( self, source: u.User, info: PortalChannelInfo | None = None ) -> RoomID | None: if self.mxid: try: await self._update_matrix_room(source, info) except Exception: self.log.exception("Failed to update portal") return self.mxid async with self._create_room_lock: try: return await self._create_matrix_room(source, info) except Exception: self.log.exception("Failed to create portal") return None @property def bridge_info_state_key(self) -> str: return f"net.miscworks.kakaotalk://kakaotalk/{self.ktid}" @property def bridge_info(self) -> dict[str, Any]: return { "bridgebot": self.az.bot_mxid, "creator": self.main_intent.mxid, "protocol": { "id": "kakaotalk", "displayname": "KakaoTalk", "avatar_url": self.config["appservice.bot_avatar"], }, "channel": { "id": str(self.ktid), "displayname": self.name, "avatar_url": self.avatar_url, }, } async def update_bridge_info(self) -> None: if not self.mxid: self.log.debug("Not updating bridge info: no Matrix room created") return try: self.log.debug("Updating bridge info...") await self.main_intent.send_state_event( self.mxid, StateBridge, self.bridge_info, self.bridge_info_state_key ) # TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec await self.main_intent.send_state_event( self.mxid, StateHalfShotBridge, self.bridge_info, self.bridge_info_state_key ) except Exception: self.log.warning("Failed to update bridge info", exc_info=True) async def _create_matrix_room( self, source: u.User, info: PortalChannelInfo | None = None ) -> RoomID: if self.mxid: await self._update_matrix_room(source, info=info) return self.mxid self.log.debug(f"Creating Matrix room") if self.is_direct: # NOTE Must do this to find the other member of the DM, since the channel ID != the member's ID! if not info or not info.participantInfo: info = await source.client.get_portal_channel_info(self.channel_props) assert info.participantInfo await self._update_participants(source, info.participantInfo) name: str | None = None description: str | None = None initial_state = [ { "type": str(StateBridge), "state_key": self.bridge_info_state_key, "content": self.bridge_info, }, # TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec { "type": str(StateHalfShotBridge), "state_key": self.bridge_info_state_key, "content": self.bridge_info, }, ] if self.is_open: preset = RoomCreatePreset.PUBLIC # TODO Find whether perms apply to any non-direct channel, or just open ones if not info or not info.participantInfo: info = await source.client.get_portal_channel_info(self.channel_props) assert info.participantInfo user_power_levels = await self._get_mapped_participant_power_levels(info.participantInfo.participants) # NOTE Giving the bot a +1 power level if necessary so it can demote non-puppet admins user_power_levels[self.main_intent.mxid] = max(100, 1 + FROM_PERM_MAP[OpenChannelUserPerm.OWNER]) power_level_override = PowerLevelStateEventContent(users=user_power_levels) else: preset = RoomCreatePreset.PRIVATE power_level_override = None invites = [] if self.config["bridge.encryption.default"] and self.matrix.e2ee: self.encrypted = True initial_state.append( { "type": "m.room.encryption", "content": {"algorithm": "m.megolm.v1.aes-sha2"}, } ) if self.is_direct: invites.append(self.az.bot_mxid) info = await self.update_info(source=source, info=info) if self.encrypted or not self.is_direct: name = self.name description = self.description initial_state.append( { "type": str(EventType.ROOM_AVATAR), "content": {"url": self.avatar_url}, } ) # We lock backfill lock here so any messages that come between the room being created # and the initial backfill finishing wouldn't be bridged before the backfill messages. with self.backfill_lock: creation_content = {} if not self.config["bridge.federate_rooms"]: creation_content["m.federate"] = False self.mxid = await self.main_intent.create_room( preset=preset, name=name, topic=description, is_direct=self.is_direct, initial_state=initial_state, invitees=invites, creation_content=creation_content, power_level_override=power_level_override, ) if not self.mxid: raise Exception("Failed to create room: no mxid returned") if self.encrypted and self.matrix.e2ee and self.is_direct: try: await self.az.intent.ensure_joined(self.mxid) except Exception: self.log.warning(f"Failed to add bridge bot to new private chat {self.mxid}") await self.save() self.log.debug(f"Matrix room created: {self.mxid}") self.by_mxid[self.mxid] = self puppet = await p.Puppet.get_by_custom_mxid(source.mxid) await self.main_intent.invite_user( self.mxid, source.mxid, extra_content=self._get_invite_content(puppet) ) if puppet: try: if self.is_direct: await source.update_direct_chats({self.main_intent.mxid: [self.mxid]}) await puppet.intent.join_room_by_id(self.mxid) except MatrixError: self.log.debug( "Failed to join custom puppet into newly created portal", exc_info=True, ) if not self.is_direct: # NOTE Calling this after room creation to invite participants await self._update_participants(source, info.participantInfo) if info.channel_info: try: await self.backfill(source, is_initial=True, channel_info=info.channel_info) # NOTE This also syncs read receipts except Exception: self.log.exception("Failed to backfill new portal") return self.mxid # endregion # region Matrix event handling def require_send_lock(self, user_id: int) -> asyncio.Lock: try: lock = self._send_locks[user_id] except KeyError: lock = asyncio.Lock() self._send_locks[user_id] = lock return lock def optional_send_lock(self, user_id: int) -> asyncio.Lock | FakeLock: try: return self._send_locks[user_id] except KeyError: pass return self._noop_lock async def _send_delivery_receipt(self, event_id: EventID) -> None: if event_id and self.config["bridge.delivery_receipts"]: try: await self.az.intent.mark_read(self.mxid, event_id) except Exception: self.log.exception(f"Failed to send delivery receipt for {event_id}") async def _send_bridge_error(self, msg: str, thing: str = "message") -> None: await self._send_message( self.main_intent, TextMessageEventContent( msgtype=MessageType.NOTICE, body=f"\u26a0 Your {thing} may not have been bridged: {msg}", ), ) def _status_from_exception(self, e: Exception) -> MessageSendCheckpointStatus: if isinstance(e, NotImplementedError): return MessageSendCheckpointStatus.UNSUPPORTED return MessageSendCheckpointStatus.PERM_FAILURE async def handle_matrix_message( self, sender: u.User, message: MessageEventContent, event_id: EventID ) -> None: try: await self._handle_matrix_message(sender, message, event_id) except Exception as e: self.log.exception(f"Failed to handle Matrix event {event_id}: {e}") sender.send_remote_checkpoint( self._status_from_exception(e), event_id, self.mxid, EventType.ROOM_MESSAGE, message.msgtype, error=e, ) await self._send_bridge_error(str(e)) else: await self._send_delivery_receipt(event_id) async def _handle_matrix_message( self, orig_sender: u.User, message: MessageEventContent, event_id: EventID ) -> None: if message.get_edit(): raise NotImplementedError("Edits are not supported by the KakaoTalk bridge.") if message.relates_to.rel_type == RelationType.REPLY and not message.msgtype.is_text: raise NotImplementedError("Replying with non-text content is not supported by the KakaoTalk bridge.") sender, is_relay = await self.get_relay_sender(orig_sender, f"message {event_id}") if not sender: raise Exception("not logged in") elif not sender.is_connected: raise Exception("not connected to KakaoTalk chats") elif is_relay: if not message.msgtype.is_text: intro_message = TextMessageEventContent(msgtype=MessageType.TEXT, body=message.body) await self.apply_relay_message_format(orig_sender, intro_message) await self._send_chat(sender, intro_message) else: await self.apply_relay_message_format(orig_sender, message) if message.msgtype == MessageType.TEXT or message.msgtype == MessageType.NOTICE: await self._handle_matrix_text(event_id, sender, message) elif message.msgtype.is_media: await self._handle_matrix_media(event_id, sender, message) # elif message.msgtype == MessageType.LOCATION: # await self._handle_matrix_location(sender, message) else: raise NotImplementedError(f"Unsupported message type {message.msgtype}") async def _send_chat( self, sender: u.User, message: TextMessageEventContent, event_id: EventID | None = None ) -> Long: converted = await matrix_to_kakaotalk(message, self.mxid, self.log, self) try: return await sender.client.send_chat( self.channel_props, text=converted.text, reply_to=converted.reply_to, mentions=converted.mentions, ) except CommandException as e: self.log.debug(f"Error handling Matrix message {event_id if event_id else ''}: {e!s}") raise async def _make_dbm(self, event_id: EventID, ktid: Long | None = None) -> DBMessage: dbm = DBMessage( mxid=event_id, mx_room=self.mxid, ktid=ktid, index=0, kt_channel=self.ktid, kt_receiver=self.kt_receiver, timestamp=int(time.time() * 1000), ) await dbm.insert() return dbm async def _handle_matrix_text( self, event_id: EventID, sender: u.User, message: TextMessageEventContent ) -> None: log_id = await self._send_chat(sender, message, event_id) await self._make_dbm(event_id, log_id) self.log.debug(f"Handled Matrix message {event_id} -> {log_id}") sender.send_remote_checkpoint( MessageSendCheckpointStatus.SUCCESS, event_id, self.mxid, EventType.ROOM_MESSAGE, message.msgtype, ) async def _handle_matrix_media( self, event_id: EventID, sender: u.User, message: MediaMessageEventContent ) -> None: if message.file and decrypt_attachment: data = await self.main_intent.download_media(message.file.url) data = decrypt_attachment( data, message.file.key.key, message.file.hashes.get("sha256"), message.file.iv ) elif message.url: data = await self.main_intent.download_media(message.url) else: raise NotImplementedError("No file or URL specified") mimetype = message.info.mimetype or magic.mimetype(data) filename = message.body width, height = None, None if message.msgtype in (MessageType.IMAGE, MessageType.STICKER, MessageType.VIDEO): width = message.info.width height = message.info.height try: ext = guess_extension(mimetype) log_id = await sender.client.send_media( self.channel_props, TO_MSGTYPE_MAP[message.msgtype], data, filename, width=width, height=height, ext=ext[1:] if ext else "", ) except CommandException as e: self.log.debug(f"Error uploading media for Matrix message {event_id}: {e!s}") raise await self._make_dbm(event_id, log_id) self.log.debug(f"Handled Matrix message {event_id} -> {log_id}") sender.send_remote_checkpoint( MessageSendCheckpointStatus.SUCCESS, event_id, self.mxid, EventType.ROOM_MESSAGE, message.msgtype, ) async def _handle_matrix_location( self, sender: u.User, message: LocationMessageEventContent ) -> str: pass # TODO # match = geo_uri_regex.fullmatch(message.geo_uri) # return await self.thread_for(sender).send_pinned_location(float(match.group(1)), # float(match.group(2))) async def handle_matrix_redaction( self, sender: u.User, event_id: EventID, redaction_event_id: EventID ) -> None: try: await self._handle_matrix_redaction(sender, event_id) except Exception as e: self.log.error( f"Failed to handle Matrix redaction {redaction_event_id}: {e}", exc_info=not isinstance(e, NotImplementedError), ) sender.send_remote_checkpoint( self._status_from_exception(e), redaction_event_id, self.mxid, EventType.ROOM_REDACTION, error=e, ) if not isinstance(e, NotImplementedError): await self._send_bridge_error(str(e), thing="redaction") else: await self._send_delivery_receipt(redaction_event_id) sender.send_remote_checkpoint( MessageSendCheckpointStatus.SUCCESS, redaction_event_id, self.mxid, EventType.ROOM_REDACTION, ) async def _handle_matrix_redaction(self, sender: u.User, event_id: EventID) -> None: sender, _ = await self.get_relay_sender(sender, f"redaction {event_id}") if not sender: raise Exception("not logged in") elif not sender.is_connected: raise Exception("not connected to KakaoTalk chats") message = await DBMessage.get_by_mxid(event_id, self.mxid) if message: if not message.ktid: raise NotImplementedError("Tried to redact message whose ktid is unknown") try: await message.delete() await sender.client.delete_chat(self.channel_props, message.ktid) except Exception as e: self.log.exception(f"Unsend failed: {e}") raise return raise NotImplementedError("Only message redactions are supported") """ TODO reaction = await DBReaction.get_by_mxid(event_id, self.mxid) if reaction: try: await reaction.delete() await sender.client.react(reaction.kt_msgid, None) except Exception as e: self.log.exception(f"Removing reaction failed: {e}") raise return raise NotImplementedError("Only message and reaction redactions are supported") """ """ TODO async def handle_matrix_reaction( self, sender: u.User, event_id: EventID, reacting_to: EventID, reaction: str ) -> None: pass """ async def handle_matrix_state_event(self, sender: u.User, evt: StateEvent) -> None: try: handler: StateEventHandler = self._STATE_EVENT_HANDLER_MAP[evt.type] except KeyError: # Misses should be guarded by supports_state_event, but handle this just in case self.log.error(f"Skipping Matrix state event {evt.event_id} of unsupported type {evt.type}") return if not self.is_open: self.log.info(f"Not bridging f{handler.action_name} change of portal for non-open channel") return try: effective_sender, _ = await self.get_relay_sender(sender, f"{handler.action_name} {evt.event_id}") if effective_sender: await handler.apply(self, effective_sender, evt.prev_content, evt.content) except Exception as e: self.log.error( f"Failed to handle Matrix {handler.action_name} {evt.event_id}: {e}", exc_info=not isinstance(e, NotImplementedError), ) sender.send_remote_checkpoint( self._status_from_exception(e), evt.event_id, self.mxid, evt.type, error=e, ) change = f"{handler.action_name} change" await self._send_bridge_error( f"{e}. Reverting the {change}...", thing=change ) # NOTE Redacting instead doesn't work await handler.revert(self, evt.prev_content) else: await self._send_delivery_receipt(evt.event_id) sender.send_remote_checkpoint( MessageSendCheckpointStatus.SUCCESS, evt.event_id, self.mxid, evt.type, ) async def _handle_matrix_power_levels( self, sender: u.User, prev_content: PowerLevelStateEventContent, content: PowerLevelStateEventContent, ) -> None: ktid_perms: dict[Long, OpenChannelUserPerm] = {} user_power_levels: dict[UserID, int] = {} for user_id, level in content.users.items(): if level == prev_content.get_user_level(user_id): continue ktid = None mxid = None puppet = await p.Puppet.get_by_mxid(user_id) user = await u.User.get_by_mxid(user_id) if not puppet else None if puppet: ktid = puppet.ktid user = await u.User.get_by_ktid(ktid) if user: mxid = user.mxid elif user: ktid = user.ktid puppet = await p.Puppet.get_by_ktid(ktid) if puppet: mxid = puppet.mxid if ktid is not None: ktid_perms[ktid] = TO_PERM_MAP.get(level) if mxid is not None: user_power_levels[mxid] = level if ktid_perms: if sender and sender.is_connected: if user_power_levels: await self._set_user_power_levels(await sender.get_puppet(), user_power_levels) ok = True results = await asyncio.gather(*[ sender.client.send_perm(self.channel_props, ktid, perm) for ktid, perm in ktid_perms.items() ], return_exceptions=True) for e in filter(lambda x: isinstance(x, Exception), results): ok = False self.log.exception(e) if not ok: self.log.info("Failed to send all perms, so re-syncing all participant info") await self._update_participants(sender) else: raise Exception( "Only users connected to KakaoTalk can set power levels of KakaoTalk users" ) async def _revert_matrix_power_levels(self, prev_content: PowerLevelStateEventContent) -> None: managed_power_levels: dict[UserID, int] = {} for user_id, level in prev_content.users.items(): if await p.Puppet.get_by_mxid(user_id) or await u.User.get_by_mxid(user_id): managed_power_levels[user_id] = level await self._set_user_power_levels(None, managed_power_levels) async def _handle_matrix_room_name( self, sender: u.User, prev_content: RoomNameStateEventContent, content: RoomNameStateEventContent, ) -> None: if content.name == prev_content.name: return if not (sender and sender.is_connected): raise Exception( "Only users connected to KakaoTalk can set the name of a KakaoTalk channel" ) await sender.client.set_channel_name(self.channel_props, content.name) self.name = content.name self.name_set = True await self.save() async def _revert_matrix_room_name(self, prev_content: RoomNameStateEventContent) -> None: await self.main_intent.set_room_name(self.mxid, prev_content.name) async def _handle_matrix_room_topic( self, sender: u.User, prev_content: RoomTopicStateEventContent, content: RoomTopicStateEventContent, ) -> None: if content.topic == prev_content.topic: return if not (sender and sender.is_connected): raise Exception( "Only users connected to KakaoTalk can set the description of a KakaoTalk channel" ) await sender.client.set_channel_description(self.channel_props, content.topic) self.description = content.topic self.topic_set = True await self.save() async def _revert_matrix_room_topic(self, prev_content: RoomTopicStateEventContent) -> None: await self.main_intent.set_room_topic(self.mxid, prev_content.topic or "") async def _handle_matrix_room_avatar( self, sender: u.User, prev_content: RoomAvatarStateEventContent, content: RoomAvatarStateEventContent, ) -> None: if content.url == prev_content.url: return if not (sender and sender.is_connected): raise Exception( "Only users connected to KakaoTalk can set the photo of a KakaoTalk channel" ) raise NotImplementedError("Changing the room avatar is not supported by the KakaoTalk bridge.") """ TODO photo_url = str(self.main_intent.api.get_download_url(content.url)) await sender.client.set_channel_photo(self.channel_props, photo_url) self.photo_id = photo_url self.avatar_url = content.url self.avatar_set = True await self.save() """ async def _revert_matrix_room_avatar(self, prev_content: RoomAvatarStateEventContent) -> None: await self.main_intent.set_room_avatar(self.mxid, prev_content.url) async def handle_matrix_leave(self, user: u.User) -> None: if self.is_direct: self.log.info(f"{user.mxid} left private chat portal with {self.ktid}") if user.ktid == self.kt_receiver: self.log.info( f"{user.mxid} was the recipient of this portal. Cleaning up and deleting..." ) await self.cleanup_and_delete() else: self.log.debug(f"{user.mxid} left portal to {self.ktid}") async def leave_kakaotalk_channel(self, user: u.User) -> None: await user.client.leave_channel(self.channel_props) await user.on_channel_left(self.ktid, self.kt_type) # endregion # region KakaoTalk event handling async def _bridge_own_message_pm( self, source: u.User, sender: p.Puppet, mid: str, invite: bool = True ) -> bool: if self.is_direct and sender.ktid == source.ktid and not sender.is_real_user: if self.invite_own_puppet_to_pm and invite: await self.main_intent.invite_user(self.mxid, sender.mxid) elif ( await self.az.state_store.get_membership(self.mxid, sender.mxid) != Membership.JOIN ): self.log.warning( f"Ignoring own {mid} in private chat because own puppet is not in room." ) return False return True async def _add_kakaotalk_reply( self, content: MessageEventContent, reply_to: ReplyAttachment ) -> None: message = await DBMessage.get_by_ktid(reply_to.src_logId, *self.ktid_full) if not message: self.log.warning( f"Couldn't find reply target {reply_to.src_logId} to bridge reply metadata to Matrix" ) return content.set_reply(message.mxid) if not isinstance(content, TextMessageEventContent): return try: evt = await self.main_intent.get_event(message.mx_room, message.mxid) except (MNotFound, MForbidden): evt = None if not evt: return if evt.type == EventType.ROOM_ENCRYPTED: try: evt = await self.matrix.e2ee.decrypt(evt, wait_session_timeout=0) except SessionNotFound: return if isinstance(evt.content, TextMessageEventContent): evt.content.trim_reply_fallback() content.set_reply(evt) async def handle_kakaotalk_chat( self, source: u.User, sender: p.Puppet, chat: Chatlog, ) -> None: try: await self._handle_kakaotalk_chat(source, sender, chat) except Exception: self.log.exception( "Error handling KakaoTalk chat %s", chat.logId, ) async def _handle_kakaotalk_chat( self, source: u.User, sender: p.Puppet, chat: Chatlog, ) -> None: # TODO Backfill!! This avoids timing conflicts on startup sync self.log.debug(f"Handling KakaoTalk event {chat.logId}") if not self.mxid: mxid = await self.create_matrix_room(source) if not mxid: # Failed to create return if not await self._bridge_own_message_pm(source, sender, f"chat {chat.logId}"): return intent = sender.intent_for(self) if ( self._backfill_leave is not None and self.ktid != sender.ktid and intent != sender.intent and intent not in self._backfill_leave ): self.log.debug("Adding %s's default puppet to room for backfilling", sender.mxid) await self.main_intent.invite_user(self.mxid, intent.mxid) await intent.ensure_joined(self.mxid) self._backfill_leave.add(intent) handler = self._CHAT_TYPE_HANDLER_MAP.get(chat.type, Portal._handle_kakaotalk_unsupported) event_ids = [ event_id for event_id in await handler( self, source=source, intent=intent, attachment=chat.attachment, timestamp=chat.sendAt, chat_text=chat.text, chat_type=chat.type, ) if event_id ] if not event_ids: self.log.warning(f"Unhandled KakaoTalk chat {chat.logId}") return self.log.debug(f"Handled KakaoTalk chat {chat.logId} -> {event_ids}") # TODO Might have to handle remote reactions on messages created by bulk_create await DBMessage.bulk_create( ktid=chat.logId, kt_channel=self.ktid, kt_receiver=self.kt_receiver, mx_room=self.mxid, timestamp=chat.sendAt, event_ids=event_ids, ) await self._send_delivery_receipt(event_ids[-1]) async def _handle_kakaotalk_unsupported( self, intent: IntentAPI, timestamp: int, chat_text: str | None, chat_type: ChatType, **_ ) -> list[EventID]: try: type_str = KnownChatType(chat_type).name.lower() except ValueError: type_str = str(chat_type) self.log.warning("No handler for chat type \"%s\" (%s)", type_str, f"text = \"{chat_text}\"" if chat_text is not None else "no text", ) if chat_text: events = await self._handle_kakaotalk_text( intent=intent, attachment=None, timestamp=timestamp, chat_text=chat_text, ) else: events = [] content = TextMessageEventContent( msgtype=MessageType.NOTICE, body=f"\u26a0 Unbridgeable message ({type_str})", ) if events: content.set_reply(events[-1]) events.append(await self._send_message(intent, content, timestamp=timestamp)) return events async def _handle_kakaotalk_feed( self, timestamp: int, chat_text: str | None, **_ ) -> list[EventID]: self.log.info("Got feed message at %s: %s", timestamp, chat_text or "none") return [] async def _handle_kakaotalk_deleted( self, timestamp: int, **_ ) -> list[EventID]: self.log.info(f"Got deleted (?) message at {timestamp}") return [] async def _handle_kakaotalk_text( self, intent: IntentAPI, attachment: Attachment | None, timestamp: int, chat_text: str | None, **_ ) -> list[EventID]: content = await kakaotalk_to_matrix(chat_text, attachment.mentions if attachment else None) return [await self._send_message(intent, content, timestamp=timestamp)] async def _handle_kakaotalk_reply( self, intent: IntentAPI, attachment: ReplyAttachment, timestamp: int, chat_text: str, **_ ) -> list[EventID]: content = await kakaotalk_to_matrix(chat_text, attachment.mentions) await self._add_kakaotalk_reply(content, attachment) return [await self._send_message(intent, content, timestamp=timestamp)] async def _handle_kakaotalk_photo(self, **kwargs) -> list[EventID]: return [await self._handle_kakaotalk_uniphoto(**kwargs)] async def _handle_kakaotalk_multiphoto( self, attachment: MultiPhotoAttachment, **kwargs ) -> list[EventID]: # TODO Upload media concurrently, but post messages sequentially return [ await self._handle_kakaotalk_uniphoto( attachment=PhotoAttachment( shout=attachment.shout, mentions=attachment.mentions, urls=attachment.urls, url=attachment.imageUrls[i], s=attachment.sl[i], k=attachment.kl[i], w=attachment.wl[i], h=attachment.hl[i], thumbnailUrl=attachment.thumbnailUrls[i], thumbnailWidth=attachment.thumbnailWidths[i], thumbnailHeight=attachment.thumbnailHeights[i], cs=attachment.csl[i], mt=attachment.mtl[i], ), **kwargs ) for i in range(len(attachment.imageUrls)) ] def _handle_kakaotalk_uniphoto( self, attachment: PhotoAttachment, **kwargs ) -> Awaitable[EventID]: return self._handle_kakaotalk_media( attachment, ImageInfo( mimetype=attachment.mt, size=attachment.s, width=attachment.w, height=attachment.h, ), MessageType.IMAGE, **kwargs ) async def _handle_kakaotalk_video( self, attachment: VideoAttachment, **kwargs ) -> list[EventID]: return [await self._handle_kakaotalk_media( attachment, VideoInfo( duration=attachment.d, width=attachment.w, height=attachment.h, ), MessageType.VIDEO, **kwargs )] async def _handle_kakaotalk_audio( self, attachment: AudioAttachment, **kwargs ) -> list[EventID]: return [await self._handle_kakaotalk_media( attachment, AudioInfo( size=attachment.s, duration=attachment.d, ), MessageType.AUDIO, **kwargs )] async def _handle_kakaotalk_media( self, attachment: MediaAttachment | AudioAttachment, info: MediaInfo, msgtype: MessageType, *, source: u.User, intent: IntentAPI, timestamp: int, chat_text: str | None, **_ ) -> EventID: mxc, additional_info, decryption_info = await self._reupload_kakaotalk_file_from_url( attachment.url, source, intent, mimetype=info.mimetype, encrypt=self.encrypted, find_size=False, ) info.size = additional_info.size info.mimetype = additional_info.mimetype content = MediaMessageEventContent( url=mxc, file=decryption_info, msgtype=msgtype, body=chat_text or "", info=info ) return await self._send_message(intent, content, timestamp=timestamp) async def _handle_kakaotalk_file( self, source: u.User, intent: IntentAPI, attachment: FileAttachment, timestamp: int, chat_text: str | None, **_ ) -> list[EventID]: data = await source.client.download_file(self.channel_props, attachment.k) mxc, info, decryption_info = await self._reupload_kakaotalk_file_from_bytes( data, intent, filename=attachment.name, encrypt=self.encrypted, ) content = MediaMessageEventContent( url=mxc, file=decryption_info, msgtype=MessageType.FILE, body=chat_text or "", info=info ) return [await self._send_message(intent, content, timestamp=timestamp)] async def handle_kakaotalk_chat_delete( self, sender: p.Puppet, chat_id: Long, timestamp: int, ) -> None: if not self.mxid: return for message in await DBMessage.get_all_by_ktid(chat_id, *self.ktid_full): try: await sender.intent_for(self).redact( message.mx_room, message.mxid, timestamp=timestamp ) except MForbidden: await self.main_intent.redact(message.mx_room, message.mxid, timestamp=timestamp) await message.delete() async def handle_kakaotalk_chat_read(self, source: u.User, sender: p.Puppet, chat_id: Long) -> None: if not self.mxid: return msg = await DBMessage.get_closest_before(self.ktid, self.kt_receiver, chat_id) if not msg: return if not await self._bridge_own_message_pm(source, sender, "read receipt", invite=False): return # NOTE No need for timestamp when the read receipt happened, since this is only for live ones await sender.intent_for(self).mark_read(msg.mx_room, msg.mxid) self.log.debug( f"Handled KakaoTalk read receipt from {sender.ktid} up to {chat_id}/{msg.mxid}" ) async def handle_kakaotalk_perm_changed( self, source: u.User, sender: p.Puppet, user_id: Long, perm: OpenChannelUserPerm ) -> None: user_power_levels: dict[UserID, int] = {} await self._update_mapped_ktid_power_levels(user_power_levels, user_id, perm) await self._set_user_power_levels(sender, user_power_levels) async def handle_kakaotalk_user_join( self, source: u.User, user: p.Puppet ) -> None: # TODO Check if a KT user can join as an admin / room owner await self.main_intent.invite_user(self.mxid, user.mxid) await user.intent_for(self).join_room_by_id(self.mxid) if not user.name: self.schedule_resync(source, user) async def handle_kakaotalk_user_left( self, source: u.User, sender: p.Puppet | None, removed: p.Puppet ) -> None: sender_intent = sender.intent_for(self) if sender else self.main_intent if sender == removed: removed_intent = removed.intent_for(self) if removed_intent != self.main_intent: await removed_intent.leave_room(self.mxid) if not removed.is_real_user: user = await u.User.get_by_ktid(removed.ktid) if user: await self.main_intent.kick_user(self.mxid, user.mxid, "Left channel from KakaoTalk") else: for removed_mxid in (r.mxid for r in ( removed, await u.User.get_by_ktid(removed.ktid) if not removed.is_real_user else None ) if r): try: await sender_intent.ban_user( self.mxid, removed_mxid, None if sender else "Kicked by channel admin" ) except MForbidden: if not sender: raise await self.main_intent.ban_user( self.mxid, removed_mxid, reason=f"Kicked by {sender.name}" ) # TODO Clean and delete if removed is real user and portal is direct / not open # TODO Find when or if there is a listener for this # TODO Confirm whether this can refer to any user that was kicked, or only to the current user async def handle_kakaotalk_user_unkick( self, source: u.User, sender: p.Puppet | None, unkicked: p.Puppet ) -> None: assert sender != unkicked, f"Puppet for {unkicked.mxid} tried to unkick itself" sender_intent = sender.intent_for(self) if sender else self.main_intent for unkicked_mxid in (r.mxid for r in ( unkicked, await u.User.get_by_ktid(unkicked.ktid) if not unkicked.is_real_user else None ) if r): # NOTE KakaoTalk kick = Matrix ban try: await sender_intent.unban_user(self.mxid, unkicked_mxid) except MForbidden: if not sender: raise await self.main_intent.unban_user(self.mxid, unkicked_mxid) # endregion async def backfill(self, source: u.User, is_initial: bool, channel_info: ChannelInfo) -> None: limit = ( self.config["bridge.backfill.initial_limit"] if is_initial else self.config["bridge.backfill.missed_limit"] ) if limit == 0: return elif limit < 0: limit = None last_log_id = None if not is_initial and channel_info.lastChatLog: last_log_id = channel_info.lastChatLog.logId most_recent = await DBMessage.get_most_recent(self.ktid, self.kt_receiver) if most_recent and is_initial: self.log.debug("Not backfilling %s: already bridged messages found", self.ktid_log) # TODO Should this be removed? With it, can't sync an empty portal! #elif (not most_recent or not most_recent.timestamp) and not is_initial: # self.log.debug("Not backfilling %s: no most recent message found", self.ktid_log) elif last_log_id and most_recent and int(most_recent.ktid or 0) >= int(last_log_id): self.log.debug( "Not backfilling %s: last activity is equal to most recent bridged " "message (%s >= %s)", self.ktid_log, most_recent.ktid, last_log_id, ) else: with self.backfill_lock: await self._backfill( source, limit, most_recent.ktid if most_recent else None, ) async def _backfill( self, source: u.User, limit: int | None, after_log_id: Long | None, ) -> None: self.log.debug(f"Backfilling history through {source.mxid}") self.log.debug(f"Fetching {f'up to {limit}' if limit else 'all'} messages through {source.ktid}") chats = await source.client.get_chats( self.channel_props, after_log_id, limit, ) if not chats: self.log.debug("Didn't get any messages from server") return self.log.debug(f"Got {len(chats)} message{'s' if len(chats) > 1 else ''} from server") self._backfill_leave = set() async with NotificationDisabler(self.mxid, source): for chat in chats: puppet = await p.Puppet.get_by_ktid(chat.sender.userId) await self.handle_kakaotalk_chat(source, puppet, chat) for intent in self._backfill_leave: self.log.trace("Leaving room with %s post-backfill", intent.mxid) await intent.leave_room(self.mxid) self.log.info("Backfilled %d messages through %s", len(chats), source.mxid) await self._sync_read_receipts(source) # region Database getters async def postinit(self) -> None: self.by_ktid[self.ktid_full] = self if self.mxid: self.by_mxid[self.mxid] = self if not self.is_direct: self._main_intent = self.az.intent else: # TODO Save kt_sender in DB instead? Only do that if keeping a unique DM portal for each receiver user = await u.User.get_by_ktid(self.kt_receiver) assert user, f"Found no user for this portal's receiver of {self.kt_receiver}" if self.kt_type == KnownChannelType.MemoChat: self._kt_sender = user.ktid else: # NOTE This throws if the user isn't connected--good! # Nothing should init a portal for a disconnected user. participants = await user.client.get_participants(self.channel_props) self._kt_sender = participants[ 0 if participants[0].userId != user.ktid else 1 ].userId self._main_intent = (await p.Puppet.get_by_ktid(self._kt_sender)).default_mxid_intent @classmethod @async_getter_lock async def get_by_mxid(cls, mxid: RoomID) -> Portal | None: try: return cls.by_mxid[mxid] except KeyError: pass portal = cast(cls, await super().get_by_mxid(mxid)) if portal: await portal.postinit() return portal return None @classmethod @async_getter_lock async def get_by_ktid( cls, ktid: int, *, kt_receiver: int = 0, create: bool = True, kt_type: ChannelType | None = None, ) -> Portal | None: # TODO Direct chats are shared, so can remove kt_receiver if DM portals should be shared if kt_type: kt_receiver = kt_receiver if KnownChannelType.is_direct(kt_type) else 0 ktid_full = (ktid, kt_receiver) try: return cls.by_ktid[ktid_full] except KeyError: pass portal = cast(cls, await super().get_by_ktid(ktid, kt_receiver)) if portal: await portal.postinit() return portal if kt_type and create: portal = cls(ktid=ktid, kt_receiver=kt_receiver, kt_type=kt_type) await portal.insert() await portal.postinit() return portal return None @classmethod async def get_all_by_receiver(cls, kt_receiver: int) -> AsyncGenerator[Portal, None]: portals = await super().get_all_by_receiver(kt_receiver) portal: Portal for portal in portals: try: yield cls.by_ktid[(portal.ktid, portal.kt_receiver)] except KeyError: await portal.postinit() yield portal @classmethod async def all(cls) -> AsyncGenerator[Portal, None]: portals = await super().all() portal: Portal for portal in portals: try: yield cls.by_ktid[(portal.ktid, portal.kt_receiver)] except KeyError: await portal.postinit() yield portal # endregion