256 lines
12 KiB
Rust
256 lines
12 KiB
Rust
//! df-im-gateway 主入口:装配 config + store + throttle + commander + adapters
|
|
//!
|
|
//! 骨架版(P0):Web 适配器真实可跑,事件流全链路打通。
|
|
//! 用法:
|
|
//! ```text
|
|
//! df-im-gateway.exe # 默认配置(env)
|
|
//! GATEWAY_RELAY_URL=... GATEWAY_RELAY_TOKEN=... \
|
|
//! GATEWAY_DEFAULT_CHANNEL=chan-work df-im-gateway.exe
|
|
//! ```
|
|
|
|
mod adapters;
|
|
mod commander;
|
|
mod config;
|
|
mod feishu;
|
|
mod store;
|
|
mod throttle;
|
|
|
|
use std::path::PathBuf;
|
|
|
|
use tokio::sync::mpsc;
|
|
|
|
use adapters::{InboundEvent, OutboundAction, PlatformAdapter};
|
|
use config::GatewayConfig;
|
|
use store::SessionStore;
|
|
use throttle::DeltaThrottle;
|
|
|
|
#[tokio::main]
|
|
async fn main() -> anyhow::Result<()> {
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(
|
|
tracing_subscriber::EnvFilter::try_from_default_env()
|
|
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
|
|
)
|
|
.init();
|
|
|
|
let cfg = GatewayConfig::load()?;
|
|
if cfg.channels.is_empty() {
|
|
anyhow::bail!("未配置任何 channel 路由(GATEWAY_DEFAULT_CHANNEL),无法启动");
|
|
}
|
|
|
|
let data_dir = std::env::var("GATEWAY_DATA_DIR")
|
|
.map(PathBuf::from)
|
|
.unwrap_or_else(|_| PathBuf::from("data"));
|
|
std::fs::create_dir_all(&data_dir)?;
|
|
let store = SessionStore::open(&data_dir.join("sessions.db"))?;
|
|
|
|
info_banner(&cfg);
|
|
|
|
// ── 核心事件总线:适配器 → 核心 ─────────────────────────────
|
|
let (inbound_tx, mut inbound_rx) = mpsc::channel::<InboundEvent>(256);
|
|
|
|
// Web 适配器(四端首个,P0)
|
|
let web_adapter = adapters::web::WebAdapter::new();
|
|
{
|
|
let web_run = web_adapter.clone();
|
|
let ev_tx = inbound_tx.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = web_run.run(ev_tx).await {
|
|
tracing::error!("[web] 适配器退出: {e}");
|
|
}
|
|
});
|
|
}
|
|
|
|
// 飞书适配器(P2):FEISHU_APP_ID/SECRET 配置时启用长连接
|
|
let feishu_adapter = cfg.feishu.as_ref().map(|f| match feishu::FeishuAdapter::new(f) {
|
|
Ok(adapter) => {
|
|
let feishu_run = adapter.clone();
|
|
let ev_tx = inbound_tx.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = feishu_run.run(ev_tx).await {
|
|
tracing::error!("[feishu] 适配器退出: {e}");
|
|
}
|
|
});
|
|
tracing::info!("[feishu] 适配器已启动(长连接)");
|
|
adapter
|
|
}
|
|
Err(e) => {
|
|
tracing::error!("[feishu] 适配器构造失败(跳过): {e}");
|
|
feishu::FeishuAdapter::offline()
|
|
}
|
|
});
|
|
|
|
// ── Commander 连接(u-relay)────────────────────────────────
|
|
let (shutdown_tx, shutdown_rx) = tokio::sync::watch::channel(false);
|
|
let default_channel = cfg
|
|
.channels
|
|
.iter()
|
|
.find(|c| c.prefix.is_empty())
|
|
.map(|c| c.channel_id.clone())
|
|
.unwrap_or_else(|| cfg.channels[0].channel_id.clone());
|
|
|
|
// 事件流:commander 任务 → 核心循环
|
|
let (ev_tx, mut ev_rx) = mpsc::channel::<df_tunnel::events::TunnelEvent>(256);
|
|
// 指令流:核心循环 → commander 任务(透传到 WS)
|
|
let (cmd_tx, cmd_rx) = mpsc::channel::<df_tunnel::TunnelCommand>(256);
|
|
|
|
{
|
|
let relay_url = cfg.relay_url.clone();
|
|
let token = cfg.relay_token.clone();
|
|
let channel = default_channel.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = commander::run_commander(relay_url, channel, token, ev_tx, cmd_rx, shutdown_rx).await {
|
|
tracing::error!("[commander] 连接循环退出: {e}");
|
|
}
|
|
});
|
|
}
|
|
|
|
// ── 核心分发循环(单 select,持有全部状态,无跨线程共享)─────
|
|
let mut throttle = DeltaThrottle::new(cfg.throttle_ms);
|
|
// 审批幂等表:approval_id → 已处理标记(P0 必验项 ②:防 pending→approved 二次点击重复转发)
|
|
let mut handled_approvals: std::collections::HashSet<String> = std::collections::HashSet::new();
|
|
// 平台注册表(走查 #4):显式 platform → 下标映射,替代硬编码 "feishu"=>1 与
|
|
// adapters vec 构建顺序的隐式耦合。新增平台(企微/钉钉)只在此处注册一次。
|
|
let mut adapters: Vec<Box<dyn adapters::PlatformAdapter>> = vec![Box::new(web_adapter.clone())];
|
|
let mut platform_index: std::collections::HashMap<String, usize> =
|
|
std::collections::HashMap::from([("web".to_string(), 0usize)]);
|
|
if let Some(fs) = feishu_adapter {
|
|
platform_index.insert("feishu".to_string(), adapters.len());
|
|
adapters.push(Box::new(fs));
|
|
}
|
|
let platform_of = |platform_or_conv: &str| -> usize {
|
|
// conv_id 形如 "platform:chat_id",前缀即平台;未知平台回退 web(0)
|
|
let platform = platform_or_conv.split(':').next().unwrap_or("web");
|
|
*platform_index.get(platform).unwrap_or(&0)
|
|
};
|
|
// 停止信号
|
|
let shutdown_ctrl = tokio::signal::ctrl_c();
|
|
tokio::pin!(shutdown_ctrl);
|
|
let cfg_loop = cfg.clone();
|
|
|
|
loop {
|
|
tokio::select! {
|
|
_ = &mut shutdown_ctrl => {
|
|
tracing::info!("收到 Ctrl+C,优雅退出");
|
|
let _ = shutdown_tx.send(true);
|
|
break;
|
|
}
|
|
// ── TunnelEvent(桌面端 → 网关)──
|
|
ev = ev_rx.recv() => {
|
|
let Some(ev) = ev else { break };
|
|
match ev {
|
|
df_tunnel::TunnelEvent::TextDelta { conv_id, delta } => {
|
|
// 出站按 conv_id 前缀(platform:chat_id)路由回原平台
|
|
let flush = throttle.feed(&conv_id, &delta);
|
|
if let Some(text) = flush {
|
|
let idx = platform_of(&conv_id);
|
|
let _ = adapters[idx]
|
|
.dispatch(OutboundAction::StreamText { chat_id: conv_id, text, done: false })
|
|
.await;
|
|
}
|
|
}
|
|
df_tunnel::TunnelEvent::Completed { conv_id, .. } => {
|
|
let tail = throttle.finish(&conv_id);
|
|
let full = tail.unwrap_or_default();
|
|
let idx = platform_of(&conv_id);
|
|
let _ = adapters[idx]
|
|
.dispatch(OutboundAction::StreamText { chat_id: conv_id, text: full, done: true })
|
|
.await;
|
|
}
|
|
df_tunnel::TunnelEvent::Approval { conv_id, approval_id, description } => {
|
|
let idx = platform_of(&conv_id);
|
|
let _ = adapters[idx]
|
|
.dispatch(OutboundAction::ApprovalCard {
|
|
chat_id: conv_id,
|
|
approval_id,
|
|
title: "工具审批请求".into(),
|
|
detail: description,
|
|
})
|
|
.await;
|
|
}
|
|
df_tunnel::TunnelEvent::ToolCall { .. } => {
|
|
// P0 骨架不转发 ToolCall 到 IM(卡片噪音),仅日志
|
|
tracing::debug!("[core] ToolCall 事件(骨架忽略)");
|
|
}
|
|
}
|
|
}
|
|
// ── InboundEvent(IM → 网关)──
|
|
inbound = inbound_rx.recv() => {
|
|
let Some(ev) = inbound else { break };
|
|
match ev {
|
|
InboundEvent::Message { platform, chat_id, user_id, text } => {
|
|
// 回复适配器:按来源平台回路由
|
|
let reply_idx = platform_of(&platform);
|
|
if !cfg_loop.whitelist.is_empty() && !cfg_loop.whitelist.contains(&user_id) {
|
|
let _ = adapters[reply_idx]
|
|
.dispatch(OutboundAction::Notice { chat_id, text: "⛔ 你不在白名单内".into() })
|
|
.await;
|
|
continue;
|
|
}
|
|
let Some(channel_id) = cfg_loop.route(&text) else {
|
|
let _ = adapters[reply_idx]
|
|
.dispatch(OutboundAction::Notice { chat_id, text: "⚠️ 无可用 channel".into() })
|
|
.await;
|
|
continue;
|
|
};
|
|
// 会话映射:无则新建(conv_id = platform:chat_id,Web 端 chat_id 同源)
|
|
let conv_id = match store.get_conv(&platform, &chat_id) {
|
|
Some(m) => m.conv_id,
|
|
None => {
|
|
let conv = format!("{platform}:{chat_id}");
|
|
let _ = store.set_conv(&platform, &chat_id, &conv, channel_id);
|
|
// 走查 #3:新建会话时清理流式残留(上轮异常中止无
|
|
// Completed 事件,streams entry 永驻会错覆写旧消息)
|
|
adapters[reply_idx].reset_stream(&chat_id).await;
|
|
conv
|
|
}
|
|
};
|
|
let _ = cmd_tx
|
|
.send(df_tunnel::TunnelCommand::Send { conv_id, content: text })
|
|
.await;
|
|
}
|
|
InboundEvent::NewSession { platform, chat_id } => {
|
|
let _ = store.remove(&platform, &chat_id);
|
|
let reply_idx = platform_of(&platform);
|
|
let _ = adapters[reply_idx]
|
|
.dispatch(OutboundAction::Notice { chat_id, text: "🔄 已重置会话".into() })
|
|
.await;
|
|
}
|
|
InboundEvent::Approval { platform, chat_id, approval_id, approved } => {
|
|
// 幂等:同 approval_id 只处理首次(P0 必验项 ②)
|
|
if handled_approvals.contains(&approval_id) {
|
|
tracing::debug!("[core] 审批 {approval_id} 已处理,忽略重复点击");
|
|
continue;
|
|
}
|
|
handled_approvals.insert(approval_id.clone());
|
|
let conv_id = store
|
|
.get_conv(&platform, &chat_id)
|
|
.map(|m| m.conv_id)
|
|
.unwrap_or_else(|| format!("{platform}:{chat_id}"));
|
|
let _ = cmd_tx
|
|
.send(df_tunnel::TunnelCommand::Approve { conv_id, approval_id, accepted: approved })
|
|
.await;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn info_banner(cfg: &GatewayConfig) {
|
|
println!("╔══════════════════════════════════════════╗");
|
|
println!("║ df-im-gateway v0.1.0 (P0 骨架) ║");
|
|
println!("╚══════════════════════════════════════════╝");
|
|
println!(" relay : {}", cfg.relay_url);
|
|
println!(" channels : {} 条路由", cfg.channels.len());
|
|
println!(" throttle : {}ms", cfg.throttle_ms);
|
|
println!(" whitelist : {} 用户", cfg.whitelist.len());
|
|
if cfg.whitelist.is_empty() {
|
|
println!(" ⚠️ 白名单为空:任何人可用本网关(开发默认)。生产部署请设置 GATEWAY_WHITELIST!");
|
|
}
|
|
println!(" feishu : {}", if cfg.feishu.is_some() { "已配置" } else { "未配置(跳过)" });
|
|
println!(" web ws : 0.0.0.0:9191");
|
|
}
|