1971 lines
73 KiB
Rust
1971 lines
73 KiB
Rust
use std::collections::HashMap;
|
|
use std::path::Path;
|
|
use std::sync::Arc;
|
|
use std::time::{Duration, Instant};
|
|
|
|
use async_trait::async_trait;
|
|
use futures_util::{SinkExt, StreamExt};
|
|
use prost::{Message as ProstMessage, bytes::Bytes};
|
|
use regex::Regex;
|
|
use serde::Deserialize;
|
|
use tokio::sync::{broadcast, RwLock};
|
|
|
|
use crate::bus::{MessageBus, MediaItem, OutboundMessage};
|
|
use crate::channels::base::{Channel, ChannelError};
|
|
use crate::config::FeishuChannelConfig;
|
|
|
|
const FEISHU_API_BASE: &str = "https://open.feishu.cn/open-apis";
|
|
const FEISHU_WS_BASE: &str = "https://open.feishu.cn";
|
|
|
|
/// Heartbeat timeout for WS connection — must be larger than ping_interval (default 120 s).
|
|
/// If no binary frame (pong or event) is received within this window, reconnect.
|
|
const WS_HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(300);
|
|
/// Refresh tenant token this many seconds before the announced expiry.
|
|
const TOKEN_REFRESH_SKEW: Duration = Duration::from_secs(120);
|
|
/// Default tenant token TTL when `expire`/`expires_in` is absent.
|
|
const DEFAULT_TOKEN_TTL: Duration = Duration::from_secs(7200);
|
|
/// Dedup cache TTL (30 minutes).
|
|
const DEDUP_CACHE_TTL: Duration = Duration::from_secs(30 * 60);
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
// Protobuf types for Feishu WebSocket protocol (pbbp2.proto)
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
#[derive(Clone, PartialEq, prost::Message)]
|
|
struct PbHeader {
|
|
#[prost(string, tag = "1")]
|
|
pub key: String,
|
|
#[prost(string, tag = "2")]
|
|
pub value: String,
|
|
}
|
|
|
|
/// Feishu WS frame.
|
|
/// method=0 → CONTROL (ping/pong) method=1 → DATA (events)
|
|
#[derive(Clone, PartialEq, prost::Message)]
|
|
struct PbFrame {
|
|
#[prost(uint64, tag = "1")]
|
|
pub seq_id: u64,
|
|
#[prost(uint64, tag = "2")]
|
|
pub log_id: u64,
|
|
#[prost(int32, tag = "3")]
|
|
pub service: i32,
|
|
#[prost(int32, tag = "4")]
|
|
pub method: i32,
|
|
#[prost(message, repeated, tag = "5")]
|
|
pub headers: Vec<PbHeader>,
|
|
#[prost(bytes = "vec", optional, tag = "8")]
|
|
pub payload: Option<Vec<u8>>,
|
|
}
|
|
|
|
/// POST /callback/ws/endpoint response
|
|
#[derive(Deserialize)]
|
|
struct WsEndpointResp {
|
|
code: i32,
|
|
msg: Option<String>,
|
|
data: Option<WsEndpoint>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct WsEndpoint {
|
|
#[serde(rename = "URL")]
|
|
url: String,
|
|
#[serde(default)]
|
|
client_config: Option<WsClientConfig>,
|
|
}
|
|
|
|
#[derive(Deserialize, Default)]
|
|
struct WsClientConfig {
|
|
#[serde(rename = "PingInterval")]
|
|
ping_interval: Option<u64>,
|
|
}
|
|
|
|
/// Lark event envelope (method=1 / type=event payload)
|
|
#[derive(Deserialize)]
|
|
struct LarkEvent {
|
|
header: LarkEventHeader,
|
|
event: serde_json::Value,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct LarkEventHeader {
|
|
event_type: String,
|
|
#[allow(dead_code)]
|
|
event_id: String,
|
|
}
|
|
|
|
impl std::fmt::Debug for LarkEventHeader {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("LarkEventHeader")
|
|
.field("event_type", &self.event_type)
|
|
.field("event_id", &self.event_id)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct MsgReceivePayload {
|
|
sender: LarkSender,
|
|
message: LarkMessage,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct LarkSender {
|
|
sender_id: LarkSenderId,
|
|
#[serde(default)]
|
|
sender_type: String,
|
|
}
|
|
|
|
#[derive(Deserialize, Default)]
|
|
struct LarkSenderId {
|
|
open_id: Option<String>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[allow(dead_code)]
|
|
struct LarkMessage {
|
|
message_id: String,
|
|
chat_id: String,
|
|
chat_type: String,
|
|
message_type: String,
|
|
#[serde(default)]
|
|
content: String,
|
|
#[serde(default)]
|
|
mentions: Vec<serde_json::Value>,
|
|
#[serde(default)]
|
|
root_id: Option<String>,
|
|
#[serde(default)]
|
|
parent_id: Option<String>,
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
/// Cached tenant token with proactive refresh metadata.
|
|
#[derive(Clone)]
|
|
struct CachedTenantToken {
|
|
value: String,
|
|
refresh_after: Instant,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct FeishuChannel {
|
|
config: FeishuChannelConfig,
|
|
http_client: reqwest::Client,
|
|
running: Arc<RwLock<bool>>,
|
|
shutdown_tx: Arc<RwLock<Option<broadcast::Sender<()>>>>,
|
|
connected: Arc<RwLock<bool>>,
|
|
/// Cached tenant access token with proactive refresh.
|
|
tenant_token: Arc<RwLock<Option<CachedTenantToken>>>,
|
|
/// Dedup cache: WS message_ids seen in the last ~30 min.
|
|
seen_message_ids: Arc<RwLock<HashMap<String, Instant>>>,
|
|
}
|
|
|
|
/// Parsed message data from a Feishu frame
|
|
struct ParsedMessage {
|
|
message_id: String,
|
|
open_id: String,
|
|
chat_id: String,
|
|
content: String,
|
|
media: Option<MediaItem>,
|
|
/// ID of the message this message is replying to (if any).
|
|
/// Used to fetch quoted message content for display.
|
|
parent_id: Option<String>,
|
|
}
|
|
|
|
impl FeishuChannel {
|
|
pub fn new(
|
|
mut config: FeishuChannelConfig,
|
|
workspace_dir: &Path,
|
|
) -> Result<Self, ChannelError> {
|
|
// Override media_dir to use workspace_dir/media/feishu
|
|
let media_dir = workspace_dir.join("media").join("feishu");
|
|
config.media_dir = media_dir.to_string_lossy().to_string();
|
|
|
|
Ok(Self {
|
|
config,
|
|
http_client: reqwest::Client::new(),
|
|
running: Arc::new(RwLock::new(false)),
|
|
shutdown_tx: Arc::new(RwLock::new(None)),
|
|
connected: Arc::new(RwLock::new(false)),
|
|
tenant_token: Arc::new(RwLock::new(None)),
|
|
seen_message_ids: Arc::new(RwLock::new(HashMap::new())),
|
|
})
|
|
}
|
|
|
|
/// Get WebSocket endpoint URL from Feishu API
|
|
async fn get_ws_endpoint(&self, client: &reqwest::Client) -> Result<(String, WsClientConfig), ChannelError> {
|
|
let resp = client
|
|
.post(format!("{}/callback/ws/endpoint", FEISHU_WS_BASE))
|
|
.header("locale", "zh")
|
|
.json(&serde_json::json!({
|
|
"AppID": self.config.app_id,
|
|
"AppSecret": self.config.app_secret,
|
|
}))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("HTTP error: {}", e)))?;
|
|
|
|
let endpoint_resp: WsEndpointResp = resp
|
|
.json()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Failed to parse endpoint response: {}", e)))?;
|
|
|
|
if endpoint_resp.code != 0 {
|
|
return Err(ChannelError::ConnectionError(format!(
|
|
"WS endpoint failed: code={} msg={}",
|
|
endpoint_resp.code,
|
|
endpoint_resp.msg.as_deref().unwrap_or("unknown")
|
|
)));
|
|
}
|
|
|
|
let ep = endpoint_resp.data
|
|
.ok_or_else(|| ChannelError::ConnectionError("Empty endpoint data".to_string()))?;
|
|
|
|
let client_config = ep.client_config.unwrap_or_default();
|
|
Ok((ep.url, client_config))
|
|
}
|
|
|
|
/// Get tenant access token (cached with proactive refresh).
|
|
async fn get_tenant_access_token(&self) -> Result<String, ChannelError> {
|
|
// 1. Check cache
|
|
{
|
|
let cached = self.tenant_token.read().await;
|
|
if let Some(ref token) = *cached
|
|
&& Instant::now() < token.refresh_after {
|
|
return Ok(token.value.clone());
|
|
}
|
|
}
|
|
|
|
// 2. Fetch new token
|
|
let (token, ttl) = self.fetch_new_token().await?;
|
|
|
|
// 3. Cache with proactive refresh time (提前 120 秒)
|
|
let refresh_after = Instant::now() + ttl.saturating_sub(TOKEN_REFRESH_SKEW);
|
|
{
|
|
let mut cached = self.tenant_token.write().await;
|
|
*cached = Some(CachedTenantToken {
|
|
value: token.clone(),
|
|
refresh_after,
|
|
});
|
|
}
|
|
|
|
Ok(token)
|
|
}
|
|
|
|
/// Fetch a new tenant access token from Feishu.
|
|
async fn fetch_new_token(&self) -> Result<(String, Duration), ChannelError> {
|
|
let resp = self.http_client
|
|
.post(format!("{}/auth/v3/tenant_access_token/internal", FEISHU_API_BASE))
|
|
.header("Content-Type", "application/json")
|
|
.json(&serde_json::json!({
|
|
"app_id": self.config.app_id,
|
|
"app_secret": self.config.app_secret,
|
|
}))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("HTTP error: {}", e)))?;
|
|
|
|
#[derive(Deserialize)]
|
|
struct TokenResponse {
|
|
code: i32,
|
|
tenant_access_token: Option<String>,
|
|
expire: Option<i64>,
|
|
}
|
|
|
|
let token_resp: TokenResponse = resp
|
|
.json()
|
|
.await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to parse token response: {}", e)))?;
|
|
|
|
if token_resp.code != 0 {
|
|
return Err(ChannelError::Other("Auth failed".to_string()));
|
|
}
|
|
|
|
let token = token_resp.tenant_access_token
|
|
.ok_or_else(|| ChannelError::Other("No token in response".to_string()))?;
|
|
|
|
let ttl = token_resp.expire
|
|
.and_then(|v| u64::try_from(v).ok())
|
|
.map(Duration::from_secs)
|
|
.unwrap_or(DEFAULT_TOKEN_TTL);
|
|
|
|
Ok((token, ttl))
|
|
}
|
|
|
|
/// Check if message_id has been seen (dedup), and mark it as seen if not.
|
|
/// Returns true if the message was already processed.
|
|
/// Note: GC of stale entries is handled in the heartbeat timeout_check loop.
|
|
async fn is_message_seen(&self, message_id: &str) -> bool {
|
|
let mut seen = self.seen_message_ids.write().await;
|
|
let now = Instant::now();
|
|
|
|
if seen.contains_key(message_id) {
|
|
true
|
|
} else {
|
|
seen.insert(message_id.to_string(), now);
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Download media and save locally, return (description, media_item)
|
|
async fn download_media(
|
|
&self,
|
|
msg_type: &str,
|
|
content_json: &serde_json::Value,
|
|
message_id: &str,
|
|
) -> Result<(String, Option<MediaItem>), ChannelError> {
|
|
let media_dir = Path::new(&self.config.media_dir);
|
|
tokio::fs::create_dir_all(media_dir).await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to create media dir: {}", e)))?;
|
|
|
|
match msg_type {
|
|
"image" => self.download_image(content_json, message_id, media_dir).await,
|
|
"audio" | "file" | "media" => self.download_file(content_json, message_id, media_dir, msg_type).await,
|
|
_ => Ok((format!("[unsupported media type: {}]", msg_type), None)),
|
|
}
|
|
}
|
|
|
|
/// Download image from Feishu
|
|
async fn download_image(
|
|
&self,
|
|
content_json: &serde_json::Value,
|
|
message_id: &str,
|
|
media_dir: &Path,
|
|
) -> Result<(String, Option<MediaItem>), ChannelError> {
|
|
let image_key = content_json.get("image_key")
|
|
.and_then(|v| v.as_str())
|
|
.ok_or_else(|| ChannelError::Other("No image_key in message".to_string()))?;
|
|
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
// Use message resource API for downloading message images
|
|
let url = format!("{}/im/v1/messages/{}/resources/{}?type=image", FEISHU_API_BASE, message_id, image_key);
|
|
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(url = %url, image_key = %image_key, message_id = %message_id, "Downloading image from Feishu via message resource API");
|
|
|
|
let resp = self.http_client
|
|
.get(&url)
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Download image HTTP error: {}", e)))?;
|
|
|
|
let status = resp.status();
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(status = %status, "Image download response status");
|
|
|
|
if !status.is_success() {
|
|
let error_text = resp.text().await.unwrap_or_default();
|
|
return Err(ChannelError::Other(format!("Image download failed {}: {}", status, error_text)));
|
|
}
|
|
|
|
let content_type = resp
|
|
.headers()
|
|
.get("content-type")
|
|
.and_then(|v| v.to_str().ok())
|
|
.unwrap_or("image/jpeg")
|
|
.to_string();
|
|
|
|
let ext = resolve_image_ext(&content_type);
|
|
|
|
let data = resp.bytes().await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read image data: {}", e)))?
|
|
.to_vec();
|
|
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(data_len = %data.len(), content_type = %content_type, "Downloaded image data");
|
|
|
|
let filename = format!("{}_{}.{}", message_id, &image_key[..8.min(image_key.len())], ext);
|
|
let file_path = resolve_unique_path(media_dir, &filename).await;
|
|
|
|
tokio::fs::write(&file_path, &data).await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to write image: {}", e)))?;
|
|
|
|
let media_item = MediaItem::new(
|
|
file_path.to_string_lossy().to_string(),
|
|
"image",
|
|
);
|
|
|
|
tracing::info!(message_id = %message_id, filename = %filename, "Downloaded image");
|
|
|
|
Ok((String::new(), Some(media_item)))
|
|
}
|
|
|
|
/// Download file/audio from Feishu
|
|
async fn download_file(
|
|
&self,
|
|
content_json: &serde_json::Value,
|
|
message_id: &str,
|
|
media_dir: &Path,
|
|
file_type: &str,
|
|
) -> Result<(String, Option<MediaItem>), ChannelError> {
|
|
let file_key = content_json.get("file_key")
|
|
.and_then(|v| v.as_str())
|
|
.ok_or_else(|| ChannelError::Other("No file_key in message".to_string()))?;
|
|
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
// Use message resource API for downloading message files
|
|
let url = format!("{}/im/v1/messages/{}/resources/{}?type=file", FEISHU_API_BASE, message_id, file_key);
|
|
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(url = %url, file_key = %file_key, message_id = %message_id, "Downloading file from Feishu via message resource API");
|
|
|
|
let resp = self.http_client
|
|
.get(&url)
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Download file HTTP error: {}", e)))?;
|
|
|
|
let status = resp.status();
|
|
if !status.is_success() {
|
|
let error_text = resp.text().await.unwrap_or_default();
|
|
return Err(ChannelError::Other(format!("File download failed {}: {}", status, error_text)));
|
|
}
|
|
|
|
let data = resp.bytes().await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read file data: {}", e)))?
|
|
.to_vec();
|
|
|
|
let filename = content_json
|
|
.get("file_name")
|
|
.and_then(|v| v.as_str())
|
|
.map(|s| s.to_string())
|
|
.unwrap_or_else(|| {
|
|
let ext = resolve_file_ext(content_json);
|
|
if ext.is_empty() {
|
|
format!("{}_{}", message_id, &file_key[..8.min(file_key.len())])
|
|
} else {
|
|
format!("{}_{}.{}", message_id, &file_key[..8.min(file_key.len())], ext)
|
|
}
|
|
});
|
|
let file_path = resolve_unique_path(media_dir, &filename).await;
|
|
|
|
tokio::fs::write(&file_path, &data).await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to write file: {}", e)))?;
|
|
|
|
let media_item = MediaItem::new(
|
|
file_path.to_string_lossy().to_string(),
|
|
file_type,
|
|
);
|
|
|
|
tracing::info!(message_id = %message_id, filename = %filename, file_type = %file_type, "Downloaded file");
|
|
|
|
Ok((String::new(), Some(media_item)))
|
|
}
|
|
|
|
/// Upload image to Feishu and return the image_key
|
|
async fn upload_image(&self, file_path: &str) -> Result<String, ChannelError> {
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
let mime = mime_guess::from_path(file_path)
|
|
.first_or_octet_stream()
|
|
.to_string();
|
|
|
|
let file_name = std::path::Path::new(file_path)
|
|
.file_name()
|
|
.and_then(|n| n.to_str())
|
|
.unwrap_or("image.jpg");
|
|
|
|
let file_data = tokio::fs::read(file_path).await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read file: {}", e)))?;
|
|
|
|
let part = reqwest::multipart::Part::bytes(file_data)
|
|
.file_name(file_name.to_string())
|
|
.mime_str(&mime)
|
|
.map_err(|e| ChannelError::Other(format!("Invalid mime type: {}", e)))?;
|
|
|
|
let form = reqwest::multipart::Form::new()
|
|
.text("image_type", "message".to_string())
|
|
.part("image", part);
|
|
|
|
let resp = self.http_client
|
|
.post(format!("{}/im/v1/images", FEISHU_API_BASE))
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.multipart(form)
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Upload image HTTP error: {}", e)))?;
|
|
|
|
let status = resp.status();
|
|
let body_text = resp.text().await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read upload response: {}", e)))?;
|
|
tracing::debug!(status = %status, body = %body_text, "Feishu upload image");
|
|
|
|
#[derive(Deserialize)]
|
|
struct UploadResp {
|
|
code: i32,
|
|
msg: Option<String>,
|
|
data: Option<UploadData>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct UploadData {
|
|
image_key: String,
|
|
}
|
|
|
|
let result: UploadResp = serde_json::from_str(&body_text)
|
|
.map_err(|e| ChannelError::Other(format!("Parse upload response error: {} | body: {}", e, &body_text)))?;
|
|
|
|
if result.code != 0 {
|
|
return Err(ChannelError::Other(format!(
|
|
"Upload image failed: code={} msg={}",
|
|
result.code,
|
|
result.msg.as_deref().unwrap_or("unknown")
|
|
)));
|
|
}
|
|
|
|
result.data
|
|
.map(|d| d.image_key)
|
|
.ok_or_else(|| ChannelError::Other("No image_key in response".to_string()))
|
|
}
|
|
|
|
/// Upload file to Feishu and return the file_key
|
|
async fn upload_file(&self, file_path: &str) -> Result<String, ChannelError> {
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
let file_name = std::path::Path::new(file_path)
|
|
.file_name()
|
|
.and_then(|n| n.to_str())
|
|
.unwrap_or("file.bin");
|
|
|
|
let extension = std::path::Path::new(file_path)
|
|
.extension()
|
|
.and_then(|e| e.to_str())
|
|
.unwrap_or("")
|
|
.to_lowercase();
|
|
|
|
let file_type = match extension.as_str() {
|
|
"opus" => "opus",
|
|
"mp4" | "mov" | "avi" | "mkv" => "mp4",
|
|
"pdf" => "pdf",
|
|
"doc" | "docx" => "doc",
|
|
"xls" | "xlsx" => "xls",
|
|
"ppt" | "pptx" => "ppt",
|
|
_ => "stream",
|
|
};
|
|
|
|
let file_data = tokio::fs::read(file_path).await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read file: {}", e)))?;
|
|
|
|
let part = reqwest::multipart::Part::bytes(file_data)
|
|
.file_name(file_name.to_string())
|
|
.mime_str("application/octet-stream")
|
|
.map_err(|e| ChannelError::Other(format!("Invalid mime type: {}", e)))?;
|
|
|
|
let form = reqwest::multipart::Form::new()
|
|
.text("file_type", file_type.to_string())
|
|
.text("file_name", file_name.to_string())
|
|
.part("file", part);
|
|
|
|
let resp = self.http_client
|
|
.post(format!("{}/im/v1/files", FEISHU_API_BASE))
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.multipart(form)
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Upload file HTTP error: {}", e)))?;
|
|
|
|
let status = resp.status();
|
|
let body_text = resp.text().await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read upload response: {}", e)))?;
|
|
tracing::debug!(status = %status, body = %body_text, "Feishu upload file");
|
|
|
|
#[derive(Deserialize)]
|
|
struct UploadResp {
|
|
code: i32,
|
|
msg: Option<String>,
|
|
data: Option<UploadData>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct UploadData {
|
|
file_key: String,
|
|
}
|
|
|
|
let result: UploadResp = serde_json::from_str(&body_text)
|
|
.map_err(|e| ChannelError::Other(format!("Parse upload response error: {} | body: {}", e, &body_text)))?;
|
|
|
|
if result.code != 0 {
|
|
return Err(ChannelError::Other(format!(
|
|
"Upload file failed: code={} msg={}",
|
|
result.code,
|
|
result.msg.as_deref().unwrap_or("unknown")
|
|
)));
|
|
}
|
|
|
|
result.data
|
|
.map(|d| d.file_key)
|
|
.ok_or_else(|| ChannelError::Other("No file_key in response".to_string()))
|
|
}
|
|
|
|
/// Add a reaction emoji to a message and store the reaction_id for later removal.
|
|
/// Returns the reaction_id if successful, None otherwise.
|
|
async fn add_reaction(&self, message_id: &str) -> Result<Option<String>, ChannelError> {
|
|
let emoji = self.config.reaction_emoji.as_str();
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
let resp = self.http_client
|
|
.post(format!("{}/im/v1/messages/{}/reactions", FEISHU_API_BASE, message_id))
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.json(&serde_json::json!({
|
|
"reaction_type": { "emoji_type": emoji }
|
|
}))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Add reaction HTTP error: {}", e)))?;
|
|
|
|
#[derive(Deserialize)]
|
|
struct ReactionResp {
|
|
code: i32,
|
|
msg: Option<String>,
|
|
data: Option<ReactionData>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct ReactionData {
|
|
reaction_id: Option<String>,
|
|
}
|
|
|
|
let result: ReactionResp = resp.json().await
|
|
.map_err(|e| ChannelError::Other(format!("Parse reaction response error: {}", e)))?;
|
|
|
|
if result.code != 0 {
|
|
tracing::warn!(
|
|
"Failed to add reaction to message {}: code={} msg={}",
|
|
message_id,
|
|
result.code,
|
|
result.msg.as_deref().unwrap_or("unknown")
|
|
);
|
|
return Ok(None);
|
|
}
|
|
|
|
let reaction_id = result.data.and_then(|d| d.reaction_id);
|
|
Ok(reaction_id)
|
|
}
|
|
|
|
/// Remove reaction using feishu metadata propagated through OutboundMessage.
|
|
/// Reads feishu.message_id and feishu.reaction_id from metadata.
|
|
async fn remove_reaction_from_metadata(&self, metadata: &std::collections::HashMap<String, String>) {
|
|
let (message_id, reaction_id) = match (
|
|
metadata.get("feishu.message_id"),
|
|
metadata.get("feishu.reaction_id"),
|
|
) {
|
|
(Some(msg_id), Some(rid)) => (msg_id.clone(), rid.clone()),
|
|
_ => return,
|
|
};
|
|
if let Err(e) = self.remove_reaction(&message_id, &reaction_id).await {
|
|
tracing::debug!(error = %e, message_id = %message_id, "Failed to remove reaction");
|
|
}
|
|
}
|
|
|
|
/// Remove a reaction emoji from a message.
|
|
async fn remove_reaction(&self, message_id: &str, reaction_id: &str) -> Result<(), ChannelError> {
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
let resp = self.http_client
|
|
.delete(format!("{}/im/v1/messages/{}/reactions/{}", FEISHU_API_BASE, message_id, reaction_id))
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Remove reaction HTTP error: {}", e)))?;
|
|
|
|
#[derive(Deserialize)]
|
|
struct ReactionResp {
|
|
code: i32,
|
|
msg: Option<String>,
|
|
}
|
|
|
|
let result: ReactionResp = resp.json().await
|
|
.map_err(|e| ChannelError::Other(format!("Parse remove reaction response error: {}", e)))?;
|
|
|
|
if result.code != 0 {
|
|
tracing::debug!(
|
|
"Failed to remove reaction {} from message {}: code={} msg={}",
|
|
reaction_id,
|
|
message_id,
|
|
result.code,
|
|
result.msg.as_deref().unwrap_or("unknown")
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
const REPLY_CONTEXT_MAX_LEN: usize = 500;
|
|
|
|
/// Fetch the text content of a Feishu message by ID.
|
|
/// Returns a "[Reply to: ...]" context string, or None on failure.
|
|
async fn get_message_content(&self, message_id: &str) -> Option<String> {
|
|
let token = match self.get_tenant_access_token().await {
|
|
Ok(t) => t,
|
|
Err(e) => {
|
|
tracing::debug!(error = %e, message_id = %message_id, "Feishu: failed to get token for fetching parent message");
|
|
return None;
|
|
}
|
|
};
|
|
|
|
let resp = self.http_client
|
|
.get(format!("{}/im/v1/messages/{}", FEISHU_API_BASE, message_id))
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.send()
|
|
.await
|
|
.ok()?;
|
|
|
|
#[derive(Deserialize)]
|
|
struct MessageResp {
|
|
code: i32,
|
|
msg: Option<String>,
|
|
data: Option<MessageData>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct MessageData {
|
|
items: Option<Vec<MessageItem>>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct MessageItem {
|
|
msg_type: String,
|
|
body: Option<MessageBody>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
struct MessageBody {
|
|
content: Option<String>,
|
|
}
|
|
|
|
let result: MessageResp = match resp.json().await {
|
|
Ok(r) => r,
|
|
Err(e) => {
|
|
tracing::debug!(error = %e, message_id = %message_id, "Feishu: failed to parse parent message response");
|
|
return None;
|
|
}
|
|
};
|
|
|
|
if result.code != 0 {
|
|
tracing::debug!(
|
|
message_id = %message_id,
|
|
code = %result.code,
|
|
msg = ?result.msg,
|
|
"Feishu: failed to fetch parent message"
|
|
);
|
|
return None;
|
|
}
|
|
|
|
let items = result.data?.items?;
|
|
let msg_obj = items.first()?;
|
|
|
|
let raw_content = msg_obj.body.as_ref()?.content.as_ref()?;
|
|
let msg_type = msg_obj.msg_type.as_str();
|
|
|
|
let text = match msg_type {
|
|
"text" => {
|
|
serde_json::from_str::<serde_json::Value>(raw_content)
|
|
.ok()?
|
|
.get("text")?
|
|
.as_str()?
|
|
.to_string()
|
|
}
|
|
"post" => {
|
|
parse_post_content(raw_content)
|
|
}
|
|
_ => String::new(),
|
|
};
|
|
|
|
if text.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
let text = if text.len() > Self::REPLY_CONTEXT_MAX_LEN {
|
|
format!("{}...", &text[..Self::REPLY_CONTEXT_MAX_LEN])
|
|
} else {
|
|
text
|
|
};
|
|
|
|
Some(format!("[Reply to: {}]", text))
|
|
}
|
|
|
|
/// Send a message to Feishu chat with specified message type and content.
|
|
/// Content is passed as-is (already a JSON string for file/media, or plain text for fallback).
|
|
async fn send_message_to_feishu(&self, receive_id: &str, receive_id_type: &str, msg_type: &str, content: &str) -> Result<(), ChannelError> {
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
let resp = self.http_client
|
|
.post(format!("{}/im/v1/messages?receive_id_type={}", FEISHU_API_BASE, receive_id_type))
|
|
.header("Content-Type", "application/json")
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.json(&serde_json::json!({
|
|
"receive_id": receive_id,
|
|
"msg_type": msg_type,
|
|
"content": content
|
|
}))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Send message HTTP error: {}", e)))?;
|
|
|
|
#[derive(Deserialize)]
|
|
struct SendResp {
|
|
code: i32,
|
|
msg: String,
|
|
}
|
|
|
|
let send_resp: SendResp = resp
|
|
.json()
|
|
.await
|
|
.map_err(|e| ChannelError::Other(format!("Parse send response error: {}", e)))?;
|
|
|
|
if send_resp.code != 0 {
|
|
return Err(ChannelError::Other(format!("Send message failed: code={} msg={}", send_resp.code, send_resp.msg)));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Extract service_id from WebSocket URL query params
|
|
fn extract_service_id(url: &str) -> i32 {
|
|
url.split('?')
|
|
.nth(1)
|
|
.and_then(|qs| {
|
|
qs.split('&')
|
|
.find(|kv| kv.starts_with("service_id="))
|
|
.and_then(|kv| kv.split('=').nth(1))
|
|
.and_then(|v| v.parse::<i32>().ok())
|
|
})
|
|
.unwrap_or(0)
|
|
}
|
|
|
|
/// Handle incoming binary PbFrame - returns Some(ParsedMessage) if we need to ack
|
|
async fn handle_frame(&self, frame: &PbFrame) -> Result<Option<ParsedMessage>, ChannelError> {
|
|
// method 0 = CONTROL (ping/pong)
|
|
if frame.method == 0 {
|
|
return Ok(None);
|
|
}
|
|
|
|
// method 1 = DATA (events)
|
|
if frame.method != 1 {
|
|
return Ok(None);
|
|
}
|
|
|
|
let payload = frame.payload.as_deref()
|
|
.ok_or_else(|| ChannelError::Other("No payload in frame".to_string()))?;
|
|
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(payload_len = %payload.len(), "Received frame payload");
|
|
|
|
let event: LarkEvent = serde_json::from_slice(payload)
|
|
.map_err(|e| ChannelError::Other(format!("Parse event error: {}", e)))?;
|
|
|
|
let event_type = event.header.event_type.as_str();
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(event_type = %event_type, "Received event type");
|
|
if event_type != "im.message.receive_v1" {
|
|
return Ok(None);
|
|
}
|
|
|
|
let payload_data: MsgReceivePayload = serde_json::from_value(event.event.clone())
|
|
.map_err(|e| ChannelError::Other(format!("Parse payload error: {}", e)))?;
|
|
|
|
// Skip bot messages
|
|
if payload_data.sender.sender_type == "bot" {
|
|
return Ok(None);
|
|
}
|
|
|
|
let message_id = payload_data.message.message_id.clone();
|
|
|
|
// Deduplication check
|
|
if self.is_message_seen(&message_id).await {
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(message_id = %message_id, "Duplicate message, skipping");
|
|
return Ok(None);
|
|
}
|
|
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(message_id = %message_id, "Received Feishu message");
|
|
|
|
let open_id = payload_data.sender.sender_id.open_id
|
|
.ok_or_else(|| ChannelError::Other("No open_id".to_string()))?;
|
|
|
|
let msg = payload_data.message;
|
|
let chat_id = msg.chat_id.clone();
|
|
let msg_type = msg.message_type.as_str();
|
|
let raw_content = msg.content.clone();
|
|
let parent_id = msg.parent_id.clone();
|
|
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(msg_type = %msg_type, chat_id = %chat_id, open_id = %open_id, "Parsing message content");
|
|
|
|
let (mut content, media) = self.parse_and_download_message(msg_type, &raw_content, &message_id).await?;
|
|
|
|
// Fetch and prepend quoted message content if this is a reply
|
|
if let Some(ref pid) = parent_id
|
|
&& let Some(reply_ctx) = self.get_message_content(pid).await {
|
|
content = format!("{}\n{}", reply_ctx, content);
|
|
}
|
|
|
|
#[cfg(debug_assertions)]
|
|
if let Some(ref m) = media {
|
|
tracing::debug!(media_type = %m.media_type, media_path = %m.path, "Media downloaded successfully");
|
|
}
|
|
|
|
Ok(Some(ParsedMessage {
|
|
message_id,
|
|
open_id,
|
|
chat_id,
|
|
content,
|
|
media,
|
|
parent_id,
|
|
}))
|
|
}
|
|
|
|
/// Parse message content and download media if needed
|
|
async fn parse_and_download_message(
|
|
&self,
|
|
msg_type: &str,
|
|
content: &str,
|
|
message_id: &str,
|
|
) -> Result<(String, Option<MediaItem>), ChannelError> {
|
|
let (text, media) = match msg_type {
|
|
"text" => {
|
|
let text = if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(content) {
|
|
parsed.get("text").and_then(|v| v.as_str()).unwrap_or(content).to_string()
|
|
} else {
|
|
content.to_string()
|
|
};
|
|
(text, None)
|
|
}
|
|
"post" => {
|
|
(parse_post_content(content), None)
|
|
}
|
|
"image" | "audio" | "file" | "media" => {
|
|
if let Ok(content_json) = serde_json::from_str::<serde_json::Value>(content) {
|
|
match self.download_media(msg_type, &content_json, message_id).await {
|
|
Ok((text, media)) => (text, media),
|
|
Err(_) => (format!("[{}: content unavailable]", msg_type), None),
|
|
}
|
|
} else {
|
|
(format!("[{}: content unavailable]", msg_type), None)
|
|
}
|
|
}
|
|
"share_chat" => {
|
|
// Shared chat/cannel messages
|
|
if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(content) {
|
|
let chat_id = parsed.get("chat_id").and_then(|v| v.as_str()).unwrap_or("unknown");
|
|
(format!("[shared chat: {}]", chat_id), None)
|
|
} else {
|
|
("[shared chat]".to_string(), None)
|
|
}
|
|
}
|
|
"share_user" => {
|
|
// Shared user messages
|
|
if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(content) {
|
|
let user_id = parsed.get("user_id").and_then(|v| v.as_str()).unwrap_or("unknown");
|
|
(format!("[shared user: {}]", user_id), None)
|
|
} else {
|
|
("[shared user]".to_string(), None)
|
|
}
|
|
}
|
|
"interactive" => {
|
|
// Interactive card messages - extract text content
|
|
match extract_interactive_content(content) {
|
|
Ok((text, media)) => (text, media),
|
|
Err(e) => {
|
|
tracing::warn!(error = %e, "Failed to extract interactive content");
|
|
(content.to_string(), None)
|
|
}
|
|
}
|
|
}
|
|
"list" => {
|
|
// List/bullet messages
|
|
match parse_list_content(content) {
|
|
Ok((text, media)) => (text, media),
|
|
Err(_) => (content.to_string(), None),
|
|
}
|
|
}
|
|
"merge_forward" => {
|
|
("[merged forward messages]".to_string(), None)
|
|
}
|
|
"share_calendar_event" => {
|
|
if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(content) {
|
|
let event_key = parsed.get("event_key").and_then(|v| v.as_str()).unwrap_or("unknown");
|
|
(format!("[shared calendar event: {}]", event_key), None)
|
|
} else {
|
|
("[shared calendar event]".to_string(), None)
|
|
}
|
|
}
|
|
"system" => {
|
|
("[system message]".to_string(), None)
|
|
}
|
|
_ => (content.to_string(), None),
|
|
};
|
|
|
|
// Strip @_user_N placeholders from group chat @mentions
|
|
let clean_text = strip_at_placeholders(&text);
|
|
Ok((clean_text, media))
|
|
}
|
|
|
|
/// Send acknowledgment for a message
|
|
async fn send_ack(frame: &PbFrame, write: &mut futures_util::stream::SplitSink<tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>>, tokio_tungstenite::tungstenite::Message>) -> Result<(), ChannelError> {
|
|
let mut ack = frame.clone();
|
|
ack.payload = Some(br#"{"code":200,"headers":{},"data":[]}"#.to_vec());
|
|
ack.headers.push(PbHeader {
|
|
key: "biz_rt".into(),
|
|
value: "0".into(),
|
|
});
|
|
write.send(tokio_tungstenite::tungstenite::Message::Binary(ack.encode_to_vec().into()))
|
|
.await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to send ack: {}", e)))?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_ws_loop(&self, bus: Arc<MessageBus>, mut shutdown_rx: broadcast::Receiver<()>) -> Result<(), ChannelError> {
|
|
let (wss_url, client_config) = self.get_ws_endpoint(&self.http_client).await?;
|
|
|
|
let service_id = Self::extract_service_id(&wss_url);
|
|
tracing::info!(url = %wss_url, "Connecting to Feishu WebSocket");
|
|
|
|
let (ws_stream, _) = tokio_tungstenite::connect_async(&wss_url)
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("WebSocket connection failed: {}", e)))?;
|
|
|
|
*self.connected.write().await = true;
|
|
tracing::info!("Feishu WebSocket connected");
|
|
|
|
let (mut write, mut read) = ws_stream.split();
|
|
|
|
// Send initial ping
|
|
let ping_frame = PbFrame {
|
|
seq_id: 1,
|
|
log_id: 0,
|
|
service: service_id,
|
|
method: 0,
|
|
headers: vec![PbHeader {
|
|
key: "type".into(),
|
|
value: "ping".into(),
|
|
}],
|
|
payload: None,
|
|
};
|
|
write.send(tokio_tungstenite::tungstenite::Message::Binary(ping_frame.encode_to_vec().into()))
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Failed to send initial ping: {}", e)))?;
|
|
|
|
let ping_interval = client_config.ping_interval.unwrap_or(120).max(10);
|
|
let mut ping_interval_tok = tokio::time::interval(tokio::time::Duration::from_secs(ping_interval));
|
|
let mut timeout_check = tokio::time::interval(tokio::time::Duration::from_secs(10));
|
|
let mut seq: u64 = 1;
|
|
let mut last_recv = Instant::now();
|
|
|
|
// Consume the immediate tick
|
|
ping_interval_tok.tick().await;
|
|
timeout_check.tick().await;
|
|
|
|
loop {
|
|
tokio::select! {
|
|
msg = read.next() => {
|
|
match msg {
|
|
Some(Ok(tokio_tungstenite::tungstenite::Message::Binary(data))) => {
|
|
last_recv = Instant::now();
|
|
let bytes: Bytes = data;
|
|
if let Ok(frame) = PbFrame::decode(bytes.as_ref()) {
|
|
match self.handle_frame(&frame).await {
|
|
Ok(Some(parsed)) => {
|
|
// Send ACK immediately (Feishu requires within 3 s)
|
|
if let Err(e) = Self::send_ack(&frame, &mut write).await {
|
|
tracing::error!(error = %e, "Failed to send ACK to Feishu");
|
|
}
|
|
|
|
// Add reaction emoji (await so we get the reaction_id for later removal)
|
|
let message_id = parsed.message_id.clone();
|
|
let reaction_id = match self.add_reaction(&message_id).await {
|
|
Ok(Some(rid)) => Some(rid),
|
|
Ok(None) => None,
|
|
Err(e) => {
|
|
tracing::debug!(error = %e, message_id = %message_id, "Failed to add reaction");
|
|
None
|
|
}
|
|
};
|
|
|
|
// forwarded_metadata is copied to OutboundMessage.metadata by the gateway.
|
|
let mut forwarded_metadata = std::collections::HashMap::new();
|
|
forwarded_metadata.insert("feishu.message_id".to_string(), message_id.clone());
|
|
if let Some(ref rid) = reaction_id {
|
|
forwarded_metadata.insert("feishu.reaction_id".to_string(), rid.clone());
|
|
}
|
|
if let Some(ref pid) = parsed.parent_id {
|
|
forwarded_metadata.insert("feishu.parent_id".to_string(), pid.clone());
|
|
}
|
|
|
|
// Publish to bus asynchronously
|
|
let channel = self.clone();
|
|
let bus = bus.clone();
|
|
tokio::spawn(async move {
|
|
let media_count = if parsed.media.is_some() { 1 } else { 0 };
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(open_id = %parsed.open_id, chat_id = %parsed.chat_id, content_len = %parsed.content.len(), media_count = %media_count, "Publishing message to bus");
|
|
let msg = crate::bus::InboundMessage {
|
|
channel: "feishu".to_string(),
|
|
sender_id: parsed.open_id.clone(),
|
|
chat_id: parsed.chat_id.clone(),
|
|
content: parsed.content.clone(),
|
|
timestamp: crate::bus::message::current_timestamp(),
|
|
media: parsed.media.map(|m| vec![m]).unwrap_or_default(),
|
|
metadata: std::collections::HashMap::new(),
|
|
forwarded_metadata,
|
|
};
|
|
if let Err(e) = channel.handle_and_publish(&bus, &msg).await {
|
|
tracing::error!(error = %e, open_id = %parsed.open_id, chat_id = %parsed.chat_id, "Failed to publish Feishu message to bus");
|
|
} else {
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!(open_id = %parsed.open_id, chat_id = %parsed.chat_id, "Message published to bus successfully");
|
|
}
|
|
});
|
|
}
|
|
Ok(None) => {}
|
|
Err(e) => {
|
|
tracing::warn!(error = %e, "Failed to parse Feishu frame");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Some(Ok(tokio_tungstenite::tungstenite::Message::Ping(data))) => {
|
|
last_recv = Instant::now();
|
|
let pong = PbFrame {
|
|
seq_id: seq.wrapping_add(1),
|
|
log_id: 0,
|
|
service: service_id,
|
|
method: 0,
|
|
headers: vec![PbHeader {
|
|
key: "type".into(),
|
|
value: "pong".into(),
|
|
}],
|
|
payload: Some(data.to_vec()),
|
|
};
|
|
let _ = write.send(tokio_tungstenite::tungstenite::Message::Binary(pong.encode_to_vec().into())).await;
|
|
}
|
|
Some(Ok(tokio_tungstenite::tungstenite::Message::Pong(_))) => {
|
|
last_recv = Instant::now();
|
|
}
|
|
Some(Ok(tokio_tungstenite::tungstenite::Message::Close(_))) | None => {
|
|
#[cfg(debug_assertions)]
|
|
tracing::debug!("Feishu WebSocket closed");
|
|
break;
|
|
}
|
|
Some(Err(e)) => {
|
|
tracing::warn!(error = %e, "Feishu WebSocket error");
|
|
break;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
_ = ping_interval_tok.tick() => {
|
|
seq = seq.wrapping_add(1);
|
|
let ping = PbFrame {
|
|
seq_id: seq,
|
|
log_id: 0,
|
|
service: service_id,
|
|
method: 0,
|
|
headers: vec![PbHeader {
|
|
key: "type".into(),
|
|
value: "ping".into(),
|
|
}],
|
|
payload: None,
|
|
};
|
|
if write.send(tokio_tungstenite::tungstenite::Message::Binary(ping.encode_to_vec().into())).await.is_err() {
|
|
tracing::warn!("Feishu ping failed, reconnecting");
|
|
break;
|
|
}
|
|
}
|
|
_ = timeout_check.tick() => {
|
|
if last_recv.elapsed() > WS_HEARTBEAT_TIMEOUT {
|
|
tracing::warn!("Feishu WebSocket heartbeat timeout, reconnecting");
|
|
break;
|
|
}
|
|
// GC dedup cache: remove entries older than TTL (matches zeroclaw pattern)
|
|
let now = Instant::now();
|
|
let mut seen = self.seen_message_ids.write().await;
|
|
seen.retain(|_, ts| now.duration_since(*ts) < DEDUP_CACHE_TTL);
|
|
}
|
|
_ = shutdown_rx.recv() => {
|
|
tracing::info!("Feishu channel shutdown signal received");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
*self.connected.write().await = false;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn parse_post_content(content: &str) -> String {
|
|
/// Extract text from a single post element (text, link, at-mention).
|
|
fn extract_element(el: &serde_json::Value, out: &mut Vec<String>) {
|
|
match el.get("tag").and_then(|t| t.as_str()).unwrap_or("") {
|
|
"text" => {
|
|
if let Some(text) = el.get("text").and_then(|t| t.as_str()) {
|
|
out.push(text.to_string());
|
|
}
|
|
}
|
|
"a" => {
|
|
let link_text = el.get("text")
|
|
.and_then(|t| t.as_str())
|
|
.filter(|s| !s.is_empty())
|
|
.or_else(|| el.get("href").and_then(|h| h.as_str()))
|
|
.unwrap_or("");
|
|
out.push(link_text.to_string());
|
|
}
|
|
"at" => {
|
|
let name = el.get("user_name")
|
|
.and_then(|n| n.as_str())
|
|
.or_else(|| el.get("user_id").and_then(|i| i.as_str()))
|
|
.unwrap_or("user");
|
|
out.push(format!("@{}", name));
|
|
}
|
|
"code_block" => {
|
|
let lang = el.get("language").and_then(|l| l.as_str()).unwrap_or("");
|
|
let code_text = el.get("text").and_then(|t| t.as_str()).unwrap_or("");
|
|
out.push(format!("\n```{}\n{}\n```\n", lang, code_text));
|
|
}
|
|
_ => {
|
|
if let Some(text) = el.get("text").and_then(|t| t.as_str()) {
|
|
out.push(text.to_string());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Parse a single block {title, content: [[...]]} and append text to out.
|
|
fn parse_block(block: &serde_json::Value, out: &mut Vec<String>) {
|
|
let title = block.get("title").and_then(|t| t.as_str()).filter(|s| !s.is_empty());
|
|
if let Some(t) = title {
|
|
out.push(t.to_string());
|
|
out.push("\n\n".to_string());
|
|
}
|
|
|
|
if let Some(content_arr) = block.get("content").and_then(|c| c.as_array()) {
|
|
for row in content_arr {
|
|
if let Some(row_arr) = row.as_array() {
|
|
for el in row_arr {
|
|
extract_element(el, out);
|
|
}
|
|
out.push("\n".to_string());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let Ok(parsed) = serde_json::from_str::<serde_json::Value>(content) else {
|
|
return content.to_string();
|
|
};
|
|
|
|
let mut texts = Vec::new();
|
|
|
|
// Unwrap optional {"post": ...} envelope (nanobot: root = root["post"])
|
|
let root = if parsed.get("post").and_then(|p| p.as_object()).is_some() {
|
|
parsed.get("post").unwrap()
|
|
} else {
|
|
&parsed
|
|
};
|
|
|
|
// Try direct format: {"title": ..., "content": [[...]]}
|
|
if root.get("content").and_then(|c| c.as_array()).is_some() {
|
|
parse_block(root, &mut texts);
|
|
let result = texts.join("");
|
|
if !result.trim().is_empty() {
|
|
return result.trim().to_string();
|
|
}
|
|
texts.clear();
|
|
}
|
|
|
|
// Try localized: {"zh_cn": {"title": ..., "content": [...]}}
|
|
for key in ["zh_cn", "en_us", "ja_jp"] {
|
|
if let Some(locale_data) = root.get(key).and_then(|l| l.as_object()) {
|
|
parse_block(&serde_json::json!(locale_data), &mut texts);
|
|
let result = texts.join("");
|
|
if !result.trim().is_empty() {
|
|
return result.trim().to_string();
|
|
}
|
|
texts.clear();
|
|
}
|
|
}
|
|
|
|
// Fall back: try any dict child
|
|
if let Some(root_obj) = root.as_object() {
|
|
for (_key, val) in root_obj {
|
|
if let Some(obj) = val.as_object()
|
|
&& obj.get("content").and_then(|c| c.as_array()).is_some() {
|
|
parse_block(val, &mut texts);
|
|
let result = texts.join("");
|
|
if !result.trim().is_empty() {
|
|
return result.trim().to_string();
|
|
}
|
|
texts.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
content.to_string()
|
|
}
|
|
|
|
/// Extract text content from interactive card messages
|
|
fn extract_interactive_content(content: &str) -> Result<(String, Option<MediaItem>), ChannelError> {
|
|
let parsed = match serde_json::from_str::<serde_json::Value>(content) {
|
|
Ok(p) => p,
|
|
Err(_) => return Ok((content.to_string(), None)),
|
|
};
|
|
|
|
let mut texts = Vec::new();
|
|
|
|
// Extract from elements array
|
|
if let Some(elements) = parsed.get("elements").and_then(|e| e.as_array()) {
|
|
for el in elements {
|
|
extract_element_content(el, &mut texts);
|
|
}
|
|
}
|
|
|
|
// Extract from card object
|
|
if let Some(card) = parsed.get("card").and_then(|c| c.as_object())
|
|
&& let Some(elements) = card.get("elements").and_then(|e| e.as_array()) {
|
|
for el in elements {
|
|
extract_element_content(el, &mut texts);
|
|
}
|
|
}
|
|
|
|
// Extract from header
|
|
if let Some(header) = parsed.get("header").and_then(|h| h.as_object())
|
|
&& let Some(title) = header.get("title").and_then(|t| t.as_object())
|
|
&& let Some(text) = title.get("content").and_then(|c| c.as_str()) {
|
|
texts.push(format!("title: {}\n", text));
|
|
}
|
|
|
|
let result = texts.join("").trim().to_string();
|
|
if result.is_empty() {
|
|
Ok((content.to_string(), None))
|
|
} else {
|
|
Ok((result, None))
|
|
}
|
|
}
|
|
|
|
/// Extract content from a single card element
|
|
fn extract_element_content(element: &serde_json::Value, texts: &mut Vec<String>) {
|
|
let tag = element.get("tag").and_then(|t| t.as_str()).unwrap_or("");
|
|
|
|
match tag {
|
|
"markdown" | "lark_md" => {
|
|
if let Some(content) = element.get("content").and_then(|c| c.as_str()) {
|
|
texts.push(content.to_string());
|
|
texts.push("\n".to_string());
|
|
}
|
|
}
|
|
"div" => {
|
|
if let Some(text_obj) = element.get("text").and_then(|t| t.as_object()) {
|
|
let content = text_obj.get("content")
|
|
.and_then(|c| c.as_str())
|
|
.unwrap_or("");
|
|
texts.push(content.to_string());
|
|
} else if let Some(content) = element.get("text").and_then(|t| t.as_str()) {
|
|
texts.push(content.to_string());
|
|
}
|
|
texts.push("\n".to_string());
|
|
}
|
|
"a" => {
|
|
let href = element.get("href")
|
|
.and_then(|h| h.as_str())
|
|
.unwrap_or("");
|
|
let text = element.get("text")
|
|
.and_then(|t| t.as_str())
|
|
.unwrap_or("");
|
|
if !text.is_empty() {
|
|
texts.push(text.to_string());
|
|
} else if !href.is_empty() {
|
|
texts.push(format!("link: {}", href));
|
|
}
|
|
}
|
|
"img" => {
|
|
let alt = element.get("alt");
|
|
let alt_text = alt.and_then(|a| a.as_str())
|
|
.or_else(|| alt.and_then(|a| a.as_object()).and_then(|o| o.get("content")).and_then(|c| c.as_str()))
|
|
.unwrap_or("[image]");
|
|
texts.push(format!("{}\n", alt_text));
|
|
}
|
|
"note" => {
|
|
if let Some(elements) = element.get("elements").and_then(|e| e.as_array()) {
|
|
for el in elements {
|
|
extract_element_content(el, texts);
|
|
}
|
|
}
|
|
}
|
|
"column_set" => {
|
|
if let Some(columns) = element.get("columns").and_then(|c| c.as_array()) {
|
|
for col in columns {
|
|
if let Some(elements) = col.get("elements").and_then(|e| e.as_array()) {
|
|
for el in elements {
|
|
extract_element_content(el, texts);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"table" => {
|
|
// Tables are complex, just indicate presence
|
|
texts.push("[table]\n".to_string());
|
|
}
|
|
_ => {
|
|
// Recursively check for nested elements
|
|
if let Some(elements) = element.get("elements").and_then(|e| e.as_array()) {
|
|
for el in elements {
|
|
extract_element_content(el, texts);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Parse Feishu list/bullet message content into plain text
|
|
fn parse_list_content(content: &str) -> Result<(String, Option<MediaItem>), ChannelError> {
|
|
let parsed = match serde_json::from_str::<serde_json::Value>(content) {
|
|
Ok(p) => p,
|
|
Err(_) => return Ok((content.to_string(), None)),
|
|
};
|
|
|
|
let items = parsed.get("items")
|
|
.and_then(|i| i.as_array())
|
|
.or_else(|| parsed.get("content").and_then(|c| c.as_array()));
|
|
|
|
let Some(items) = items else {
|
|
return Ok((content.to_string(), None));
|
|
};
|
|
|
|
let mut lines = Vec::new();
|
|
collect_list_items(items, &mut lines, 0);
|
|
|
|
let result = lines.join("\n").trim().to_string();
|
|
if result.is_empty() {
|
|
Ok((content.to_string(), None))
|
|
} else {
|
|
Ok((result, None))
|
|
}
|
|
}
|
|
|
|
/// Recursively collect list item text with indentation
|
|
fn collect_list_items(items: &[serde_json::Value], lines: &mut Vec<String>, depth: usize) {
|
|
let indent = " ".repeat(depth);
|
|
|
|
for item in items {
|
|
// Items can be arrays of inline elements or objects with content/children
|
|
let inline_elements = if let Some(arr) = item.as_array() {
|
|
arr.as_slice()
|
|
} else if let Some(obj) = item.as_object() {
|
|
obj.get("content")
|
|
.and_then(|c| c.as_array())
|
|
.map(|a| a.as_slice())
|
|
.unwrap_or(&[])
|
|
} else {
|
|
continue;
|
|
};
|
|
|
|
let mut text = String::new();
|
|
for el in inline_elements {
|
|
extract_inline_text(el, &mut text);
|
|
}
|
|
|
|
let trimmed = text.trim();
|
|
if !trimmed.is_empty() {
|
|
lines.push(format!("{}- {}", indent, trimmed));
|
|
}
|
|
|
|
// Handle nested children
|
|
if let Some(obj) = item.as_object() {
|
|
if let Some(children) = obj.get("children").and_then(|c| c.as_array()) {
|
|
collect_list_items(children, lines, depth + 1);
|
|
}
|
|
} else if let Some(children_arr) = item.as_array().and_then(|arr| {
|
|
arr.iter().find_map(|child| {
|
|
if child.as_object().and_then(|o| o.get("children")).is_some() {
|
|
Some(child)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
})
|
|
&& let Some(children) = children_arr.as_object().and_then(|o| o.get("children")).and_then(|c| c.as_array()) {
|
|
collect_list_items(children, lines, depth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Extract text from inline elements (text, link, at-mention)
|
|
fn extract_inline_text(el: &serde_json::Value, out: &mut String) {
|
|
match el.get("tag").and_then(|t| t.as_str()).unwrap_or("") {
|
|
"text" => {
|
|
if let Some(text) = el.get("text").and_then(|t| t.as_str()) {
|
|
out.push_str(text);
|
|
}
|
|
}
|
|
"a" => {
|
|
let text = el.get("text")
|
|
.and_then(|t| t.as_str())
|
|
.filter(|s| !s.is_empty())
|
|
.or_else(|| el.get("href").and_then(|h| h.as_str()))
|
|
.unwrap_or("");
|
|
out.push_str(text);
|
|
}
|
|
"at" => {
|
|
let name = el.get("user_name")
|
|
.and_then(|n| n.as_str())
|
|
.or_else(|| el.get("user_id").and_then(|i| i.as_str()))
|
|
.unwrap_or("user");
|
|
out.push_str(&format!("@{}", name));
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
/// Remove @_user_N placeholder tokens injected by Feishu in group chats
|
|
fn strip_at_placeholders(text: &str) -> String {
|
|
let mut result = String::with_capacity(text.len());
|
|
let mut chars = text.chars().peekable();
|
|
|
|
while let Some(ch) = chars.next() {
|
|
if ch == '@' {
|
|
let rest: String = chars.clone().collect();
|
|
if let Some(after) = rest.strip_prefix("_user_") {
|
|
// Skip until we hit a non-alphanumeric character
|
|
let placeholder_len = after.find(|c: char| !c.is_alphanumeric()).unwrap_or(after.len());
|
|
// Skip the placeholder
|
|
for _ in 0..placeholder_len {
|
|
chars.next();
|
|
}
|
|
// Also skip the underscore after user_N if present
|
|
if chars.peek() == Some(&'_') {
|
|
chars.next();
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
result.push(ch);
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
fn resolve_image_ext(content_type: &str) -> &str {
|
|
match content_type {
|
|
"image/png" => "png",
|
|
"image/gif" => "gif",
|
|
"image/webp" => "webp",
|
|
"image/bmp" => "bmp",
|
|
_ => "jpg",
|
|
}
|
|
}
|
|
|
|
fn resolve_file_ext(content_json: &serde_json::Value) -> String {
|
|
if let Some(name) = content_json
|
|
.get("file_name")
|
|
.and_then(|v| v.as_str())
|
|
{
|
|
if let Some(ext) = std::path::Path::new(name).extension().and_then(|e| e.to_str()) {
|
|
return ext.to_string();
|
|
}
|
|
}
|
|
String::new()
|
|
}
|
|
|
|
async fn resolve_unique_path(dir: &Path, filename: &str) -> std::path::PathBuf {
|
|
let candidate = dir.join(filename);
|
|
if !tokio::fs::try_exists(&candidate).await.unwrap_or(false) {
|
|
return candidate;
|
|
}
|
|
let stem = std::path::Path::new(filename)
|
|
.file_stem()
|
|
.and_then(|s| s.to_str())
|
|
.unwrap_or(filename);
|
|
let ext = std::path::Path::new(filename)
|
|
.extension()
|
|
.and_then(|s| s.to_str())
|
|
.unwrap_or("");
|
|
let mut n = 1;
|
|
loop {
|
|
let candidate = if ext.is_empty() {
|
|
dir.join(format!("{}({})", stem, n))
|
|
} else {
|
|
dir.join(format!("{}({}).{}", stem, n, ext))
|
|
};
|
|
if !tokio::fs::try_exists(&candidate).await.unwrap_or(false) {
|
|
return candidate;
|
|
}
|
|
n += 1;
|
|
}
|
|
}
|
|
|
|
impl FeishuChannel {
|
|
fn strip_thinking_tags(content: &str) -> String {
|
|
use std::sync::LazyLock;
|
|
static THINK_RE: LazyLock<Regex> = LazyLock::new(|| {
|
|
Regex::new(r"(?s)<think>.*?</think>").unwrap()
|
|
});
|
|
let stripped = THINK_RE.replace_all(content, "");
|
|
stripped.trim().to_string()
|
|
}
|
|
|
|
/// Build a Card JSON 2.0 interactive card with a single markdown element.
|
|
fn build_card_content(markdown: &str) -> String {
|
|
serde_json::json!({
|
|
"schema": "2.0",
|
|
"body": {
|
|
"elements": [{
|
|
"tag": "markdown",
|
|
"content": markdown
|
|
}]
|
|
}
|
|
})
|
|
.to_string()
|
|
}
|
|
|
|
/// Max byte-size for markdown content in a single card.
|
|
/// Card payloads have a ~30 KB limit; leave margin for JSON envelope.
|
|
const CARD_MARKDOWN_MAX_BYTES: usize = 28_000;
|
|
|
|
/// Split markdown content into chunks that fit within the card size limit.
|
|
/// Splits on line boundaries to avoid breaking markdown syntax.
|
|
fn split_markdown_chunks(text: &str) -> Vec<String> {
|
|
if text.len() <= Self::CARD_MARKDOWN_MAX_BYTES {
|
|
return vec![text.to_string()];
|
|
}
|
|
|
|
let mut chunks: Vec<String> = Vec::new();
|
|
let mut start = 0;
|
|
|
|
while start < text.len() {
|
|
if start + Self::CARD_MARKDOWN_MAX_BYTES >= text.len() {
|
|
chunks.push(text[start..].to_string());
|
|
break;
|
|
}
|
|
|
|
let end = start + Self::CARD_MARKDOWN_MAX_BYTES;
|
|
let search_region = &text[start..end];
|
|
let split_at = search_region
|
|
.rfind('\n')
|
|
.map(|pos| start + pos + 1)
|
|
.unwrap_or(end);
|
|
|
|
let split_at = if text.is_char_boundary(split_at) {
|
|
split_at
|
|
} else {
|
|
(start..split_at)
|
|
.rev()
|
|
.find(|&i| text.is_char_boundary(i))
|
|
.unwrap_or(start)
|
|
};
|
|
|
|
if split_at <= start {
|
|
let forced = (end..=text.len())
|
|
.find(|&i| text.is_char_boundary(i))
|
|
.unwrap_or(text.len());
|
|
chunks.push(text[start..forced].to_string());
|
|
start = forced;
|
|
} else {
|
|
chunks.push(text[start..split_at].to_string());
|
|
start = split_at;
|
|
}
|
|
}
|
|
|
|
chunks
|
|
}
|
|
|
|
/// Send an interactive card message to Feishu.
|
|
async fn send_interactive_card(
|
|
&self,
|
|
receive_id: &str,
|
|
receive_id_type: &str,
|
|
card_content: &str,
|
|
) -> Result<(), ChannelError> {
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
let resp = self.http_client
|
|
.post(format!("{}/im/v1/messages?receive_id_type={}", FEISHU_API_BASE, receive_id_type))
|
|
.header("Content-Type", "application/json")
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.json(&serde_json::json!({
|
|
"receive_id": receive_id,
|
|
"msg_type": "interactive",
|
|
"content": card_content
|
|
}))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Send interactive card HTTP error: {}", e)))?;
|
|
|
|
#[derive(Deserialize)]
|
|
struct SendResp {
|
|
code: i32,
|
|
msg: String,
|
|
}
|
|
|
|
let send_resp: SendResp = resp
|
|
.json()
|
|
.await
|
|
.map_err(|e| ChannelError::Other(format!("Parse send interactive card response error: {}", e)))?;
|
|
|
|
if send_resp.code != 0 {
|
|
return Err(ChannelError::Other(format!(
|
|
"Send interactive card failed: code={} msg={}",
|
|
send_resp.code, send_resp.msg
|
|
)));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl Channel for FeishuChannel {
|
|
fn name(&self) -> &str {
|
|
"feishu"
|
|
}
|
|
|
|
/// Handle an inbound message: check for slash commands first, then publish to bus
|
|
async fn handle_and_publish(
|
|
&self,
|
|
bus: &Arc<MessageBus>,
|
|
msg: &crate::bus::InboundMessage,
|
|
) -> Result<(), ChannelError> {
|
|
// All messages (including slash commands) go through the normal inbound flow
|
|
// SessionManager handles session creation/reuse internally
|
|
bus.publish_inbound(msg.clone()).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn start(&self, bus: Arc<MessageBus>) -> Result<(), ChannelError> {
|
|
if self.config.app_id.is_empty() || self.config.app_secret.is_empty() {
|
|
return Err(ChannelError::ConfigError(
|
|
"Feishu app_id or app_secret is not configured".to_string()
|
|
));
|
|
}
|
|
|
|
*self.running.write().await = true;
|
|
|
|
let (shutdown_tx, _) = broadcast::channel(1);
|
|
*self.shutdown_tx.write().await = Some(shutdown_tx.clone());
|
|
|
|
let channel = self.clone();
|
|
let bus = bus.clone();
|
|
tokio::spawn(async move {
|
|
let mut consecutive_failures = 0;
|
|
let max_failures = 3;
|
|
|
|
loop {
|
|
if !*channel.running.read().await {
|
|
break;
|
|
}
|
|
|
|
let shutdown_rx = shutdown_tx.subscribe();
|
|
match channel.run_ws_loop(bus.clone(), shutdown_rx).await {
|
|
Ok(_) => {
|
|
tracing::info!("Feishu WebSocket disconnected");
|
|
}
|
|
Err(e) => {
|
|
consecutive_failures += 1;
|
|
tracing::error!(attempt = consecutive_failures, error = %e, "Feishu WebSocket error");
|
|
if consecutive_failures >= max_failures {
|
|
tracing::error!("Feishu channel: max failures reached, stopping");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if !*channel.running.read().await {
|
|
break;
|
|
}
|
|
|
|
tracing::info!("Feishu channel retrying in 5s...");
|
|
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
|
|
}
|
|
|
|
*channel.running.write().await = false;
|
|
tracing::info!("Feishu channel stopped");
|
|
});
|
|
|
|
tracing::info!("Feishu channel started");
|
|
Ok(())
|
|
}
|
|
|
|
async fn stop(&self) -> Result<(), ChannelError> {
|
|
*self.running.write().await = false;
|
|
|
|
if let Some(tx) = self.shutdown_tx.write().await.take() {
|
|
let _ = tx.send(());
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn is_running(&self) -> bool {
|
|
self.running.try_read().map(|r| *r).unwrap_or(false)
|
|
}
|
|
|
|
async fn send(&self, msg: OutboundMessage) -> Result<(), ChannelError> {
|
|
let msg = OutboundMessage {
|
|
content: Self::strip_thinking_tags(&msg.content),
|
|
..msg
|
|
};
|
|
let receive_id = if msg.chat_id.starts_with("oc_") { &msg.chat_id } else { msg.reply_to.as_ref().unwrap_or(&msg.chat_id) };
|
|
let receive_id_type = if msg.chat_id.starts_with("oc_") { "chat_id" } else { "open_id" };
|
|
|
|
// If no media, send as interactive card with raw markdown
|
|
if msg.media.is_empty() {
|
|
let content = msg.content.trim();
|
|
|
|
// Empty content
|
|
if content.is_empty() {
|
|
self.remove_reaction_from_metadata(&msg.metadata).await;
|
|
return Ok(());
|
|
}
|
|
|
|
let chunks = Self::split_markdown_chunks(content);
|
|
for chunk in &chunks {
|
|
let card = Self::build_card_content(chunk);
|
|
if let Err(e) = self.send_interactive_card(receive_id, receive_id_type, &card).await {
|
|
tracing::warn!(error = %e, "Failed to send interactive card, falling back to text");
|
|
let text_content = serde_json::json!({ "text": chunk }).to_string();
|
|
let result = self.send_message_to_feishu(receive_id, receive_id_type, "text", &text_content).await;
|
|
self.remove_reaction_from_metadata(&msg.metadata).await;
|
|
return result;
|
|
}
|
|
}
|
|
self.remove_reaction_from_metadata(&msg.metadata).await;
|
|
return Ok(());
|
|
}
|
|
|
|
// Handle multimodal message - send with media
|
|
let token = self.get_tenant_access_token().await?;
|
|
|
|
// Separate images (can embed in post) from files (sent as separate messages)
|
|
let mut image_items = Vec::new();
|
|
let mut file_items = Vec::new();
|
|
for media_item in &msg.media {
|
|
match media_item.media_type.as_str() {
|
|
"image" => image_items.push(media_item),
|
|
"audio" | "video" | "file" => file_items.push(media_item),
|
|
_ => {
|
|
tracing::warn!(media_type = %media_item.media_type, "Unsupported media type for sending");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Upload and send files as separate messages (one per file)
|
|
for item in &file_items {
|
|
match self.upload_file(&item.path).await {
|
|
Ok(file_key) => {
|
|
let file_msg_type = match item.media_type.as_str() {
|
|
"audio" => "audio",
|
|
"video" => "media",
|
|
_ => "file",
|
|
};
|
|
let file_content = serde_json::json!({"file_key": file_key}).to_string();
|
|
if let Err(e) = self.send_message_to_feishu(
|
|
receive_id, receive_id_type, file_msg_type, &file_content,
|
|
).await {
|
|
tracing::warn!(error = %e, msg_type = file_msg_type, "Failed to send file message");
|
|
}
|
|
}
|
|
Err(e) => {
|
|
tracing::warn!(error = %e, path = %item.path, "Failed to upload file");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Build content parts for post (text + images)
|
|
let mut content_parts = Vec::new();
|
|
|
|
if !msg.content.is_empty() {
|
|
const MAX_TEXT_LENGTH: usize = 60_000;
|
|
let truncated_text = if msg.content.len() > MAX_TEXT_LENGTH {
|
|
format!("{}...\n\n[Content truncated due to length limit]", &msg.content[..msg.content.ceil_char_boundary(MAX_TEXT_LENGTH)])
|
|
} else {
|
|
msg.content.clone()
|
|
};
|
|
content_parts.push(serde_json::json!({
|
|
"tag": "text",
|
|
"text": truncated_text
|
|
}));
|
|
}
|
|
|
|
for item in &image_items {
|
|
match self.upload_image(&item.path).await {
|
|
Ok(image_key) => {
|
|
content_parts.push(serde_json::json!({
|
|
"tag": "img",
|
|
"image_key": image_key
|
|
}));
|
|
}
|
|
Err(e) => {
|
|
tracing::warn!(error = %e, path = %item.path, "Failed to upload image");
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no post content after processing (no text, no images), skip
|
|
if content_parts.is_empty() {
|
|
self.remove_reaction_from_metadata(&msg.metadata).await;
|
|
return Ok(());
|
|
}
|
|
|
|
// Determine message type and build content
|
|
let msg_type = if msg.content.is_empty() && image_items.len() == 1 {
|
|
"image"
|
|
} else {
|
|
"post"
|
|
};
|
|
|
|
let content = if msg_type == "image" {
|
|
// Image-only: content is just {"image_key": "..."}
|
|
let image_key = content_parts[0]["image_key"]
|
|
.as_str()
|
|
.unwrap_or("");
|
|
serde_json::json!({"image_key": image_key}).to_string()
|
|
} else {
|
|
// Post with media: zh_cn wrapped post structure
|
|
let post_content: Vec<Vec<serde_json::Value>> = content_parts
|
|
.into_iter()
|
|
.map(|part| vec![part])
|
|
.collect();
|
|
serde_json::json!({
|
|
"zh_cn": {
|
|
"title": "",
|
|
"content": post_content
|
|
}
|
|
}).to_string()
|
|
};
|
|
|
|
let resp = self.http_client
|
|
.post(format!("{}/im/v1/messages?receive_id_type={}", FEISHU_API_BASE, receive_id_type))
|
|
.header("Content-Type", "application/json")
|
|
.header("Authorization", format!("Bearer {}", token))
|
|
.json(&serde_json::json!({
|
|
"receive_id": receive_id,
|
|
"msg_type": msg_type,
|
|
"content": content
|
|
}))
|
|
.send()
|
|
.await
|
|
.map_err(|e| ChannelError::ConnectionError(format!("Send multimodal message HTTP error: {}", e)))?;
|
|
|
|
let send_status = resp.status();
|
|
let send_body = resp.text().await
|
|
.map_err(|e| ChannelError::Other(format!("Failed to read send response: {}", e)))?;
|
|
tracing::debug!(status = %send_status, body = %send_body, msg_type = %msg_type, "Feishu send message");
|
|
|
|
#[derive(Deserialize)]
|
|
struct SendResp {
|
|
code: i32,
|
|
msg: String,
|
|
}
|
|
|
|
let send_resp: SendResp = serde_json::from_str(&send_body)
|
|
.map_err(|e| ChannelError::Other(format!("Parse send response error: {} | body: {}", e, &send_body)))?;
|
|
|
|
if send_resp.code != 0 {
|
|
return Err(ChannelError::Other(format!("Send multimodal message failed: code={} msg={}", send_resp.code, send_resp.msg)));
|
|
}
|
|
|
|
// Remove pending reaction after successfully sending
|
|
self.remove_reaction_from_metadata(&msg.metadata).await;
|
|
|
|
Ok(())
|
|
}
|
|
}
|