Kris
ebab14660a
新增 Mattermost 渠道扩展，支持在 Yuxi 平台中集成 Mattermost 团队协作平台。 包含以下功能模块： - client: Mattermost API 客户端封装 - config: 渠道配置管理 - gateway: SSE/WebSocket 网关接入 - websocket: WebSocket 实时连接 - outbound: 外发消息管理 - streaming: 流式消息处理 - pairing: 用户配对与绑定 - security: 安全校验 - dedup: 消息去重 - monitor: 渠道状态监控 - status: 会话状态管理 - session: 会话管理 - interactions: 交互处理 - slash_commands: 斜杠指令 - actions: 动作处理 - approval: 审批流程 - delivery: 消息送达确认 - directory: 目录管理 - threading: 线程管理 - gating: 门控管理 - reconnect: 重连机制 - reactions: 表情反应 - media: 媒体资源处理 - model_picker: 模型选择 - types: 类型定义
300 lines
9.6 KiB
Python
300 lines
9.6 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
import re
|
|
from typing import Any
|
|
|
|
from yuxi.channel.extensions.mattermost.client import (
|
|
MattermostClient,
|
|
create_direct_channel_with_retry,
|
|
)
|
|
from yuxi.channel.extensions.mattermost.errors import (
|
|
MattermostError,
|
|
)
|
|
from yuxi.channel.extensions.mattermost.format import (
|
|
safe_split_markdown,
|
|
truncate_markdown,
|
|
)
|
|
from yuxi.channel.extensions.mattermost.types import DeliveryTarget, SendContext
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class MattermostOutboundAdapter:
|
|
def __init__(self, client: MattermostClient, account_id: str = ""):
|
|
self.client = client
|
|
self.account_id = account_id
|
|
self._dm_cache: dict[str, str] = {}
|
|
|
|
async def send_text(
|
|
self,
|
|
channel_id: str,
|
|
content: str,
|
|
*,
|
|
root_id: str | None = None,
|
|
file_ids: list[str] | None = None,
|
|
text_chunk_limit: int = 4000,
|
|
priority: str | None = None,
|
|
request_ack: bool = False,
|
|
) -> dict | None:
|
|
chunks = safe_split_markdown(content, text_chunk_limit)
|
|
last_post: dict | None = None
|
|
for chunk in chunks:
|
|
payload: dict[str, Any] = {
|
|
"channel_id": channel_id,
|
|
"message": chunk,
|
|
}
|
|
if root_id:
|
|
payload["root_id"] = root_id
|
|
if file_ids and chunk == chunks[-1]:
|
|
payload["file_ids"] = file_ids
|
|
if priority:
|
|
payload["metadata"] = {
|
|
"priority": {
|
|
"priority": priority,
|
|
"requested_ack": request_ack,
|
|
}
|
|
}
|
|
try:
|
|
last_post = await self.client.create_post(payload)
|
|
except MattermostError as e:
|
|
logger.error("Failed to send text to channel %s: %s", channel_id, e)
|
|
raise
|
|
return last_post
|
|
|
|
async def edit_message(self, post_id: str, content: str) -> dict | None:
|
|
payload = {"message": truncate_markdown(content), "props": {}}
|
|
try:
|
|
return await self.client.update_post(post_id, payload)
|
|
except MattermostError as e:
|
|
logger.error("Failed to edit post %s: %s", post_id, e)
|
|
return None
|
|
|
|
async def delete_message(self, post_id: str) -> bool:
|
|
try:
|
|
await self.client.delete_post(post_id)
|
|
return True
|
|
except MattermostError:
|
|
return False
|
|
|
|
async def send_media(
|
|
self,
|
|
channel_id: str,
|
|
file_data: bytes,
|
|
filename: str,
|
|
mime_type: str = "application/octet-stream",
|
|
*,
|
|
root_id: str | None = None,
|
|
caption: str | None = None,
|
|
) -> dict | None:
|
|
try:
|
|
upload = await self.client.upload_file(channel_id, file_data, filename, mime_type)
|
|
file_infos = upload.get("file_infos", [])
|
|
fid = file_infos[0]["id"] if file_infos else None
|
|
if not fid:
|
|
return None
|
|
|
|
payload: dict[str, Any] = {
|
|
"channel_id": channel_id,
|
|
"message": caption or "",
|
|
"file_ids": [fid],
|
|
}
|
|
if root_id:
|
|
payload["root_id"] = root_id
|
|
return await self.client.create_post(payload)
|
|
except MattermostError as e:
|
|
logger.error("Failed to send media to channel %s: %s", channel_id, e)
|
|
return None
|
|
|
|
async def send_reaction(self, user_id: str, post_id: str, emoji_name: str) -> dict | None:
|
|
try:
|
|
return await self.client.add_reaction(user_id, post_id, emoji_name)
|
|
except MattermostError as e:
|
|
logger.error("Failed to add reaction: %s", e)
|
|
return None
|
|
|
|
async def remove_reaction(self, user_id: str, post_id: str, emoji_name: str) -> bool:
|
|
try:
|
|
await self.client.remove_reaction(user_id, post_id, emoji_name)
|
|
return True
|
|
except MattermostError:
|
|
return False
|
|
|
|
async def send_typing_indicator(self, channel_id: str) -> None:
|
|
try:
|
|
await self.client.send_typing(channel_id)
|
|
except MattermostError:
|
|
pass
|
|
|
|
async def create_dm_channel(self, user_id: str) -> str | None:
|
|
if user_id in self._dm_cache:
|
|
return self._dm_cache[user_id]
|
|
try:
|
|
result = await create_direct_channel_with_retry(
|
|
self.client, [user_id, "me"],
|
|
)
|
|
channel_id = result.get("id")
|
|
if channel_id:
|
|
self._dm_cache[user_id] = channel_id
|
|
return channel_id
|
|
except MattermostError as e:
|
|
logger.error("Failed to create DM channel: %s", e)
|
|
return None
|
|
|
|
async def send_ephemeral(
|
|
self,
|
|
user_id: str,
|
|
channel_id: str,
|
|
content: str,
|
|
*,
|
|
root_id: str = "",
|
|
) -> dict | None:
|
|
truncated = truncate_markdown(content)
|
|
try:
|
|
return await self.client.create_ephemeral_post(
|
|
user_id=user_id,
|
|
channel_id=channel_id,
|
|
message=truncated,
|
|
root_id=root_id,
|
|
)
|
|
except MattermostError as e:
|
|
logger.error("Failed to send ephemeral to user %s in channel %s: %s", user_id, channel_id, e)
|
|
return None
|
|
|
|
async def set_bot_status(self, status: str) -> dict | None:
|
|
try:
|
|
me = await self.client.fetch_me()
|
|
return await self.client.update_user_status(me["id"], status)
|
|
except MattermostError as e:
|
|
logger.error("Failed to set bot status: %s", e)
|
|
return None
|
|
|
|
async def pin_message(self, post_id: str) -> dict | None:
|
|
try:
|
|
return await self.client.pin_post(post_id)
|
|
except MattermostError as e:
|
|
logger.error("Failed to pin post %s: %s", post_id, e)
|
|
return None
|
|
|
|
async def unpin_message(self, post_id: str) -> dict | None:
|
|
try:
|
|
return await self.client.unpin_post(post_id)
|
|
except MattermostError as e:
|
|
logger.error("Failed to unpin post %s: %s", post_id, e)
|
|
return None
|
|
|
|
|
|
def parse_mattermost_target(raw: str) -> DeliveryTarget:
|
|
raw = raw.strip()
|
|
|
|
if re.fullmatch(r"[a-z0-9]{26}", raw, re.IGNORECASE):
|
|
return DeliveryTarget(kind="channel", id=raw)
|
|
|
|
if raw.startswith("channel:"):
|
|
inner = raw[len("channel:"):]
|
|
if inner.startswith("#"):
|
|
return DeliveryTarget(kind="channel-name", name=inner[1:])
|
|
return DeliveryTarget(kind="channel", id=inner)
|
|
|
|
if raw.startswith("user:"):
|
|
return DeliveryTarget(kind="user", id=raw[len("user:"):])
|
|
|
|
if raw.startswith("@"):
|
|
return DeliveryTarget(kind="user", name=raw[1:])
|
|
|
|
if raw.startswith("#"):
|
|
return DeliveryTarget(kind="channel-name", name=raw[1:])
|
|
|
|
return DeliveryTarget(kind="channel", id=raw)
|
|
|
|
|
|
async def resolve_send_context(
|
|
target_str: str,
|
|
client: MattermostClient,
|
|
account_id: str,
|
|
bot_user_id: str,
|
|
) -> SendContext:
|
|
target = parse_mattermost_target(target_str)
|
|
|
|
if target.kind == "channel" and target.id:
|
|
return SendContext(
|
|
channel_id=target.id,
|
|
token=client.bot_token,
|
|
base_url=client.base_url,
|
|
account_id=account_id,
|
|
)
|
|
|
|
if target.kind == "user" and target.id:
|
|
channel_id = await _resolve_dm_channel(client, target.id, bot_user_id)
|
|
return SendContext(
|
|
channel_id=channel_id or target.id,
|
|
token=client.bot_token,
|
|
base_url=client.base_url,
|
|
account_id=account_id,
|
|
)
|
|
|
|
if target.kind == "user" and target.name:
|
|
try:
|
|
user = await client.fetch_user_by_username(target.name)
|
|
uid = user["id"]
|
|
channel_id = await _resolve_dm_channel(client, uid, bot_user_id)
|
|
return SendContext(
|
|
channel_id=channel_id or uid,
|
|
token=client.bot_token,
|
|
base_url=client.base_url,
|
|
account_id=account_id,
|
|
)
|
|
except MattermostError:
|
|
return SendContext(
|
|
channel_id="",
|
|
token=client.bot_token,
|
|
base_url=client.base_url,
|
|
account_id=account_id,
|
|
)
|
|
|
|
if target.kind == "channel-name" and target.name:
|
|
try:
|
|
me = await client.fetch_me()
|
|
teams = await client.fetch_user_teams(me["id"])
|
|
for team_data in teams:
|
|
tid = team_data["id"]
|
|
try:
|
|
ch = await client.fetch_channel_by_name(tid, target.name)
|
|
return SendContext(
|
|
channel_id=ch["id"],
|
|
token=client.bot_token,
|
|
base_url=client.base_url,
|
|
account_id=account_id,
|
|
)
|
|
except MattermostError:
|
|
continue
|
|
except MattermostError:
|
|
pass
|
|
|
|
return SendContext(
|
|
channel_id="",
|
|
token=client.bot_token,
|
|
base_url=client.base_url,
|
|
account_id=account_id,
|
|
)
|
|
|
|
|
|
async def _resolve_dm_channel(
|
|
client: MattermostClient, user_id: str, bot_user_id: str,
|
|
) -> str | None:
|
|
try:
|
|
result = await create_direct_channel_with_retry(
|
|
client, [user_id, bot_user_id],
|
|
)
|
|
return result.get("id")
|
|
except MattermostError:
|
|
return None
|
|
|
|
|
|
def map_mattermost_channel_type_to_chat_type(mm_type: str) -> str:
|
|
if mm_type == "D":
|
|
return "direct"
|
|
if mm_type == "G":
|
|
return "group"
|
|
return "channel"
|