eba4fd1
use std::collections::HashSet;
use std::time::Duration;
use cache::CacheClient;
use export::AppState;
use models::system::system_settings;
use sea_orm::sea_query::OnConflict;
use sea_orm::{DatabaseConnection, EntityTrait, Set};
use serde::{Deserialize, Serialize};
pub const DB_KEY: &str = "mcp.tools";
pub const CACHE_KEY: &str = "system:setting:mcp.tools";
const CACHE_TTL: Duration = Duration::from_secs(30);
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct McpToolSettings {
#[serde(default)]
pub disabled: Vec<String>,
#[serde(default)]
pub updated_by: Option<String>,
#[serde(default)]
pub updated_at: Option<String>,
}
pub async fn read(state: &AppState) -> McpToolSettings {
let cache = CacheClient::new(state.redis.clone());
if let Ok(Some(settings)) = cache.get::<McpToolSettings>(CACHE_KEY).await {
return settings;
}
match system_settings::Entity::find_by_id(DB_KEY.to_string())
.one(state.database.read())
.await
{
Ok(Some(row)) => match serde_json::from_str::<McpToolSettings>(&row.value) {
Ok(settings) => {
let _ = cache.set(CACHE_KEY, &settings, Some(CACHE_TTL)).await;
settings
}
Err(error) => {
tracing::warn!(%error, "invalid mcp tool settings payload; treating all tools as enabled");
McpToolSettings::default()
}
},
Ok(None) => McpToolSettings::default(),
Err(error) => {
tracing::warn!(%error, "failed to load mcp tool settings; treating all tools as enabled");
McpToolSettings::default()
}
}
}
pub async fn read_disabled(state: &AppState) -> HashSet<String> {
read(state).await.disabled.into_iter().collect()
}
pub async fn update(
state: &AppState,
disabled: Vec<String>,
updated_by: Option<String>,
) -> Result<McpToolSettings, String> {
let mut disabled: Vec<String> = disabled
.into_iter()
.map(|name| name.trim().to_string())
.filter(|name| !name.is_empty())
.collect();
disabled.sort();
disabled.dedup();
let settings = McpToolSettings {
disabled,
updated_by,
updated_at: Some(time::OffsetDateTime::now_utc().to_string()),
};
let value = serde_json::to_string(&settings).map_err(|error| error.to_string())?;
save(state.database.write(), &value)
.await
.map_err(|error| error.to_string())?;
if let Err(error) = export::redis::delete(&state.redis, CACHE_KEY).await {
tracing::warn!(%error, "failed to invalidate mcp tool settings cache");
}
Ok(settings)
}
async fn save(db: &DatabaseConnection, value: &str) -> Result<(), sea_orm::DbErr> {
let now = time::OffsetDateTime::now_utc();
let model = system_settings::ActiveModel {
key: Set(DB_KEY.to_string()),
value: Set(value.to_string()),
updated_at: Set(now),
};
system_settings::Entity::insert(model)
.on_conflict(
OnConflict::column(system_settings::Column::Key)
.update_columns([
system_settings::Column::Value,
system_settings::Column::UpdatedAt,
])
.to_owned(),
)
.exec_without_returning(db)
.await?;
Ok(())
}