8965 lines
398 KiB
Rust
8965 lines
398 KiB
Rust
use std::{collections::HashMap, sync::Arc, time::Duration, time::Instant};
|
||
|
||
use rmcp::{
|
||
handler::server::{router::tool::ToolRouter, wrapper::Parameters},
|
||
model::{
|
||
CallToolResult, ContentBlock, ErrorData, Implementation, ListResourceTemplatesResult, ListResourcesResult,
|
||
ReadResourceRequestParams, ReadResourceResult, Resource, ResourceContents, ResourceTemplate,
|
||
ServerCapabilities, ServerInfo,
|
||
},
|
||
schemars, tool, tool_handler, tool_router, ServerHandler,
|
||
};
|
||
use serde::Deserialize;
|
||
use serde_json::json;
|
||
use url::Url;
|
||
use uuid::Uuid;
|
||
|
||
use crate::backend::{format_query_result, new_connection_config, parse_database_type, ConnectionSummary, DbxBackend};
|
||
use crate::mongo::{self, MongoCommand, MongoSafetyError};
|
||
use crate::session::{McpSession, McpSessionStore};
|
||
use crate::transaction::{TransactionFailure, TransactionResult, TransactionStatus};
|
||
use dbx_core::{
|
||
agent_tools::{
|
||
format_query_result_as_text, normalize_sql_for_confirmation, QueryCellWindow, MAX_EXECUTE_QUERY_ROWS,
|
||
},
|
||
connection::SalesforceCurrentUser,
|
||
database_manifest,
|
||
db::redis_driver::{classify_command, parse_command_argv, RedisCommandResult, RedisCommandSafety},
|
||
db::salesforce_driver::parse_salesforce_statement,
|
||
history::HistoryEntry,
|
||
mcp_policy::connection_allows_salesforce_dml,
|
||
models::connection::ConnectionConfig,
|
||
models::connection::DatabaseType,
|
||
production_safety::{
|
||
is_production_database, mongo_pipeline_targets_production_database, sql_references_disallowed_database,
|
||
targets_production_database,
|
||
},
|
||
query_execution_sql::{classify_salesforce_statement_risk, is_write_sql_for_database, SalesforceStatementRisk},
|
||
sql_risk::{
|
||
classify_sql_risk_for_database, is_dangerous_sql_for_database, mcp_sql_has_forbidden_database_switch, SqlRisk,
|
||
},
|
||
storage::{McpDatabaseScope, McpGlobalPolicy},
|
||
};
|
||
|
||
const CONNECTIONS_RESOURCE_URI: &str = "dbx://connections";
|
||
const DATABASES_RESOURCE_TEMPLATE: &str = "dbx://connections/{connection_id}/databases";
|
||
const TABLES_RESOURCE_TEMPLATE: &str = "dbx://connections/{connection_id}/tables{?database,schema}";
|
||
const TABLE_SCHEMA_RESOURCE_TEMPLATE: &str = "dbx://connections/{connection_id}/table-schema{?database,schema,table}";
|
||
|
||
#[derive(Debug, PartialEq, Eq)]
|
||
enum DbxResourceRequest {
|
||
Connections,
|
||
Databases { connection_id: String },
|
||
Tables { connection_id: String, database: Option<String>, schema: Option<String> },
|
||
TableSchema { connection_id: String, database: Option<String>, schema: Option<String>, table: String },
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ListConnectionsRequest {}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ListDatabasesRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct PluginListRequest {
|
||
#[schemars(description = "Optional case-insensitive keyword matched against plugin ids and names")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub filter: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct PluginToolsRequest {
|
||
#[schemars(description = "Unique ID of the plugin, as returned by dbx_plugin_list")]
|
||
pub plugin_id: String,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct PluginCallRequest {
|
||
#[schemars(description = "Unique ID of the plugin, as returned by dbx_plugin_list")]
|
||
pub plugin_id: String,
|
||
#[schemars(description = "Tool name exactly as listed by dbx_plugin_tools")]
|
||
pub tool: String,
|
||
#[schemars(description = "Tool arguments object, matching the tool schema returned by dbx_plugin_tools")]
|
||
pub arguments: Option<serde_json::Value>,
|
||
#[schemars(
|
||
description = "Optional DBX connection to run the tool on when the plugin has several allowed connections"
|
||
)]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub dbx_connection: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ConnectionSelector {
|
||
#[schemars(description = "Unique ID of the DBX connection")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub connection_id: Option<String>,
|
||
#[schemars(description = "Name of the DBX connection")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub connection_name: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ListTablesRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(description = "Schema name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub schema: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct DescribeTableRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Table name")]
|
||
pub table: String,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(description = "Schema name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub schema: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ListRoutinesRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(description = "Schema name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub schema: Option<String>,
|
||
#[schemars(
|
||
description = "Optional routine type filter: PROCEDURE or FUNCTION. Omit to list both. Unsupported databases return an empty list."
|
||
)]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub routine_type: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct GetRoutineSourceRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Routine name (as returned by dbx_list_routines)")]
|
||
pub name: String,
|
||
#[schemars(description = "Routine type: PROCEDURE or FUNCTION")]
|
||
pub object_type: String,
|
||
#[schemars(description = "Optional routine signature for databases that overload routine names (e.g. Oracle)")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub signature: Option<String>,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(description = "Schema name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub schema: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ExecuteQueryRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(description = "SQL query to execute")]
|
||
pub sql: String,
|
||
#[schemars(
|
||
description = "Session ID from dbx_open_session. When set, the query runs on the session's pinned connection, preserving USE/SET and other session state across calls."
|
||
)]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub session_id: Option<String>,
|
||
#[schemars(
|
||
description = "Start character offset for every string cell (default 0, max 1000000). Use the next offset reported by a truncated result to slide through a long value; narrow the query to the target row and column first."
|
||
)]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub cell_char_offset: Option<u64>,
|
||
#[schemars(
|
||
description = "Maximum characters returned per string cell (default 200, max 4000). Increase only for an explicit long-value expansion."
|
||
)]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub cell_char_limit: Option<u64>,
|
||
#[schemars(
|
||
description = "Maximum rows returned for this call (default 100, max 1000; larger values are clamped). SQL connections only - MongoDB shell commands always return at most 100 rows, and multi-statement scripts routed to the batch executor return at most 100 rows per statement."
|
||
)]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub max_rows: Option<u64>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct OpenSessionRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[serde(default)]
|
||
#[schemars(description = "Eagerly reserve one native MySQL connection for explicit transaction tools")]
|
||
pub enable_transactions: bool,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct CloseSessionRequest {
|
||
#[schemars(description = "Session ID returned by dbx_open_session")]
|
||
pub session_id: String,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct TransactionSessionRequest {
|
||
#[schemars(description = "Transaction-enabled session ID returned by dbx_open_session")]
|
||
pub session_id: String,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct AddConnectionRequest {
|
||
pub name: String,
|
||
pub db_type: String,
|
||
pub host: String,
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub port: Option<u16>,
|
||
#[serde(default)]
|
||
pub username: String,
|
||
#[serde(default)]
|
||
pub password: String,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[serde(default)]
|
||
pub ssl: bool,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub driver_profile: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct DuplicateConnectionRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Name for the copied connection")]
|
||
pub new_name: String,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct RemoveConnectionRequest {
|
||
#[schemars(description = "Name of the DBX connection when connection_id is not provided")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub connection_name: Option<String>,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub connection_id: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ExecuteRedisCommandRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Redis logical database number. Use this argument instead of the SELECT command.")]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub db: Option<u32>,
|
||
#[schemars(description = "Redis command to execute, for example GET mykey or INFO")]
|
||
pub command: String,
|
||
}
|
||
|
||
#[derive(Debug, Default, serde::Serialize, Deserialize, schemars::JsonSchema)]
|
||
#[serde(rename_all = "lowercase")]
|
||
pub enum PeekStartPosition {
|
||
#[default]
|
||
Latest,
|
||
Earliest,
|
||
Offset,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct PeekMessagesRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Kafka topic name")]
|
||
pub topic: String,
|
||
#[schemars(description = "Number of messages, 1 to 100 (default 20)", extend("type" = "integer"))]
|
||
pub count: Option<u32>,
|
||
#[serde(default)]
|
||
#[schemars(description = "Read latest messages (default), earliest messages, or from an offset")]
|
||
pub start_position: PeekStartPosition,
|
||
#[schemars(description = "Non-negative partition; omit to read across partitions", extend("type" = "integer"))]
|
||
pub partition: Option<i32>,
|
||
#[schemars(description = "Non-negative offset, required only for start_position=offset", extend("type" = "integer"))]
|
||
pub offset: Option<i64>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct SendMessageRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(description = "Message queue topic name")]
|
||
pub topic: String,
|
||
#[schemars(description = "Message payload encoded as standard base64")]
|
||
pub payload_base64: String,
|
||
#[serde(default)]
|
||
#[schemars(description = "Optional message key used for partitioning")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub key: Option<String>,
|
||
#[serde(default)]
|
||
#[schemars(description = "Optional UTF-8 text preview of the payload")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub payload_text: Option<String>,
|
||
#[serde(default)]
|
||
#[schemars(description = "Optional message headers")]
|
||
pub headers: std::collections::HashMap<String, String>,
|
||
#[serde(default)]
|
||
#[schemars(description = "Optional target partition")]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub partition: Option<i32>,
|
||
#[serde(default)]
|
||
#[schemars(description = "RabbitMQ exchange name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub exchange: Option<String>,
|
||
#[serde(default)]
|
||
#[schemars(description = "RabbitMQ routing key")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub routing_key: Option<String>,
|
||
#[serde(default)]
|
||
#[schemars(description = "RabbitMQ virtual-host namespace")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub namespace: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct SchemaContextRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub schema: Option<String>,
|
||
#[schemars(description = "Specific table names to include")]
|
||
#[schemars(extend("type" = "array"))]
|
||
pub tables: Option<Vec<String>>,
|
||
#[schemars(description = "Maximum number of tables to include, from 1 to 20")]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub max_tables: Option<usize>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct OpenTableRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
pub table: String,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub schema: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ExecuteAndShowRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
pub sql: String,
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Default, Deserialize, schemars::JsonSchema)]
|
||
pub struct CellWindowArgs {
|
||
#[schemars(
|
||
description = "Start character offset for every string cell (default 0, max 1000000). Use the next offset reported by a truncated result to slide through a long value; narrow the query to the target row and column first."
|
||
)]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub cell_char_offset: Option<u64>,
|
||
#[schemars(
|
||
description = "Maximum characters returned per string cell (default 200, max 4000). Increase only for an explicit long-value expansion."
|
||
)]
|
||
#[schemars(extend("type" = "integer"))]
|
||
pub cell_char_limit: Option<u64>,
|
||
}
|
||
|
||
impl CellWindowArgs {
|
||
fn to_query_window(&self) -> QueryCellWindow {
|
||
QueryCellWindow::from_options(self.cell_char_offset, self.cell_char_limit)
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct ExecuteBatchQueryRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
/// Per-cell character window for every rendered statement. Flattened from
|
||
/// `CellWindowArgs` so the batch tool accepts the same `cell_char_offset` /
|
||
/// `cell_char_limit` arguments as `dbx_execute_query` instead of silently
|
||
/// ignoring them (#9865).
|
||
#[serde(flatten)]
|
||
pub cell_window: CellWindowArgs,
|
||
#[schemars(description = "Database name")]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(
|
||
description = "SQL script containing one or more statements. Statements are split using the database-dialect-aware splitter, so semicolons inside strings, comments, and stored procedures are handled."
|
||
)]
|
||
pub sql: String,
|
||
#[schemars(
|
||
description = "Session ID from dbx_open_session. When set, every statement runs on the session's pinned connection, preserving USE/SET, temporary tables and other session state across statements in the script and across calls."
|
||
)]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub session_id: Option<String>,
|
||
#[schemars(
|
||
description = "When true, execution continues after a statement error instead of stopping at the first failure. Connection-level failures always stop the batch. Default false (stop at first failure)."
|
||
)]
|
||
#[schemars(extend("type" = "boolean"))]
|
||
pub continue_on_error: Option<bool>,
|
||
#[schemars(
|
||
description = "When true and the script has more than one statement, all statements run inside one transaction (BEGIN … COMMIT) so the whole batch succeeds or rolls back, and the call returns a single merged result. For a single-statement script the option is ignored and the statement runs as normal auto-commit. Backends that cannot provide a rollbackable transaction reject this option. Cannot be combined with session_id or continue_on_error. Rejected for MySQL-family DDL scripts because DDL implicitly commits and cannot be rolled back. Default is auto-commit for each statement."
|
||
)]
|
||
#[schemars(extend("type" = "boolean"))]
|
||
pub use_transaction: Option<bool>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct SalesforceIdentityRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct SalesforcePrepareWriteRequest {
|
||
#[serde(flatten)]
|
||
pub selector: ConnectionSelector,
|
||
#[schemars(
|
||
description = "Database name. Salesforce has no databases, so omit this unless DBX MCP settings scope the connection."
|
||
)]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub database: Option<String>,
|
||
#[schemars(description = "Write operation: \"insert\", \"update\" or \"delete\". One record per call.")]
|
||
pub op: String,
|
||
#[schemars(
|
||
description = "Salesforce object API name, e.g. \"Account\", \"Contact\" or a custom object such as \"Invoice__c\"."
|
||
)]
|
||
pub object: String,
|
||
#[schemars(
|
||
description = "Record Id of the row to change. Required for update and delete; omit for insert, where Salesforce assigns it."
|
||
)]
|
||
#[schemars(extend("type" = "string"))]
|
||
pub id: Option<String>,
|
||
#[schemars(
|
||
description = "Field API name to value map, e.g. {\"Name\": \"Acme\", \"AnnualRevenue\": 1200}. Required and non-empty for insert and update; omit for delete. Never include \"Id\"."
|
||
)]
|
||
#[schemars(extend("type" = "object"))]
|
||
pub fields: Option<serde_json::Value>,
|
||
}
|
||
|
||
#[derive(Debug, Deserialize, schemars::JsonSchema)]
|
||
pub struct SalesforceApplyWriteRequest {
|
||
#[schemars(
|
||
description = "The confirm_token returned by dbx_salesforce_prepare_write. Single-use, and valid only for the exact write that was summarized."
|
||
)]
|
||
pub confirm_token: String,
|
||
}
|
||
|
||
/// How long a prepared Salesforce write stays applicable. Long enough for an
|
||
/// agent to show the summary and for a human to answer, short enough that a
|
||
/// token left in a transcript cannot be replayed much later against a changed
|
||
/// org.
|
||
const SALESFORCE_WRITE_CONFIRM_TTL: Duration = Duration::from_secs(300);
|
||
/// Ceiling on simultaneously pending confirmations. Prepared writes live in
|
||
/// process memory, so an agent that prepares in a loop must not be able to grow
|
||
/// the map without bound.
|
||
const SALESFORCE_WRITE_PENDING_LIMIT: usize = 64;
|
||
/// Field rows shown in a confirmation summary before it collapses the rest into
|
||
/// a count. The full statement is still in `structured_content`.
|
||
const SALESFORCE_SUMMARY_MAX_FIELDS: usize = 40;
|
||
/// Characters of one field value shown in the summary.
|
||
const SALESFORCE_SUMMARY_MAX_VALUE_CHARS: usize = 200;
|
||
/// Header the Salesforce driver routes to its REST DML endpoints. Mirrors
|
||
/// `dbx-sql`'s grid save builder; the driver matches it case-insensitively.
|
||
const SALESFORCE_DML_HEADER: &str = "DBX SALESFORCE DML";
|
||
|
||
/// One write prepared by `dbx_salesforce_prepare_write` and waiting for its
|
||
/// `dbx_salesforce_apply_write` call.
|
||
///
|
||
/// Salesforce has no transactions and no rollback, so this confirmation step is
|
||
/// the only place a write can still be stopped. The statement text is captured
|
||
/// here verbatim and re-sent verbatim: what the summary showed the user is
|
||
/// exactly what the org receives, and an agent cannot widen it in between.
|
||
#[derive(Debug, Clone)]
|
||
struct PendingSalesforceWrite {
|
||
connection_id: String,
|
||
database: String,
|
||
statement: String,
|
||
created_at: Instant,
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
struct PendingSalesforceWrites {
|
||
ttl: Duration,
|
||
entries: tokio::sync::Mutex<HashMap<String, PendingSalesforceWrite>>,
|
||
}
|
||
|
||
impl PendingSalesforceWrites {
|
||
fn new(ttl: Duration) -> Arc<Self> {
|
||
Arc::new(Self { ttl, entries: tokio::sync::Mutex::new(HashMap::new()) })
|
||
}
|
||
|
||
fn ttl_secs(&self) -> u64 {
|
||
self.ttl.as_secs()
|
||
}
|
||
|
||
fn is_expired(&self, pending: &PendingSalesforceWrite) -> bool {
|
||
pending.created_at.elapsed() >= self.ttl
|
||
}
|
||
|
||
/// Store a prepared write under its token, dropping expired entries first
|
||
/// and then the oldest ones until the cap has room.
|
||
async fn insert(&self, token: String, pending: PendingSalesforceWrite) {
|
||
let mut entries = self.entries.lock().await;
|
||
entries.retain(|_, entry| !self.is_expired(entry));
|
||
while entries.len() >= SALESFORCE_WRITE_PENDING_LIMIT {
|
||
let Some(oldest) = entries.iter().min_by_key(|(_, entry)| entry.created_at).map(|(token, _)| token.clone())
|
||
else {
|
||
break;
|
||
};
|
||
entries.remove(&oldest);
|
||
}
|
||
entries.insert(token, pending);
|
||
}
|
||
|
||
/// Consume a token. Single-use by design: a failed apply, a retry, or a
|
||
/// second call with the same token all have to go back through prepare, so
|
||
/// every write that reaches Salesforce was summarized again first.
|
||
async fn take(&self, token: &str) -> Option<PendingSalesforceWrite> {
|
||
let entry = self.entries.lock().await.remove(token.trim())?;
|
||
(!self.is_expired(&entry)).then_some(entry)
|
||
}
|
||
}
|
||
|
||
// One context per dispatched request; legacy SQL helpers enrich it instead of
|
||
// writing duplicate rows. Direct internal calls retain their existing behavior.
|
||
tokio::task_local! {
|
||
static CALL_HISTORY: std::sync::Mutex<HistoryEntry>;
|
||
}
|
||
|
||
struct CallHistoryGuard {
|
||
backend: Arc<dyn DbxBackend>,
|
||
fallback: Option<HistoryEntry>,
|
||
started: Instant,
|
||
}
|
||
|
||
impl Drop for CallHistoryGuard {
|
||
fn drop(&mut self) {
|
||
if let Some(mut entry) = self.fallback.take() {
|
||
entry.execution_time_ms = self.started.elapsed().as_millis();
|
||
entry.error = Some("MCP request cancelled or interrupted".into());
|
||
let backend = self.backend.clone();
|
||
// rmcp may drop the handler future on cancellation. Persist outside
|
||
// that future so the interruption still has an audit record.
|
||
if let Ok(runtime) = tokio::runtime::Handle::try_current() {
|
||
runtime.spawn(async move {
|
||
if let Err(error) = backend.save_history_entry(&entry).await {
|
||
log::warn!("failed to save interrupted MCP history: {error}");
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn history_request(value: &serde_json::Value, depth: usize) -> serde_json::Value {
|
||
use serde_json::Value;
|
||
if depth > 8 {
|
||
return json!("[depth limit]");
|
||
}
|
||
match value {
|
||
Value::Object(fields) => Value::Object(
|
||
fields
|
||
.iter()
|
||
.take(64)
|
||
.map(|(key, value)| {
|
||
let lower = key.to_ascii_lowercase();
|
||
let secret = [
|
||
"password",
|
||
"passwd",
|
||
"secret",
|
||
"token",
|
||
"credential",
|
||
"authorization",
|
||
"private_key",
|
||
"apikey",
|
||
"api_key",
|
||
"connection_string",
|
||
"url",
|
||
"dsn",
|
||
]
|
||
.iter()
|
||
.any(|part| lower.contains(part));
|
||
(
|
||
key.chars().take(128).collect(),
|
||
if secret { json!("[redacted]") } else { history_request(value, depth + 1) },
|
||
)
|
||
})
|
||
.collect(),
|
||
),
|
||
Value::Array(values) => {
|
||
Value::Array(values.iter().take(16).map(|value| history_request(value, depth + 1)).collect())
|
||
}
|
||
Value::String(value) => json!(value.chars().take(1024).collect::<String>()),
|
||
value => value.clone(),
|
||
}
|
||
}
|
||
|
||
fn bounded_history_request(value: &serde_json::Value) -> String {
|
||
let sanitized = history_request(value, 0).to_string();
|
||
if sanitized.len() > 16 * 1024 {
|
||
json!({"truncated": true, "summary": "Request exceeds history size limit"}).to_string()
|
||
} else {
|
||
sanitized
|
||
}
|
||
}
|
||
|
||
// Response payloads need their own sanitizer: request summaries intentionally
|
||
// shorten strings and arrays, which would silently discard query results.
|
||
fn history_response(value: &serde_json::Value, depth: usize) -> serde_json::Value {
|
||
use serde_json::Value;
|
||
if depth > 32 {
|
||
return json!({"truncated": true, "reason": "depth limit"});
|
||
}
|
||
match value {
|
||
Value::Object(fields) => Value::Object(
|
||
fields
|
||
.iter()
|
||
.map(|(key, value)| {
|
||
let lower = key.to_ascii_lowercase();
|
||
let secret = [
|
||
"password",
|
||
"passwd",
|
||
"secret",
|
||
"token",
|
||
"credential",
|
||
"authorization",
|
||
"private_key",
|
||
"apikey",
|
||
"api_key",
|
||
"connection_string",
|
||
"url",
|
||
"dsn",
|
||
]
|
||
.iter()
|
||
.any(|part| lower.contains(part));
|
||
let binary = key == "data"
|
||
&& fields
|
||
.get("type")
|
||
.and_then(Value::as_str)
|
||
.is_some_and(|kind| kind == "image" || kind == "audio")
|
||
|| key == "blob";
|
||
(
|
||
key.clone(),
|
||
if secret || binary { json!("[redacted]") } else { history_response(value, depth + 1) },
|
||
)
|
||
})
|
||
.collect(),
|
||
),
|
||
Value::Array(values) => Value::Array(values.iter().map(|value| history_response(value, depth + 1)).collect()),
|
||
Value::String(text) => {
|
||
// MCP text blocks often contain JSON encoded inside a string.
|
||
// Sanitize that JSON too, while preserving the text-block shape.
|
||
if let Ok(parsed) = serde_json::from_str::<Value>(text) {
|
||
if parsed.is_object() || parsed.is_array() {
|
||
return json!(history_response(&parsed, depth + 1).to_string());
|
||
}
|
||
}
|
||
value.clone()
|
||
}
|
||
_ => value.clone(),
|
||
}
|
||
}
|
||
|
||
fn bounded_history_response<T: serde::Serialize>(value: &T) -> String {
|
||
let value = serde_json::to_value(value).unwrap_or_else(|_| json!({"serialization_error": true}));
|
||
let sanitized = history_response(&value, 0).to_string();
|
||
if sanitized.len() > 64 * 1024 {
|
||
// A short preview leaves room for JSON escaping and metadata.
|
||
json!({"truncated": true, "summary": "Response exceeds 64 KiB history size limit", "original_bytes": sanitized.len(), "preview": sanitized.chars().take(4096).collect::<String>()}).to_string()
|
||
} else {
|
||
sanitized
|
||
}
|
||
}
|
||
|
||
#[derive(Clone)]
|
||
pub struct DbxMcpServer {
|
||
backend: Arc<dyn DbxBackend>,
|
||
scope: McpScope,
|
||
plugin_tools_mode: PluginToolsMode,
|
||
sessions: Arc<McpSessionStore>,
|
||
pending_salesforce_writes: Arc<PendingSalesforceWrites>,
|
||
tool_router: ToolRouter<Self>,
|
||
}
|
||
|
||
/// How plugin tools appear on the external server (`DBX_MCP_PLUGIN_TOOLS`):
|
||
/// `flat` lists every plugin tool in `tools/list` (default, compatible),
|
||
/// `lazy` exposes only the `dbx_plugin_*` meta tools so schemas enter the
|
||
/// context on demand, `both` advertises both views.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||
pub enum PluginToolsMode {
|
||
#[default]
|
||
Flat,
|
||
Lazy,
|
||
Both,
|
||
}
|
||
|
||
impl PluginToolsMode {
|
||
pub fn from_env() -> Self {
|
||
match std::env::var("DBX_MCP_PLUGIN_TOOLS").ok().as_deref().map(str::trim) {
|
||
Some(value) if value.eq_ignore_ascii_case("lazy") => Self::Lazy,
|
||
Some(value) if value.eq_ignore_ascii_case("both") => Self::Both,
|
||
Some(value) if value.eq_ignore_ascii_case("flat") => Self::Flat,
|
||
_ => Self::default(),
|
||
}
|
||
}
|
||
|
||
pub fn advertise_flat(&self) -> bool {
|
||
matches!(self, Self::Flat | Self::Both)
|
||
}
|
||
|
||
pub fn advertise_meta(&self) -> bool {
|
||
matches!(self, Self::Lazy | Self::Both)
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug, Default)]
|
||
pub struct McpScope {
|
||
pub connection_ids: Vec<String>,
|
||
pub connection_name: Option<String>,
|
||
pub database: Option<String>,
|
||
pub schema: Option<String>,
|
||
}
|
||
|
||
struct ResolvedConnection {
|
||
connection: dbx_core::models::connection::ConnectionConfig,
|
||
policy: McpGlobalPolicy,
|
||
database_scope: DatabaseScope,
|
||
group_ids: Vec<String>,
|
||
}
|
||
|
||
struct SessionCleanupResult {
|
||
status: Option<TransactionStatus>,
|
||
error: Option<String>,
|
||
}
|
||
|
||
#[derive(Clone, Debug)]
|
||
enum DatabaseScope {
|
||
All,
|
||
Selected(Vec<String>),
|
||
None,
|
||
}
|
||
|
||
impl McpScope {
|
||
pub fn from_env() -> Self {
|
||
let mut connection_ids = scoped_connection_ids(std::env::var("DBX_MCP_SCOPE_CONNECTION_IDS").ok().as_deref());
|
||
if connection_ids.is_empty() {
|
||
if let Some(connection_id) = non_empty_env("DBX_MCP_SCOPE_CONNECTION_ID") {
|
||
connection_ids.push(connection_id);
|
||
}
|
||
}
|
||
Self {
|
||
connection_ids,
|
||
connection_name: non_empty_env("DBX_MCP_SCOPE_CONNECTION_NAME"),
|
||
database: non_empty_env("DBX_MCP_SCOPE_DATABASE"),
|
||
schema: non_empty_env("DBX_MCP_SCOPE_SCHEMA"),
|
||
}
|
||
}
|
||
|
||
fn enabled(&self) -> bool {
|
||
self.connection_scope_enabled() || self.database.is_some() || self.schema.is_some()
|
||
}
|
||
|
||
fn connection_scope_enabled(&self) -> bool {
|
||
!self.connection_ids.is_empty() || self.connection_name.is_some()
|
||
}
|
||
|
||
fn matches(&self, connection: &dbx_core::models::connection::ConnectionConfig) -> bool {
|
||
if !self.connection_ids.is_empty() {
|
||
return self.connection_ids.iter().any(|id| id == &connection.id);
|
||
}
|
||
self.connection_name.as_deref() == Some(connection.name.as_str())
|
||
}
|
||
}
|
||
|
||
impl DbxMcpServer {
|
||
pub fn new(backend: Arc<dyn DbxBackend>) -> Self {
|
||
Self::with_runtime_options(backend, McpScope::from_env(), std::env::var_os("DBX_WEB_URL").is_some())
|
||
}
|
||
|
||
pub fn with_runtime_options(backend: Arc<dyn DbxBackend>, scope: McpScope, web_mode: bool) -> Self {
|
||
Self::with_plugin_tools_mode(backend, scope, web_mode, PluginToolsMode::from_env())
|
||
}
|
||
|
||
/// Same as [`with_runtime_options`], but pins the plugin-tools mode —
|
||
/// used by tests so parallel cases cannot observe each other's env.
|
||
pub fn with_plugin_tools_mode(
|
||
backend: Arc<dyn DbxBackend>,
|
||
scope: McpScope,
|
||
web_mode: bool,
|
||
plugin_tools_mode: PluginToolsMode,
|
||
) -> Self {
|
||
// The workspace enables more than one rustls crypto feature through
|
||
// transitive dependencies. Native MCP runs outside the desktop/web
|
||
// startup paths, so select the same provider before any TLS tool call.
|
||
let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
|
||
let mut tool_router = Self::tool_router();
|
||
if scope.enabled() {
|
||
tool_router.disable_route("dbx_add_connection");
|
||
tool_router.disable_route("dbx_duplicate_connection");
|
||
tool_router.disable_route("dbx_remove_connection");
|
||
}
|
||
// Desktop UI bridge operations are intentionally unavailable remotely and in scoped AI sessions.
|
||
if web_mode || scope.enabled() {
|
||
tool_router.disable_route("dbx_open_table");
|
||
tool_router.disable_route("dbx_execute_and_show");
|
||
}
|
||
#[cfg(not(feature = "mq-admin"))]
|
||
{
|
||
tool_router.disable_route("dbx_send_message");
|
||
tool_router.disable_route("dbx_peek_messages");
|
||
}
|
||
// In `flat` mode plugin tools are merged directly into tools/list and
|
||
// the lazy meta tools would only duplicate them; in `lazy`/`both`
|
||
// they stay enabled so clients can discover on demand.
|
||
if !plugin_tools_mode.advertise_meta() {
|
||
tool_router.disable_route("dbx_plugin_list");
|
||
tool_router.disable_route("dbx_plugin_tools");
|
||
tool_router.disable_route("dbx_plugin_call");
|
||
}
|
||
Self {
|
||
backend,
|
||
scope,
|
||
plugin_tools_mode,
|
||
sessions: McpSessionStore::new(),
|
||
pending_salesforce_writes: PendingSalesforceWrites::new(SALESFORCE_WRITE_CONFIRM_TTL),
|
||
tool_router,
|
||
}
|
||
}
|
||
|
||
fn spawn_session_cleanup(&self, session: McpSession) -> tokio::sync::oneshot::Receiver<SessionCleanupResult> {
|
||
let backend = self.backend.clone();
|
||
let sessions = self.sessions.clone();
|
||
let (result_tx, result_rx) = tokio::sync::oneshot::channel();
|
||
tokio::spawn(async move {
|
||
let status = if let Some(owner) = &session.transaction_owner {
|
||
match owner.close().await {
|
||
Ok(status) => Some(status),
|
||
Err(_) => {
|
||
owner.wait_closed().await;
|
||
Some(owner.status())
|
||
}
|
||
}
|
||
} else {
|
||
None
|
||
};
|
||
let close_result = backend
|
||
.close_client_session(&session.connection_id, &session.database, &session.client_session_id)
|
||
.await;
|
||
let error = match close_result {
|
||
Ok(_) => {
|
||
sessions.finish_close(&session.id).await;
|
||
None
|
||
}
|
||
Err(error) if session.transaction_owner.is_none() => {
|
||
sessions.restore_after_failed_close(session).await;
|
||
Some(error)
|
||
}
|
||
Err(error) => {
|
||
sessions.finish_close(&session.id).await;
|
||
Some(error)
|
||
}
|
||
};
|
||
let _ = result_tx.send(SessionCleanupResult { status, error });
|
||
});
|
||
result_rx
|
||
}
|
||
|
||
async fn close_backend_sessions_best_effort(&self, sessions: Vec<McpSession>) {
|
||
let cleanups = sessions.into_iter().map(|session| self.spawn_session_cleanup(session)).collect::<Vec<_>>();
|
||
for cleanup in cleanups {
|
||
let _ = cleanup.await;
|
||
}
|
||
}
|
||
|
||
fn spawn_transaction_session_open(
|
||
&self,
|
||
connection: ConnectionConfig,
|
||
database: String,
|
||
session: McpSession,
|
||
) -> (
|
||
tokio::sync::oneshot::Receiver<Result<Arc<crate::transaction::TransactionOwner>, String>>,
|
||
tokio::sync::oneshot::Sender<()>,
|
||
) {
|
||
let backend = self.backend.clone();
|
||
let sessions = self.sessions.clone();
|
||
let (prepared_tx, prepared_rx) = tokio::sync::oneshot::channel();
|
||
let (ack_tx, ack_rx) = tokio::sync::oneshot::channel();
|
||
tokio::spawn(async move {
|
||
let owner = match backend.open_transaction_owner(&connection, &database, &session.client_session_id).await {
|
||
Ok(owner) => owner,
|
||
Err(error) => {
|
||
sessions.cancel_opening(&session.id).await;
|
||
let _ = backend
|
||
.close_client_session(&session.connection_id, &session.database, &session.client_session_id)
|
||
.await;
|
||
let _ = prepared_tx.send(Err(error));
|
||
return;
|
||
}
|
||
};
|
||
if prepared_tx.send(Ok(owner.clone())).is_err() || ack_rx.await.is_err() {
|
||
sessions.cancel_opening(&session.id).await;
|
||
let _ = owner.close().await;
|
||
owner.wait_closed().await;
|
||
let _ = backend
|
||
.close_client_session(&session.connection_id, &session.database, &session.client_session_id)
|
||
.await;
|
||
}
|
||
});
|
||
(prepared_rx, ack_tx)
|
||
}
|
||
async fn save_mcp_sql_history(
|
||
&self,
|
||
tool_name: &str,
|
||
connection: &ConnectionConfig,
|
||
database: &str,
|
||
sql: &str,
|
||
started_at: Instant,
|
||
success: bool,
|
||
error: Option<String>,
|
||
affected_rows: Option<i64>,
|
||
) {
|
||
let entry = HistoryEntry {
|
||
id: Uuid::new_v4().to_string(),
|
||
connection_id: connection.id.clone(),
|
||
connection_name: connection.name.clone(),
|
||
database: database.to_string(),
|
||
sql: sql.to_string(),
|
||
executed_at: chrono::Utc::now().to_rfc3339(),
|
||
execution_time_ms: started_at.elapsed().as_millis(),
|
||
success,
|
||
error,
|
||
activity_kind: mcp_sql_activity_kind(sql, connection.db_type).to_string(),
|
||
operation: mcp_sql_operation(sql, connection.db_type),
|
||
target: String::new(),
|
||
affected_rows,
|
||
rollback_sql: None,
|
||
details_json: Some(r#"{"source":"mcp"}"#.to_string()),
|
||
source: "mcp".to_string(),
|
||
mcp_tool_name: Some(tool_name.to_string()),
|
||
mcp_request_json: None,
|
||
mcp_response_json: None,
|
||
mcp_session_id: None,
|
||
};
|
||
if CALL_HISTORY
|
||
.try_with(|current| {
|
||
let mut current = current.lock().unwrap();
|
||
current.connection_id = entry.connection_id.clone();
|
||
current.connection_name = entry.connection_name.clone();
|
||
current.database = entry.database.clone();
|
||
current.sql = entry.sql.clone();
|
||
current.activity_kind = entry.activity_kind.clone();
|
||
current.operation = entry.operation.clone();
|
||
current.affected_rows = entry.affected_rows;
|
||
})
|
||
.is_ok()
|
||
{
|
||
return;
|
||
}
|
||
if let Err(error) = self.backend.save_history_entry(&entry).await {
|
||
log::warn!("failed to save MCP SQL history for connection {}: {error}", connection.id);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tool_router]
|
||
impl DbxMcpServer {
|
||
#[tool(
|
||
name = "dbx_plugin_list",
|
||
description = "List DBX plugins that contribute MCP tools. Returns each plugin's id, name, tool count, and the number of connections available for its tools. Use dbx_plugin_tools with a plugin id to inspect its tools; call them through dbx_plugin_call."
|
||
)]
|
||
async fn plugin_list(&self, Parameters(request): Parameters<PluginListRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_plugin_list").await {
|
||
return error;
|
||
}
|
||
let (rows, note) = match self.plugin_tool_catalog().await {
|
||
Ok(catalog) => catalog,
|
||
Err(error) => return error,
|
||
};
|
||
let filter = request.filter.as_deref().map(str::trim).filter(|value| !value.is_empty());
|
||
let mut lines = Vec::new();
|
||
for (plugin_id, plugin_name, tool_count, connection_count) in &rows {
|
||
let matches = |haystack: &str| -> bool {
|
||
filter.is_none_or(|needle| haystack.to_ascii_lowercase().contains(&needle.to_ascii_lowercase()))
|
||
};
|
||
if filter.is_some() && !matches(plugin_id) && !matches(plugin_name) {
|
||
continue;
|
||
}
|
||
lines.push(format!(
|
||
"- {plugin_id} · {plugin_name} · {tool_count} tool(s) · {connection_count} allowed connection(s)"
|
||
));
|
||
}
|
||
if lines.is_empty() {
|
||
return text(match (filter, ¬e) {
|
||
(Some(_), _) => "No DBX plugin matches the filter.".to_string(),
|
||
(None, Some(note)) => note.clone(),
|
||
(None, None) => "No DBX plugin contributes MCP tools.".to_string(),
|
||
});
|
||
}
|
||
text(format!(
|
||
"{} plugin(s) contribute MCP tools:\n{}\n\nInspect tools with dbx_plugin_tools (plugin_id), call them with dbx_plugin_call.{}",
|
||
lines.len(),
|
||
lines.join("\n"),
|
||
note.as_ref().map(|note| format!("\n{note}")).unwrap_or_default()
|
||
))
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_plugin_tools",
|
||
description = "List the MCP tools of one DBX plugin by its plugin id (from dbx_plugin_list). Returns each tool's name, description, arguments schema, read-only hint, and whether a connection must be selected. Call the tool through dbx_plugin_call."
|
||
)]
|
||
async fn plugin_tools(&self, Parameters(request): Parameters<PluginToolsRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_plugin_tools").await {
|
||
return error;
|
||
}
|
||
let plugin_id = request.plugin_id.trim();
|
||
if plugin_id.is_empty() {
|
||
return tool_error("PLUGIN_ID_REQUIRED", "plugin_id is required; use dbx_plugin_list to find plugin ids.");
|
||
}
|
||
let providers = match self.backend.list_plugin_mcp_tools().await {
|
||
Ok(providers) => providers,
|
||
Err(error) => return backend_tool_error("DBX_TOOL_ERROR", error),
|
||
};
|
||
let entries = crate::plugin_tools::build_catalog(&providers);
|
||
// Disclose only what the flat surface would advertise: the per-tool
|
||
// allowlist filters the listing just like `tools/list`, with a count
|
||
// of hidden tools so the caller knows the view is narrowed.
|
||
let policy = self.load_policy().await.ok();
|
||
let (owned, hidden) = {
|
||
let owned: Vec<&crate::plugin_tools::PluginToolEntry> = entries
|
||
.iter()
|
||
.filter(|entry| {
|
||
entry.plugin_id == plugin_id
|
||
&& policy.as_ref().is_none_or(|policy| policy_allows_tool(policy, &entry.exposed_name))
|
||
})
|
||
.collect();
|
||
let total = entries.iter().filter(|entry| entry.plugin_id == plugin_id).count();
|
||
let hidden = total - owned.len();
|
||
(owned, hidden)
|
||
};
|
||
if owned.is_empty() {
|
||
let reason = if hidden > 0 {
|
||
format!("All {hidden} tool(s) of plugin \"{plugin_id}\" are hidden by the DBX MCP tool allowlist.")
|
||
} else {
|
||
format!("Plugin \"{plugin_id}\" does not contribute MCP tools. Use dbx_plugin_list to list plugins.")
|
||
};
|
||
return tool_error("PLUGIN_NOT_FOUND", reason);
|
||
}
|
||
let allowed = match self.allowed_plugin_connections_for(plugin_id).await {
|
||
Ok(allowed) => allowed,
|
||
Err(error) => return error,
|
||
};
|
||
let mut lines = Vec::new();
|
||
for entry in &owned {
|
||
let mut line = format!(
|
||
"### {}\n{}",
|
||
entry.tool.name,
|
||
crate::plugin_tools::external_tool_description(&entry.plugin_name, &entry.tool)
|
||
);
|
||
if entry.tool.read_only {
|
||
line.push_str("\nRead-only.");
|
||
}
|
||
let schema = crate::plugin_tools::external_tool_parameters(&entry.tool.input_schema, &allowed);
|
||
line.push_str(&format!("\nArguments schema: {schema}"));
|
||
if entry.injects_connection_id {
|
||
line.push_str("\nThe host injects the bound connection's id automatically.");
|
||
}
|
||
lines.push(line);
|
||
}
|
||
let connection_note = match allowed.len() {
|
||
0 => "No allowed connection is configured for this plugin; only connection-less tools can run.".to_string(),
|
||
1 => format!("Tools run on connection {} ({}); you may omit dbx_connection.", allowed[0].0, allowed[0].1),
|
||
_ => format!(
|
||
"Pass dbx_connection to choose among: {}",
|
||
allowed.iter().map(|(id, name)| format!("{id} = {name}")).collect::<Vec<_>>().join("; ")
|
||
),
|
||
};
|
||
let hidden_note = (hidden > 0)
|
||
.then(|| format!("\n{} further tool(s) of this plugin are hidden by the DBX MCP tool allowlist.", hidden));
|
||
text(format!(
|
||
"{} tool(s) of plugin {plugin_id}:\n\n{}\n\n{connection_note}\nCall through dbx_plugin_call (plugin_id + tool + arguments).{}",
|
||
owned.len(),
|
||
lines.join("\n\n"),
|
||
hidden_note.unwrap_or_default()
|
||
))
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_plugin_call",
|
||
description = "Call one MCP tool of a DBX plugin by plugin id (from dbx_plugin_list) and tool name (from dbx_plugin_tools). The host binds the connection from DBX settings and generates the credentials payload; pass dbx_connection only when dbx_plugin_tools lists several allowed connections."
|
||
)]
|
||
async fn plugin_call(&self, Parameters(request): Parameters<PluginCallRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_plugin_call").await {
|
||
return error;
|
||
}
|
||
let plugin_id = request.plugin_id.trim();
|
||
if plugin_id.is_empty() {
|
||
return tool_error("PLUGIN_ID_REQUIRED", "plugin_id is required; use dbx_plugin_list to find plugin ids.");
|
||
}
|
||
let tool = request.tool.trim();
|
||
if tool.is_empty() {
|
||
return tool_error(
|
||
"TOOL_NAME_REQUIRED",
|
||
"tool is required; use dbx_plugin_tools to list this plugin's tools.",
|
||
);
|
||
}
|
||
let mut arguments = request.arguments.clone().unwrap_or_else(|| json!({}));
|
||
if !arguments.is_object() {
|
||
return tool_error("INVALID_ARGUMENTS", "arguments must be a JSON object.");
|
||
}
|
||
if let Some(selector) = request.dbx_connection.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
|
||
if let Some(object) = arguments.as_object_mut() {
|
||
object.insert(crate::plugin_tools::PLUGIN_CONNECTION_ARGUMENT.to_string(), json!(selector));
|
||
}
|
||
}
|
||
let dispatched = match self.call_plugin_by_id(plugin_id, tool, arguments).await {
|
||
Ok(result) => result,
|
||
Err(error) => return error,
|
||
};
|
||
self.postprocess_plugin_result(plugin_id, tool, &request.dbx_connection, dispatched).await
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_list_connections",
|
||
description = "List database connections configured in DBX. Returns connection IDs, names, group paths, database types, endpoints, and selected databases."
|
||
)]
|
||
async fn list_connections(
|
||
&self,
|
||
Parameters(ListConnectionsRequest {}): Parameters<ListConnectionsRequest>,
|
||
) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_list_connections").await {
|
||
return error;
|
||
}
|
||
match self.load_scoped_connections().await {
|
||
Ok(connections) if connections.is_empty() => text("No connections configured in DBX."),
|
||
Ok(connections) => {
|
||
let group_paths = self.backend.load_connection_group_details().await.unwrap_or_default();
|
||
let rows = connections
|
||
.iter()
|
||
.map(|connection| {
|
||
let mut summary = ConnectionSummary::from(connection);
|
||
summary.group_path =
|
||
group_paths.get(&connection.id).map(|path| path.names.clone()).unwrap_or_default();
|
||
summary
|
||
})
|
||
.collect::<Vec<_>>();
|
||
text(format_connections(&rows))
|
||
}
|
||
Err(error) => backend_tool_error("CONNECTION_LOAD_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_list_databases",
|
||
description = "List database names available through a DBX connection. When the connection has a database allowlist, returns only the databases allowed by DBX MCP settings; use this before listing tables if the connection has no default database."
|
||
)]
|
||
async fn list_databases(&self, Parameters(request): Parameters<ListDatabasesRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_list_databases").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
self.list_databases_for_resolved(&resolved).await
|
||
}
|
||
|
||
#[tool(name = "dbx_list_tables", description = "List tables and views for a database connection")]
|
||
async fn list_tables(&self, Parameters(request): Parameters<ListTablesRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_list_tables").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let schema = match self.resolve_schema(request.schema) {
|
||
Ok(schema) => schema,
|
||
Err(error) => return error,
|
||
};
|
||
match self.backend.list_tables(&resolved.connection, &database, &schema).await {
|
||
Ok(tables) if tables.is_empty() => text("No tables found."),
|
||
Ok(tables) => text(
|
||
tables
|
||
.into_iter()
|
||
.map(|table| {
|
||
let comment = table
|
||
.comment
|
||
.filter(|comment| !comment.is_empty())
|
||
.map(|comment| format!(" -- {comment}"))
|
||
.unwrap_or_default();
|
||
format!("- {} ({}){}", table.name, table.table_type, comment)
|
||
})
|
||
.collect::<Vec<_>>()
|
||
.join("\n"),
|
||
),
|
||
Err(error) => tool_error("TABLE_LIST_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(name = "dbx_describe_table", description = "Get column definitions for a table")]
|
||
async fn describe_table(&self, Parameters(request): Parameters<DescribeTableRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_describe_table").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let schema = match self.resolve_schema(request.schema) {
|
||
Ok(schema) => schema,
|
||
Err(error) => return error,
|
||
};
|
||
match self.backend.get_columns(&resolved.connection, &database, &schema, &request.table).await {
|
||
Ok(columns) if columns.is_empty() => text("No columns found."),
|
||
Ok(columns) => text(format_columns(&columns)),
|
||
Err(error) => tool_error("TABLE_DESCRIPTION_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(name = "dbx_list_routines", description = "List stored procedures and functions for a database schema")]
|
||
async fn list_routines(&self, Parameters(request): Parameters<ListRoutinesRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_list_routines").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let schema = match self.resolve_schema(request.schema) {
|
||
Ok(schema) => schema,
|
||
Err(error) => return error,
|
||
};
|
||
let routine_types = match request.routine_type.as_deref() {
|
||
None => None,
|
||
Some(kind) => match normalize_routine_type(kind) {
|
||
Ok(kind) => Some(vec![kind]),
|
||
Err(error) => return tool_error("ROUTINE_LIST_ERROR", error),
|
||
},
|
||
};
|
||
match self.backend.list_routines(&resolved.connection, &database, &schema, routine_types.as_deref()).await {
|
||
Ok(routines) if routines.is_empty() => text("No routines found."),
|
||
Ok(routines) => text(format_routines(&routines)),
|
||
Err(error) => tool_error("ROUTINE_LIST_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(name = "dbx_get_routine_source", description = "Get the full source text of a stored procedure or function")]
|
||
async fn get_routine_source(&self, Parameters(request): Parameters<GetRoutineSourceRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_get_routine_source").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let schema = match self.resolve_schema(request.schema) {
|
||
Ok(schema) => schema,
|
||
Err(error) => return error,
|
||
};
|
||
let object_type = match normalize_routine_type(&request.object_type) {
|
||
Ok(kind) => kind,
|
||
Err(error) => return tool_error("ROUTINE_SOURCE_ERROR", error),
|
||
};
|
||
match self
|
||
.backend
|
||
.get_routine_source(
|
||
&resolved.connection,
|
||
&database,
|
||
&schema,
|
||
&request.name,
|
||
&object_type,
|
||
request.signature.as_deref(),
|
||
)
|
||
.await
|
||
{
|
||
Ok(source) if source.source.trim().is_empty() => text("Routine source is empty."),
|
||
Ok(source) => text(source.source),
|
||
Err(error) => tool_error("ROUTINE_SOURCE_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_execute_query",
|
||
description = "Execute a SQL query on a database connection (default 100 rows; pass max_rows to return up to 1000 rows; larger values are clamped; MongoDB shell commands and multi-statement scripts routed through the batch executor stay at 100 rows). For backwards compatibility, multi-statement scripts and stored-procedure scripts are routed through the dialect-aware batch executor."
|
||
)]
|
||
async fn execute_query_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<ExecuteQueryRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.execute_query(parameters)).await
|
||
}
|
||
|
||
async fn execute_query(&self, Parameters(request): Parameters<ExecuteQueryRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_execute_query").await {
|
||
return error;
|
||
}
|
||
let explicit_cell_window = (request.cell_char_offset.is_some() || request.cell_char_limit.is_some())
|
||
.then(|| QueryCellWindow::from_options(request.cell_char_offset, request.cell_char_limit));
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type == dbx_core::models::connection::DatabaseType::Redis {
|
||
return tool_error(
|
||
"REDIS_COMMAND_REQUIRED",
|
||
"Redis connections do not accept SQL through dbx_execute_query. Use dbx_execute_redis_command.",
|
||
);
|
||
}
|
||
if connection.db_type == DatabaseType::Salesforce
|
||
&& !is_database_discovery_sql(&request.sql)
|
||
&& is_write_sql_for_database(&request.sql, DatabaseType::Salesforce)
|
||
{
|
||
// SOQL has no write verbs, so anything the Salesforce classifier reads
|
||
// as a write here is a `DBX SALESFORCE DML` pseudo-command. Letting it
|
||
// ride along as a "query" would bypass both the connection's DML opt-in
|
||
// and the two-step confirmation, and Salesforce cannot roll it back.
|
||
// `SHOW DATABASES` is the one non-SOQL probe exempted: SOQL rules read
|
||
// every non-SELECT as opaque, and the discovery path below answers it
|
||
// with the "one org is one scope" explanation instead.
|
||
return tool_error(
|
||
"SALESFORCE_DML_REQUIRES_CONFIRMATION",
|
||
"Salesforce writes cannot run through dbx_execute_query. Call dbx_salesforce_prepare_write, show its summary to the user, then dbx_salesforce_apply_write with the confirm_token it returns.",
|
||
);
|
||
}
|
||
if sql_requires_batch_execution(&request.sql, connection.db_type) {
|
||
return self
|
||
.execute_batch_request(ExecuteBatchQueryRequest {
|
||
selector: ConnectionSelector { connection_id: Some(connection.id.clone()), connection_name: None },
|
||
cell_window: CellWindowArgs {
|
||
cell_char_offset: request.cell_char_offset,
|
||
cell_char_limit: request.cell_char_limit,
|
||
},
|
||
database: request.database.clone(),
|
||
sql: request.sql.clone(),
|
||
session_id: request.session_id.clone(),
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
})
|
||
.await;
|
||
}
|
||
// Database discovery does not require a default database. In a
|
||
// narrowed MCP scope it must never reveal names outside the allowlist,
|
||
// so serve it directly from the scoped discovery path instead of
|
||
// passing SHOW DATABASES to the database driver.
|
||
if is_database_discovery_sql(&request.sql) {
|
||
return self.list_databases_for_resolved(&resolved).await;
|
||
}
|
||
// Resolve the session before the database so its connection/database
|
||
// binding is enforced on every stateful query.
|
||
let session = match request.session_id.as_deref().map(str::trim).filter(|id| !id.is_empty()) {
|
||
Some(session_id) => {
|
||
let (session, expired) = self.sessions.resolve(session_id).await.into_parts();
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
match session {
|
||
Some(session) if session.connection_id == connection.id => Some(session),
|
||
Some(_) => {
|
||
return tool_error(
|
||
"SESSION_CONNECTION_MISMATCH",
|
||
format!("Session \"{session_id}\" is bound to a different connection."),
|
||
);
|
||
}
|
||
None => {
|
||
return tool_error(
|
||
"SESSION_NOT_FOUND",
|
||
format!(
|
||
"Session \"{session_id}\" not found or expired. Open a new one with dbx_open_session."
|
||
),
|
||
);
|
||
}
|
||
}
|
||
}
|
||
None => None,
|
||
};
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let policy =
|
||
effective_policy_for_database_with_groups(&resolved.policy, &resolved.group_ids, connection, &database);
|
||
if let Some(session) = &session {
|
||
if session.database != database {
|
||
return tool_error(
|
||
"SESSION_DATABASE_MISMATCH",
|
||
format!(
|
||
"Session \"{}\" is bound to database \"{}\", not \"{database}\".",
|
||
session.id, session.database
|
||
),
|
||
);
|
||
}
|
||
}
|
||
if connection.db_type == DatabaseType::MongoDb {
|
||
// max_rows is deliberately ignored here: MongoDB shell commands
|
||
// always return at most 100 rows, and this branch returns before the
|
||
// arguments below are built.
|
||
let command = match validate_mongo_command_with_groups(
|
||
connection,
|
||
&resolved.policy,
|
||
&resolved.group_ids,
|
||
&resolved.database_scope,
|
||
&database,
|
||
&request.sql,
|
||
) {
|
||
Ok(command) => command,
|
||
Err(error) => return error,
|
||
};
|
||
return match self.backend.execute_mongo_command(connection, &database, &command).await {
|
||
Ok(result) => match explicit_cell_window {
|
||
Some(window) => match format_query_result_as_text(&result, 100, window) {
|
||
Ok(output) => text(output),
|
||
Err(error) => backend_tool_error("QUERY_FORMAT_ERROR", error),
|
||
},
|
||
None => text(format_query_result(&result, 100)),
|
||
},
|
||
Err(error) => backend_tool_error("QUERY_ERROR", error),
|
||
};
|
||
}
|
||
// A pinned session makes USE/SET CATALOG meaningful, so database
|
||
// switching is allowed — unless a hard database scope is configured,
|
||
// which a USE statement could otherwise escape.
|
||
let allow_database_switch = session.is_some() && self.scope.database.is_none();
|
||
if connection.db_type != DatabaseType::MongoDb {
|
||
if let Err(error) = ensure_sql_database_scope(&resolved.database_scope, connection, &database, &request.sql)
|
||
{
|
||
return error;
|
||
}
|
||
if let Err(error) =
|
||
ensure_sql_database_execution_scope(&resolved.policy, connection, &database, &request.sql)
|
||
{
|
||
return error;
|
||
}
|
||
}
|
||
let permissions = match validate_sql_policy(connection, &policy, &database, &request.sql, allow_database_switch)
|
||
{
|
||
Ok(permissions) => permissions,
|
||
Err(error) => return error,
|
||
};
|
||
let max_rows = request.max_rows.map(|value| value.clamp(1, MAX_EXECUTE_QUERY_ROWS as u64)).unwrap_or(100);
|
||
if let Some(session) = session.as_ref().filter(|session| session.transaction_owner.is_some()) {
|
||
if let Err(error) = validate_transaction_sql_shape(&request.sql) {
|
||
return tool_error("TRANSACTION_SQL_BLOCKED", error);
|
||
}
|
||
if let Some(reason) = confirmed_batch_sql_block_reason(
|
||
&request.sql,
|
||
connection.db_type,
|
||
permissions.confirmed_write_sql.as_deref(),
|
||
) {
|
||
return tool_error("SQL_BLOCKED", reason);
|
||
}
|
||
let owner = session.transaction_owner.as_ref().expect("filtered transaction owner").clone();
|
||
let lease = match owner.acquire().await {
|
||
Ok(lease) => lease,
|
||
Err(error) => return transaction_failure_result(&session.id, error),
|
||
};
|
||
|
||
// The lease is the queue boundary. Re-read every mutable policy and
|
||
// connection binding after waiting so queued work cannot outrun a
|
||
// revocation or configuration refresh.
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_execute_query").await {
|
||
return error;
|
||
}
|
||
let refreshed = match self
|
||
.resolve_connection(&ConnectionSelector {
|
||
connection_id: Some(session.connection_id.clone()),
|
||
connection_name: None,
|
||
})
|
||
.await
|
||
{
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
if !transaction_connection_supported(&refreshed.connection)
|
||
|| refreshed.connection.id != session.connection_id
|
||
{
|
||
return tool_error("TRANSACTION_UNSUPPORTED", "The bound native MySQL connection changed.");
|
||
}
|
||
if let Err(error) = ensure_sql_database_scope(
|
||
&refreshed.database_scope,
|
||
&refreshed.connection,
|
||
&session.database,
|
||
&request.sql,
|
||
) {
|
||
return error;
|
||
}
|
||
if let Err(error) = ensure_sql_database_execution_scope(
|
||
&refreshed.policy,
|
||
&refreshed.connection,
|
||
&session.database,
|
||
&request.sql,
|
||
) {
|
||
return error;
|
||
}
|
||
let refreshed_policy = effective_policy_for_database_with_groups(
|
||
&refreshed.policy,
|
||
&refreshed.group_ids,
|
||
&refreshed.connection,
|
||
&session.database,
|
||
);
|
||
let refreshed_permissions = match validate_sql_policy(
|
||
&refreshed.connection,
|
||
&refreshed_policy,
|
||
&session.database,
|
||
&request.sql,
|
||
false,
|
||
) {
|
||
Ok(permissions) => permissions,
|
||
Err(error) => return error,
|
||
};
|
||
if let Err(error) = validate_transaction_sql_shape(&request.sql) {
|
||
return tool_error("TRANSACTION_SQL_BLOCKED", error);
|
||
}
|
||
if let Some(reason) = confirmed_batch_sql_block_reason(
|
||
&request.sql,
|
||
refreshed.connection.db_type,
|
||
refreshed_permissions.confirmed_write_sql.as_deref(),
|
||
) {
|
||
return tool_error("SQL_BLOCKED", reason);
|
||
}
|
||
|
||
let history_sql = request.sql.clone();
|
||
let started_at = Instant::now();
|
||
return match lease.query(request.sql, Some(max_rows as usize)).await {
|
||
Ok(execution) => {
|
||
let rendered = explicit_cell_window
|
||
.and_then(|window| {
|
||
format_query_result_as_text(&execution.result, max_rows as usize, window).ok()
|
||
})
|
||
.unwrap_or_else(|| format_query_result(&execution.result, max_rows as usize));
|
||
self.save_mcp_sql_history(
|
||
"dbx_execute_query",
|
||
&refreshed.connection,
|
||
&session.database,
|
||
&history_sql,
|
||
started_at,
|
||
true,
|
||
None,
|
||
Some(execution.result.affected_rows as i64),
|
||
)
|
||
.await;
|
||
transaction_success_result(&session.id, &rendered, execution)
|
||
}
|
||
Err(error) => {
|
||
self.save_mcp_sql_history(
|
||
"dbx_execute_query",
|
||
&refreshed.connection,
|
||
&session.database,
|
||
&history_sql,
|
||
started_at,
|
||
false,
|
||
Some(error.message.clone()),
|
||
None,
|
||
)
|
||
.await;
|
||
transaction_failure_result(&session.id, error)
|
||
}
|
||
};
|
||
}
|
||
let history_sql = request.sql.clone();
|
||
let mut arguments = json!({ "sql": request.sql, "limit": max_rows });
|
||
if let Some(schema) = self.scope.schema.as_deref() {
|
||
arguments["schema"] = json!(schema);
|
||
}
|
||
if let Some(session) = &session {
|
||
arguments["client_session_id"] = json!(session.client_session_id);
|
||
}
|
||
if let Some(offset) = request.cell_char_offset {
|
||
arguments["cell_char_offset"] = json!(offset);
|
||
}
|
||
if let Some(limit) = request.cell_char_limit {
|
||
arguments["cell_char_limit"] = json!(limit);
|
||
}
|
||
// Surface the global MCP query timeout as a per-query argument. It is
|
||
// re-read on every tool call, so a settings-page change takes effect on
|
||
// the next MCP query with no client-config regeneration. A future
|
||
// per-call `timeout_secs` tool parameter can slot in above this by not
|
||
// being clobbered when set by the model.
|
||
if let Some(secs) = resolved.policy.query_timeout_secs {
|
||
arguments["timeout_secs"] = json!(secs);
|
||
}
|
||
let started_at = Instant::now();
|
||
let result =
|
||
self.backend.execute_agent_tool(connection, &database, "execute_query", arguments, permissions).await;
|
||
let success = !result.is_error;
|
||
let error = result.is_error.then(|| result.content.trim_start_matches("Error: ").to_string());
|
||
self.save_mcp_sql_history(
|
||
"dbx_execute_query",
|
||
connection,
|
||
&database,
|
||
&history_sql,
|
||
started_at,
|
||
success,
|
||
error,
|
||
None,
|
||
)
|
||
.await;
|
||
agent_result(result)
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_execute_batch",
|
||
description = "Execute a SQL script containing multiple statements in one call and return a result per statement. Statements are split with a database-dialect-aware parser, so semicolons inside strings, comments and stored procedures are handled. Stops at the first failing statement unless continue_on_error is true. Pass session_id (from dbx_open_session) when statements must share one connection (e.g. temporary tables, USE/SET). Pass cell_char_offset/cell_char_limit to expand long string cells in every statement's result, exactly like dbx_execute_query. When use_transaction is true and the script has multiple statements, the whole script runs in one transaction and the call returns a single merged result instead of one result per statement (single-statement scripts run normally and return that one result); use_transaction cannot be combined with session_id or continue_on_error, and is rejected when the backend cannot provide a rollbackable transaction or for MySQL-family DDL scripts (DDL implicitly commits and cannot be rolled back)."
|
||
)]
|
||
async fn execute_batch_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<ExecuteBatchQueryRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.execute_batch(parameters)).await
|
||
}
|
||
|
||
async fn execute_batch(&self, Parameters(request): Parameters<ExecuteBatchQueryRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_execute_batch").await {
|
||
return error;
|
||
}
|
||
self.execute_batch_request(request).await
|
||
}
|
||
|
||
async fn execute_batch_request(&self, request: ExecuteBatchQueryRequest) -> CallToolResult {
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type == DatabaseType::Salesforce {
|
||
return tool_error(
|
||
"DBX_BATCH_UNSUPPORTED",
|
||
"Salesforce has no batch execution: SOQL is read-only and every write touches exactly one record. Use dbx_execute_query for SOQL, and dbx_salesforce_prepare_write followed by dbx_salesforce_apply_write for a write.",
|
||
);
|
||
}
|
||
if matches!(connection.db_type, DatabaseType::Redis | DatabaseType::MongoDb) {
|
||
return tool_error(
|
||
"DBX_BATCH_UNSUPPORTED",
|
||
format!("Batch SQL execution is not available for {connection:?} connections."),
|
||
);
|
||
}
|
||
let sql = request.sql.trim();
|
||
if sql.is_empty() {
|
||
return tool_error("SQL_BATCH_EMPTY", "SQL script cannot be empty.");
|
||
}
|
||
// Every statement is rendered on its own, so the requested per-cell
|
||
// character window has to reach `format_batch_results`; without it the
|
||
// renderer silently fell back to the 200-character default and
|
||
// `cell_char_limit` looked ignored (#9865).
|
||
let cell_window = request.cell_window.to_query_window();
|
||
let session = match request.session_id.as_deref().map(str::trim).filter(|id| !id.is_empty()) {
|
||
Some(session_id) => {
|
||
let (session, expired) = self.sessions.resolve(session_id).await.into_parts();
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
match session {
|
||
Some(session) if session.connection_id == connection.id => Some(session),
|
||
Some(_) => {
|
||
return tool_error(
|
||
"SESSION_CONNECTION_MISMATCH",
|
||
format!("Session \"{session_id}\" is bound to a different connection."),
|
||
);
|
||
}
|
||
None => {
|
||
return tool_error(
|
||
"SESSION_NOT_FOUND",
|
||
format!(
|
||
"Session \"{session_id}\" not found or expired. Open a new one with dbx_open_session."
|
||
),
|
||
);
|
||
}
|
||
}
|
||
}
|
||
None => None,
|
||
};
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
if let Some(session) = &session {
|
||
if session.database != database {
|
||
return tool_error(
|
||
"SESSION_DATABASE_MISMATCH",
|
||
format!(
|
||
"Session \"{}\" is bound to database \"{}\", not \"{database}\".",
|
||
session.id, session.database
|
||
),
|
||
);
|
||
}
|
||
}
|
||
// A pinned session makes USE/SET CATALOG meaningful, so database
|
||
// switching is allowed — unless a hard database scope is configured.
|
||
let allow_database_switch = session.is_some() && self.scope.database.is_none();
|
||
let policy =
|
||
effective_policy_for_database_with_groups(&resolved.policy, &resolved.group_ids, connection, &database);
|
||
if let Err(error) = ensure_sql_database_scope(&resolved.database_scope, connection, &database, sql) {
|
||
return error;
|
||
}
|
||
if let Err(error) = ensure_sql_database_execution_scope(&resolved.policy, connection, &database, sql) {
|
||
return error;
|
||
}
|
||
// Split with the same dialect-aware splitter the core uses, early, so the
|
||
// option-validity checks below only fire for scripts that actually enter
|
||
// transaction mode (more than one statement). A single-statement script
|
||
// ignores use_transaction and runs as normal auto-commit, so combining it
|
||
// with session_id / continue_on_error must still be allowed.
|
||
let execution_plan = self.backend.execution_plan(connection, &database, sql).await;
|
||
let statement_count = execution_plan.statements.len();
|
||
let transactional = request.use_transaction == Some(true) && statement_count > 1;
|
||
// A transactional batch runs on a pooled connection and returns one
|
||
// merged result, so it cannot preserve session state or yield per-
|
||
// statement results. The core transaction path takes no client session
|
||
// id, so combining the two would silently drop the session pin. Only
|
||
// relevant when the script actually enters transaction mode.
|
||
if transactional && session.is_some() {
|
||
return tool_error(
|
||
"TRANSACTION_WITH_SESSION_UNSUPPORTED",
|
||
"use_transaction cannot be combined with session_id: transactional batches run on a pooled connection, discard session state, and return a single merged result. Run the batch either without use_transaction (auto-commit, one result per statement) or without session_id.",
|
||
);
|
||
}
|
||
// The core transaction path rolls back and stops on the first failure
|
||
// (query.rs:2970), so continue_on_error is silently ignored there.
|
||
// Accepting both would promise per-statement continuation that never
|
||
// happens — reject the combination instead. Only relevant when the
|
||
// script actually enters transaction mode.
|
||
if transactional && request.continue_on_error == Some(true) {
|
||
return tool_error(
|
||
"TRANSACTION_WITH_CONTINUE_UNSUPPORTED",
|
||
"use_transaction cannot be combined with continue_on_error: a transactional batch stops and rolls back at the first failure, so continue_on_error would be ignored. Run the batch either without use_transaction (auto-commit, one result per statement, may continue on error) or without continue_on_error.",
|
||
);
|
||
}
|
||
// DDL implicitly commits on MySQL-family and Oracle engines (and any
|
||
// backend without transactional DDL — the shared capability check), so
|
||
// the transaction wrapper cannot roll back a DDL that already committed
|
||
// (e.g. "CREATE TABLE a; INSERT INTO missing" leaves the table behind
|
||
// after the failed INSERT rolls back). A transactional batch containing
|
||
// DDL would over-promise atomicity — reject it instead. Gated on multi-
|
||
// statement like the other rejects: a single DDL statement is plain
|
||
// auto-commit and safe.
|
||
if transactional
|
||
&& dbx_core::query::batch_transaction_ddl_is_unrollbackable(
|
||
Some(connection.db_type),
|
||
&execution_plan.statements,
|
||
)
|
||
{
|
||
return tool_error(
|
||
"TRANSACTION_WITH_DDL_UNSUPPORTED",
|
||
"use_transaction cannot be used with a batch whose DDL cannot be rolled back: DDL statements implicitly commit and cannot be rolled back, so the batch would not be atomic. Run the batch without use_transaction (auto-commit, one result per statement) or split the DDL and DML into separate calls.",
|
||
);
|
||
}
|
||
// Classify the whole script as a unit so a single write/DDL statement in
|
||
// the batch fails closed under read-only / dangerous-SQL / production
|
||
// policy, exactly as the Web /api/query/execute-multi route does.
|
||
let permissions = match validate_sql_policy(connection, &policy, &database, sql, allow_database_switch) {
|
||
Ok(permissions) => permissions,
|
||
Err(error) => return error,
|
||
};
|
||
// When the user confirmed a specific write SQL for this run, the batch
|
||
// must not smuggle a different write/DDL statement past that binding.
|
||
// Fail closed on the whole script when it contains a write and is not
|
||
// exactly the confirmed SQL — matching execute_query's anti-replay rule.
|
||
if let Some(message) =
|
||
confirmed_batch_sql_block_reason(sql, connection.db_type, permissions.confirmed_write_sql.as_deref())
|
||
{
|
||
return tool_error("SQL_BLOCKED", message);
|
||
}
|
||
if let Some(session) = session.as_ref().filter(|session| session.transaction_owner.is_some()) {
|
||
if request.use_transaction == Some(true) {
|
||
return tool_error(
|
||
"TRANSACTION_WITH_SESSION_UNSUPPORTED",
|
||
"use_transaction cannot be combined with a transaction-enabled session; use dbx_begin_transaction and dbx_commit_transaction.",
|
||
);
|
||
}
|
||
for statement in &execution_plan.statements {
|
||
if let Err(error) = validate_transaction_sql_shape(statement) {
|
||
return tool_error("TRANSACTION_SQL_BLOCKED", error);
|
||
}
|
||
}
|
||
let owner = session.transaction_owner.as_ref().expect("filtered transaction owner").clone();
|
||
let lease = match owner.acquire().await {
|
||
Ok(lease) => lease,
|
||
Err(error) => return transaction_failure_result(&session.id, error),
|
||
};
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_execute_batch").await {
|
||
return error;
|
||
}
|
||
let refreshed = match self
|
||
.resolve_connection(&ConnectionSelector {
|
||
connection_id: Some(session.connection_id.clone()),
|
||
connection_name: None,
|
||
})
|
||
.await
|
||
{
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
if !transaction_connection_supported(&refreshed.connection)
|
||
|| refreshed.connection.id != session.connection_id
|
||
{
|
||
return tool_error("TRANSACTION_UNSUPPORTED", "The bound native MySQL connection changed.");
|
||
}
|
||
if let Err(error) =
|
||
ensure_sql_database_scope(&refreshed.database_scope, &refreshed.connection, &session.database, sql)
|
||
{
|
||
return error;
|
||
}
|
||
if let Err(error) =
|
||
ensure_sql_database_execution_scope(&refreshed.policy, &refreshed.connection, &session.database, sql)
|
||
{
|
||
return error;
|
||
}
|
||
let refreshed_policy = effective_policy_for_database_with_groups(
|
||
&refreshed.policy,
|
||
&refreshed.group_ids,
|
||
&refreshed.connection,
|
||
&session.database,
|
||
);
|
||
let refreshed_permissions =
|
||
match validate_sql_policy(&refreshed.connection, &refreshed_policy, &session.database, sql, false) {
|
||
Ok(permissions) => permissions,
|
||
Err(error) => return error,
|
||
};
|
||
if let Some(message) = confirmed_batch_sql_block_reason(
|
||
sql,
|
||
refreshed.connection.db_type,
|
||
refreshed_permissions.confirmed_write_sql.as_deref(),
|
||
) {
|
||
return tool_error("SQL_BLOCKED", message);
|
||
}
|
||
for statement in &execution_plan.statements {
|
||
if let Err(error) = validate_transaction_sql_shape(statement) {
|
||
return tool_error("TRANSACTION_SQL_BLOCKED", error);
|
||
}
|
||
}
|
||
|
||
let started_at = Instant::now();
|
||
let executions = lease
|
||
.batch(
|
||
execution_plan.statements.clone(),
|
||
Some(BATCH_MAX_ROWS),
|
||
request.continue_on_error.unwrap_or(false),
|
||
)
|
||
.await;
|
||
let mut results = Vec::with_capacity(executions.len());
|
||
let mut failures = Vec::new();
|
||
for (index, execution) in executions.into_iter().enumerate() {
|
||
match execution {
|
||
Ok(execution) => results.push(crate::backend::BatchStatementResult {
|
||
result: execution.result,
|
||
execution_error: false,
|
||
statement_index: Some(index),
|
||
error_message: None,
|
||
merged: false,
|
||
transaction_state: Some(execution.state),
|
||
transaction_outcome: execution.outcome,
|
||
}),
|
||
Err(error) => {
|
||
failures.push(error.message.clone());
|
||
results.push(crate::backend::BatchStatementResult {
|
||
result: empty_query_result(),
|
||
execution_error: true,
|
||
statement_index: Some(index),
|
||
error_message: Some(error.message),
|
||
merged: false,
|
||
transaction_state: Some(error.state),
|
||
transaction_outcome: error.outcome,
|
||
});
|
||
}
|
||
}
|
||
}
|
||
let status = owner.status();
|
||
self.save_mcp_sql_history(
|
||
"dbx_execute_batch",
|
||
&refreshed.connection,
|
||
&session.database,
|
||
sql,
|
||
started_at,
|
||
failures.is_empty(),
|
||
(!failures.is_empty()).then(|| failures.join("; ")),
|
||
failures.is_empty().then(|| {
|
||
results.iter().map(|result| result.result.affected_rows).sum::<u64>().min(i64::MAX as u64) as i64
|
||
}),
|
||
)
|
||
.await;
|
||
let mut tool_result = text(format_batch_results(&results, cell_window));
|
||
tool_result.structured_content = Some(json!({
|
||
"session_id": session.id,
|
||
"transaction_state": status.state,
|
||
"transaction_outcome": status.outcome,
|
||
"results": results,
|
||
}));
|
||
return tool_result;
|
||
}
|
||
// A transactional batch runs on the plain (non-session) pool: the core
|
||
// transaction wrapper ignores client_session_id (query.rs:2970 →
|
||
// execute_statements_in_transaction_typed re-resolves the default pool
|
||
// with get_or_create_pool). Creating an ephemeral session pool here
|
||
// would open physical connections that are closed unused, so only
|
||
// auto-commit batches get an ephemeral pinned pool — it keeps temp
|
||
// tables and SET state alive for every statement in the script.
|
||
let ephemeral_client_session_id =
|
||
(!transactional && session.is_none()).then(|| format!("mcp-batch-{}", Uuid::new_v4()));
|
||
let client_session_id = session
|
||
.as_ref()
|
||
.map(|session| session.client_session_id.clone())
|
||
.or_else(|| ephemeral_client_session_id.clone());
|
||
let mut options = dbx_core::query::QueryExecutionOptions {
|
||
max_rows: Some(BATCH_MAX_ROWS),
|
||
continue_on_error: request.continue_on_error.unwrap_or(false),
|
||
use_transaction: request.use_transaction,
|
||
client_session_id: client_session_id.clone(),
|
||
..Default::default()
|
||
};
|
||
// Surface the global MCP query timeout. It is re-read on every tool
|
||
// call, so a settings change takes effect without client-config
|
||
// regeneration.
|
||
options.timeout_secs = resolved.policy.query_timeout_secs;
|
||
let schema = self.scope.schema.as_deref();
|
||
let started_at = Instant::now();
|
||
let execution = self.backend.execute_batch(connection, &database, schema, sql, options).await;
|
||
if let Some(client_session_id) = ephemeral_client_session_id.as_deref() {
|
||
if let Err(error) = self.backend.close_client_session(&connection.id, &database, client_session_id).await {
|
||
log::warn!("failed to close ephemeral MCP batch session for {}: {error}", connection.id);
|
||
}
|
||
}
|
||
match execution {
|
||
Ok(mut results) => {
|
||
// The core transaction path collapses the whole script into one
|
||
// merged QueryResult. Mark it so callers can tell a merged
|
||
// outcome from a per-statement result, and render it distinctly
|
||
// instead of implying per-statement outcomes. The len()==1 guard
|
||
// keeps drivers that return per-statement results even with
|
||
// use_transaction (e.g. SQL Server scripts with result sets)
|
||
// from being mislabelled as transactional.
|
||
if transactional && results.len() == 1 {
|
||
results[0].merged = true;
|
||
results[0].statement_index = None;
|
||
}
|
||
let failures = results
|
||
.iter()
|
||
.filter(|result| result.execution_error)
|
||
.map(|result| {
|
||
result.error_message.clone().unwrap_or_else(|| match result.statement_index {
|
||
Some(index) => format!("Statement {} failed", index + 1),
|
||
None => "Batch execution failed".to_string(),
|
||
})
|
||
})
|
||
.collect::<Vec<_>>();
|
||
let success = failures.is_empty();
|
||
let affected_rows = success.then(|| {
|
||
results.iter().map(|result| result.result.affected_rows).sum::<u64>().min(i64::MAX as u64) as i64
|
||
});
|
||
self.save_mcp_sql_history(
|
||
"dbx_execute_batch",
|
||
connection,
|
||
&database,
|
||
sql,
|
||
started_at,
|
||
success,
|
||
(!failures.is_empty()).then(|| failures.join("; ")),
|
||
affected_rows,
|
||
)
|
||
.await;
|
||
let markdown = format_batch_results(&results, cell_window);
|
||
// Issue #7548 requires structured per-statement results so callers do not
|
||
// parse concatenated text. MCP requires structuredContent to be an object,
|
||
// so the array lives under `results`.
|
||
let mut tool_result = CallToolResult::success(vec![ContentBlock::text(markdown)]);
|
||
tool_result.structured_content = Some(serde_json::json!({ "results": results }));
|
||
tool_result
|
||
}
|
||
Err(error) => {
|
||
self.save_mcp_sql_history(
|
||
"dbx_execute_batch",
|
||
connection,
|
||
&database,
|
||
sql,
|
||
started_at,
|
||
false,
|
||
Some(error.clone()),
|
||
None,
|
||
)
|
||
.await;
|
||
backend_tool_error("DBX_BATCH_EXECUTION_ERROR", error)
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_open_session",
|
||
description = "Open a stateful query session pinned to a single backend connection. Returns a session ID for dbx_execute_query: USE, SET CATALOG, session variables and temporary tables persist across calls within the session. Close with dbx_close_session when done; idle sessions expire after 30 minutes by default (configurable with DBX_SESSION_IDLE_TTL_SECS)."
|
||
)]
|
||
async fn open_session_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<OpenSessionRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.open_session(parameters)).await
|
||
}
|
||
|
||
async fn open_session(&self, Parameters(request): Parameters<OpenSessionRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_open_session").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type == DatabaseType::Salesforce {
|
||
return tool_error(
|
||
"SESSION_UNSUPPORTED",
|
||
"Salesforce connections are stateless REST calls: there is no session to pin, no USE, and no transaction. Use dbx_execute_query for SOQL, and dbx_salesforce_prepare_write followed by dbx_salesforce_apply_write for a write.",
|
||
);
|
||
}
|
||
if matches!(connection.db_type, DatabaseType::Redis | DatabaseType::MongoDb) {
|
||
return tool_error(
|
||
"SESSION_UNSUPPORTED",
|
||
format!("Sessions are only supported for SQL connections; \"{}\" is not one.", connection.name),
|
||
);
|
||
}
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
if request.enable_transactions && !transaction_connection_supported(connection) {
|
||
return tool_error(
|
||
"TRANSACTION_UNSUPPORTED",
|
||
"Fixed-session transactions require a native local MySQL connection without an external driver profile.",
|
||
);
|
||
}
|
||
let (session, expired) = if request.enable_transactions {
|
||
self.sessions.reserve_opening(&connection.id, &database).await.into_parts()
|
||
} else {
|
||
self.sessions.open(&connection.id, &database).await.into_parts()
|
||
};
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
let session = match session {
|
||
Ok(session) => session,
|
||
Err(error) => return tool_error("SESSION_LIMIT", error),
|
||
};
|
||
if request.enable_transactions {
|
||
let (prepared, acknowledge) =
|
||
self.spawn_transaction_session_open(connection.clone(), database.clone(), session.clone());
|
||
let owner = match prepared.await {
|
||
Ok(Ok(owner)) => owner,
|
||
Ok(Err(error)) => return backend_tool_error("TRANSACTION_UNSUPPORTED", error),
|
||
Err(_) => return tool_error("SESSION_OPEN_ERROR", "Transaction session open worker stopped."),
|
||
};
|
||
let session = match self.sessions.promote_opening(&session.id, owner).await {
|
||
Ok(session) => session,
|
||
Err(error) => return tool_error("SESSION_OPEN_ERROR", error),
|
||
};
|
||
let mut result = text(format!(
|
||
"Session opened.\nsession_id: {}\nconnection: {} (id: {})\ndatabase: {}\ntransactions: enabled\n\nPass session_id to dbx_execute_query to run every query on the same pinned connection. Close with dbx_close_session when done.",
|
||
session.id, connection.name, connection.id, database
|
||
));
|
||
result.structured_content = Some(json!({
|
||
"session_id": session.id,
|
||
"transaction_state": "idle",
|
||
"transaction_outcome": null,
|
||
}));
|
||
let _ = acknowledge.send(());
|
||
return result;
|
||
}
|
||
text(format!(
|
||
"Session opened.\nsession_id: {}\nconnection: {} (id: {})\ndatabase: {}\n\nPass session_id to dbx_execute_query to run every query on the same pinned connection. Close with dbx_close_session when done.",
|
||
session.id, connection.name, connection.id, database
|
||
))
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_begin_transaction",
|
||
description = "Begin a transaction on a transaction-enabled native MySQL session"
|
||
)]
|
||
async fn begin_transaction_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<TransactionSessionRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.begin_transaction(parameters)).await
|
||
}
|
||
|
||
async fn begin_transaction(&self, Parameters(request): Parameters<TransactionSessionRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_begin_transaction").await {
|
||
return error;
|
||
}
|
||
let (session, expired) = self.sessions.resolve(&request.session_id).await.into_parts();
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
let Some(session) = session else {
|
||
return tool_error(
|
||
"SESSION_NOT_FOUND",
|
||
format!("Session \"{}\" not found or expired.", request.session_id),
|
||
);
|
||
};
|
||
let Some(owner) = session.transaction_owner.clone() else {
|
||
return tool_error("TRANSACTION_UNSUPPORTED", "This session was not opened with enable_transactions=true.");
|
||
};
|
||
let lease = match owner.acquire().await {
|
||
Ok(lease) => lease,
|
||
Err(error) => return transaction_failure_result(&session.id, error),
|
||
};
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_begin_transaction").await {
|
||
return error;
|
||
}
|
||
if let Err(error) = self.validate_transaction_control(&session, "BEGIN").await {
|
||
return error;
|
||
}
|
||
match lease.begin().await {
|
||
Ok(result) => transaction_success_result(&session.id, "Transaction started.", result),
|
||
Err(error) => transaction_failure_result(&session.id, error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_commit_transaction",
|
||
description = "Commit the active transaction; committed is reported only after MySQL acknowledges COMMIT"
|
||
)]
|
||
async fn commit_transaction_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<TransactionSessionRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.commit_transaction(parameters)).await
|
||
}
|
||
|
||
async fn commit_transaction(&self, Parameters(request): Parameters<TransactionSessionRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_commit_transaction").await {
|
||
return error;
|
||
}
|
||
let (session, expired) = self.sessions.resolve(&request.session_id).await.into_parts();
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
let Some(session) = session else {
|
||
return tool_error(
|
||
"SESSION_NOT_FOUND",
|
||
format!("Session \"{}\" not found or expired.", request.session_id),
|
||
);
|
||
};
|
||
let Some(owner) = session.transaction_owner.clone() else {
|
||
return tool_error("TRANSACTION_UNSUPPORTED", "This session was not opened with enable_transactions=true.");
|
||
};
|
||
let lease = match owner.acquire().await {
|
||
Ok(lease) => lease,
|
||
Err(error) => return transaction_failure_result(&session.id, error),
|
||
};
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_commit_transaction").await {
|
||
return error;
|
||
}
|
||
if let Err(error) = self.validate_transaction_control(&session, "COMMIT").await {
|
||
return error;
|
||
}
|
||
match lease.commit().await {
|
||
Ok(result) => transaction_success_result(&session.id, "Transaction committed.", result),
|
||
Err(error) => transaction_failure_result(&session.id, error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_rollback_transaction",
|
||
description = "Roll back the active transaction. Cleanup remains available after write-policy revocation."
|
||
)]
|
||
async fn rollback_transaction_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<TransactionSessionRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.rollback_transaction(parameters)).await
|
||
}
|
||
|
||
async fn rollback_transaction(&self, Parameters(request): Parameters<TransactionSessionRequest>) -> CallToolResult {
|
||
let (session, expired) = self.sessions.resolve(&request.session_id).await.into_parts();
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
let Some(session) = session else {
|
||
return tool_error(
|
||
"SESSION_NOT_FOUND",
|
||
format!("Session \"{}\" not found or expired.", request.session_id),
|
||
);
|
||
};
|
||
let Some(owner) = session.transaction_owner.clone() else {
|
||
return tool_error("TRANSACTION_UNSUPPORTED", "This session was not opened with enable_transactions=true.");
|
||
};
|
||
let lease = match owner.acquire().await {
|
||
Ok(lease) => lease,
|
||
Err(error) => return transaction_failure_result(&session.id, error),
|
||
};
|
||
match lease.rollback().await {
|
||
Ok(result) => transaction_success_result(&session.id, "Transaction rolled back.", result),
|
||
Err(error) => transaction_failure_result(&session.id, error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_close_session",
|
||
description = "Close a stateful query session and release its pinned backend connection"
|
||
)]
|
||
async fn close_session_tool(
|
||
&self,
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
parameters: Parameters<CloseSessionRequest>,
|
||
) -> CallToolResult {
|
||
cancellable_tool_call(cancellation, self.close_session(parameters)).await
|
||
}
|
||
|
||
async fn close_session(&self, Parameters(request): Parameters<CloseSessionRequest>) -> CallToolResult {
|
||
let (session, expired) = self.sessions.begin_close(&request.session_id).await.into_parts();
|
||
self.close_backend_sessions_best_effort(expired).await;
|
||
let Some(session) = session else {
|
||
return tool_error(
|
||
"SESSION_NOT_FOUND",
|
||
format!("Session \"{}\" not found or already closed.", request.session_id),
|
||
);
|
||
};
|
||
let session_id = session.id.clone();
|
||
let cleanup = self.spawn_session_cleanup(session);
|
||
let cleanup = match cleanup.await {
|
||
Ok(cleanup) => cleanup,
|
||
Err(_) => return tool_error("SESSION_CLOSE_ERROR", "Session cleanup worker stopped."),
|
||
};
|
||
if let Some(error) = cleanup.error {
|
||
return backend_tool_error("SESSION_CLOSE_ERROR", error);
|
||
}
|
||
let mut result = text(format!("Session \"{}\" closed.", session_id));
|
||
if let Some(status) = cleanup.status {
|
||
result.structured_content = Some(json!({
|
||
"session_id": session_id,
|
||
"transaction_state": status.state,
|
||
"transaction_outcome": status.outcome,
|
||
}));
|
||
}
|
||
result
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_execute_redis_command",
|
||
description = "Execute a Redis command on a Redis connection. Use the db argument to select a logical database instead of sending SELECT. Use SCAN rather than KEYS when enumerating keys."
|
||
)]
|
||
async fn execute_redis_command(
|
||
&self,
|
||
Parameters(request): Parameters<ExecuteRedisCommandRequest>,
|
||
) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_execute_redis_command").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type != DatabaseType::Redis {
|
||
return tool_error("INVALID_CONNECTION_TYPE", format!("Connection \"{}\" is not Redis.", connection.name));
|
||
}
|
||
let database = match self.resolve_redis_database(request.db, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let argv = match parse_command_argv(&request.command) {
|
||
Ok(argv) => argv,
|
||
Err(error) => return tool_error("REDIS_COMMAND_BLOCKED", error),
|
||
};
|
||
if argv[0].eq_ignore_ascii_case("SELECT") {
|
||
return tool_error(
|
||
"REDIS_DATABASE_SELECTION_REQUIRED",
|
||
"Redis SELECT is not available through MCP. Set the db argument to the logical database number instead; when db is omitted, DBX uses the current scoped database.",
|
||
);
|
||
}
|
||
let safety = classify_command(&argv[0]);
|
||
let policy = effective_policy_for_database_with_groups(
|
||
&resolved.policy,
|
||
&resolved.group_ids,
|
||
connection,
|
||
&database.to_string(),
|
||
);
|
||
let permissions = mcp_permissions(connection, &policy);
|
||
if safety != RedisCommandSafety::Allowed && policy.read_only {
|
||
return tool_error(
|
||
"MCP_READ_ONLY",
|
||
format!("MCP execution permission for Redis database {database} is read-only. Redis command blocked."),
|
||
);
|
||
}
|
||
if safety != RedisCommandSafety::Allowed && connection.read_only {
|
||
return tool_error(
|
||
"CONNECTION_READ_ONLY",
|
||
format!("Connection \"{}\" has read-only protection enabled. Redis command blocked.", connection.name),
|
||
);
|
||
}
|
||
if safety == RedisCommandSafety::Blocked && !permissions.allow_dangerous {
|
||
return tool_error(
|
||
"REDIS_COMMAND_BLOCKED",
|
||
format!(
|
||
"Dangerous Redis command \"{}\" is disabled in DBX MCP settings.",
|
||
argv[0].to_ascii_uppercase()
|
||
),
|
||
);
|
||
}
|
||
if safety != RedisCommandSafety::Allowed && !permissions.allow_writes {
|
||
return tool_error(
|
||
"REDIS_COMMAND_BLOCKED",
|
||
"MCP Redis command execution is read-only in DBX MCP settings.",
|
||
);
|
||
}
|
||
// Production protection is stricter than the opt-in write flags by design.
|
||
if safety != RedisCommandSafety::Allowed && is_production_database(connection, &database.to_string()) {
|
||
return tool_error(
|
||
"PRODUCTION_WRITE_BLOCKED",
|
||
"MCP cannot execute write or dangerous Redis commands against a production database.",
|
||
);
|
||
}
|
||
match self
|
||
.backend
|
||
.execute_redis_command(
|
||
connection,
|
||
database,
|
||
&request.command,
|
||
safety == RedisCommandSafety::Blocked && permissions.allow_dangerous,
|
||
)
|
||
.await
|
||
{
|
||
Ok(result) => text(format_redis_result(&result)),
|
||
Err(error) => backend_tool_error("REDIS_COMMAND_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_peek_messages",
|
||
description = "Read up to 100 Kafka messages without committing consumer offsets. Defaults to the latest 20 messages. Returns JSON with base64 payloads, UTF-8 previews, metadata, incomplete (partial broker read), and outputTruncated (256 KiB message output budget). Only Kafka is supported."
|
||
)]
|
||
async fn peek_messages(&self, Parameters(request): Parameters<PeekMessagesRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_peek_messages").await {
|
||
return error;
|
||
}
|
||
#[cfg(not(feature = "mq-admin"))]
|
||
{
|
||
let _ = request;
|
||
tool_error("MQ_UNSUPPORTED", "Message queue support is not compiled into this DBX MCP build.")
|
||
}
|
||
#[cfg(feature = "mq-admin")]
|
||
{
|
||
use dbx_core::mq::{
|
||
config::MqAdminConfig, MqSystemKind, PeekMessagesOptions, PeekStartPosition as Start, TopicRef,
|
||
};
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
match MqAdminConfig::from_connection(&resolved.connection) {
|
||
Ok(config) if config.system_kind == MqSystemKind::Kafka => {}
|
||
_ => {
|
||
return tool_error("MQ_UNSUPPORTED", "Message reading through MCP supports Kafka connections only.")
|
||
}
|
||
}
|
||
let count = request.count.unwrap_or(20);
|
||
let start_position = match request.start_position {
|
||
PeekStartPosition::Latest => Start::Latest,
|
||
PeekStartPosition::Earliest => Start::Earliest,
|
||
PeekStartPosition::Offset => Start::Offset,
|
||
};
|
||
if request.topic.trim().is_empty() {
|
||
return tool_error("MESSAGE_TOPIC_REQUIRED", "Message topic must not be empty.");
|
||
}
|
||
if !(1..=100).contains(&count)
|
||
|| request.partition.is_some_and(|value| value < 0)
|
||
|| request.offset.is_some_and(|value| value < 0)
|
||
|| (start_position == Start::Offset) != request.offset.is_some()
|
||
{
|
||
return tool_error("INVALID_PEEK_OPTIONS", "count must be 1..100; partition and offset must be non-negative; offset is required only for start_position=offset.");
|
||
}
|
||
let topic = TopicRef {
|
||
tenant: "_kafka".into(),
|
||
namespace: "default".into(),
|
||
topic: request.topic.trim().into(),
|
||
..Default::default()
|
||
};
|
||
let options = PeekMessagesOptions {
|
||
start_position: Some(start_position),
|
||
partition: request.partition,
|
||
offset: request.offset,
|
||
};
|
||
match self.backend.peek_messages(&resolved.connection, topic, count, options).await {
|
||
Ok(result) => text(format_peek_messages_result(result, count as usize)),
|
||
Err(error) => backend_tool_error("MESSAGE_PEEK_ERROR", error),
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_send_message",
|
||
description = "Send a base64-encoded message to a Kafka, RocketMQ, or RabbitMQ topic/queue"
|
||
)]
|
||
async fn send_message(&self, Parameters(request): Parameters<SendMessageRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_send_message").await {
|
||
return error;
|
||
}
|
||
#[cfg(not(feature = "mq-admin"))]
|
||
{
|
||
let _ = request;
|
||
return tool_error("MQ_UNSUPPORTED", "Message queue support is not compiled into this DBX MCP build.");
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
{
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
let mq_config = match dbx_core::mq::config::MqAdminConfig::from_connection(connection) {
|
||
Ok(config) => config,
|
||
Err(error) => return tool_error("MQ_UNSUPPORTED", error),
|
||
};
|
||
if request.topic.trim().is_empty() {
|
||
return tool_error("MESSAGE_TOPIC_REQUIRED", "Message topic must not be empty.");
|
||
}
|
||
let policy = effective_policy_for_database_with_groups(
|
||
&resolved.policy,
|
||
&resolved.group_ids,
|
||
connection,
|
||
connection.database.as_deref().unwrap_or(""),
|
||
);
|
||
if policy.read_only {
|
||
return tool_error(
|
||
"MCP_READ_ONLY",
|
||
"The effective MCP execution permission is read-only. Message sending is blocked.",
|
||
);
|
||
}
|
||
if connection.read_only {
|
||
return tool_error(
|
||
"CONNECTION_READ_ONLY",
|
||
format!(
|
||
"Connection \"{}\" has read-only protection enabled. Message sending is blocked.",
|
||
connection.name
|
||
),
|
||
);
|
||
}
|
||
if dbx_core::production_safety::is_production_database(
|
||
connection,
|
||
connection.database.as_deref().unwrap_or(""),
|
||
) {
|
||
return tool_error("PRODUCTION_WRITE_BLOCKED", "MCP cannot send messages to a production database.");
|
||
}
|
||
let request = dbx_core::mq::SendMessageRequest {
|
||
topic: request.topic.trim().to_string(),
|
||
key: request.key,
|
||
payload_base64: request.payload_base64,
|
||
payload_text: request.payload_text,
|
||
headers: request.headers,
|
||
partition: request.partition,
|
||
exchange: request.exchange,
|
||
routing_key: request.routing_key,
|
||
namespace: request.namespace,
|
||
};
|
||
match self.backend.send_message(connection, request).await {
|
||
Ok(result) => text(format_send_message_result(&mq_config.system_kind, &result)),
|
||
Err(error) => backend_tool_error("MESSAGE_SEND_ERROR", error),
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tool(name = "dbx_get_schema_context", description = "Get compact table and column context for writing SQL")]
|
||
async fn get_schema_context(&self, Parameters(request): Parameters<SchemaContextRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_get_schema_context").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let schema = match self.resolve_schema(request.schema) {
|
||
Ok(schema) => schema,
|
||
Err(error) => return error,
|
||
};
|
||
let max_tables = request.max_tables.unwrap_or(8).clamp(1, 20);
|
||
let available = match self.backend.list_tables(connection, &database, &schema).await {
|
||
Ok(tables) => tables,
|
||
Err(error) => return tool_error("SCHEMA_CONTEXT_ERROR", error),
|
||
};
|
||
let requested = request
|
||
.tables
|
||
.unwrap_or_default()
|
||
.into_iter()
|
||
.map(|name| name.to_ascii_lowercase())
|
||
.collect::<std::collections::HashSet<_>>();
|
||
let mut selected = if requested.is_empty() {
|
||
available.iter().collect::<Vec<_>>()
|
||
} else {
|
||
available.iter().filter(|table| requested.contains(&table.name.to_ascii_lowercase())).collect::<Vec<_>>()
|
||
};
|
||
let truncated = selected.len() > max_tables || (requested.is_empty() && available.len() > max_tables);
|
||
selected.truncate(max_tables);
|
||
if selected.is_empty() {
|
||
return text("No matching tables found.");
|
||
}
|
||
let mut tables = Vec::with_capacity(selected.len());
|
||
for table in selected {
|
||
// Keep metadata calls sequential because some embedded drivers expose a single physical connection.
|
||
let columns = match self.backend.get_columns(connection, &database, &schema, &table.name).await {
|
||
Ok(columns) => columns,
|
||
Err(error) => return tool_error("SCHEMA_CONTEXT_ERROR", error),
|
||
};
|
||
tables.push((table.clone(), columns));
|
||
}
|
||
text(format_schema_context(&connection.name, &database, &schema, &tables, truncated))
|
||
}
|
||
|
||
#[tool(name = "dbx_add_connection", description = "Add a new database connection to DBX")]
|
||
async fn add_connection(&self, Parameters(request): Parameters<AddConnectionRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_add_connection").await {
|
||
return error;
|
||
}
|
||
let policy = match self.load_policy().await {
|
||
Ok(policy) => policy,
|
||
Err(error) => return error,
|
||
};
|
||
if policy.read_only {
|
||
return tool_error(
|
||
"MCP_READ_ONLY",
|
||
"DBX global MCP read-only mode is enabled. Connection management is not allowed.",
|
||
);
|
||
}
|
||
let connections = match self.backend.load_connections().await {
|
||
Ok(connections) => connections,
|
||
Err(error) => return tool_error("CONNECTION_LOAD_ERROR", error),
|
||
};
|
||
if connections.iter().any(|connection| connection.name.eq_ignore_ascii_case(&request.name)) {
|
||
return text(format!("Connection \"{}\" already exists.", request.name));
|
||
}
|
||
let db_type = match parse_database_type(&request.db_type) {
|
||
Ok(db_type) => db_type,
|
||
Err(error) => return tool_error("INVALID_CONNECTION_TYPE", error),
|
||
};
|
||
let port = match request.port.or_else(|| database_manifest::default_port(&db_type)) {
|
||
Some(port) => port,
|
||
None => return text("Port is required for this database type."),
|
||
};
|
||
let config = match new_connection_config(
|
||
Uuid::new_v4().to_string(),
|
||
request.name,
|
||
db_type,
|
||
request.host,
|
||
port,
|
||
request.username,
|
||
request.password,
|
||
request.database,
|
||
request.ssl,
|
||
request.driver_profile,
|
||
) {
|
||
Ok(config) => config,
|
||
Err(error) => return tool_error("INVALID_CONNECTION", error),
|
||
};
|
||
match self.backend.add_connection_for_mcp(config).await {
|
||
Ok(config) => text(format!("Connection \"{}\" added (id: {}).", config.name, config.id)),
|
||
Err(error) => backend_tool_error("CONNECTION_SAVE_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_duplicate_connection",
|
||
description = "Duplicate a DBX connection with its complete settings, credentials, tunnels, and sidebar group"
|
||
)]
|
||
async fn duplicate_connection(
|
||
&self,
|
||
Parameters(request): Parameters<DuplicateConnectionRequest>,
|
||
) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_duplicate_connection").await {
|
||
return error;
|
||
}
|
||
let policy = match self.load_policy().await {
|
||
Ok(policy) => policy,
|
||
Err(error) => return error,
|
||
};
|
||
if policy.read_only {
|
||
return tool_error(
|
||
"MCP_READ_ONLY",
|
||
"DBX global MCP read-only mode is enabled. Connection management is not allowed.",
|
||
);
|
||
}
|
||
let connections = match self.backend.load_connections().await {
|
||
Ok(connections) => connections,
|
||
Err(error) => return tool_error("CONNECTION_LOAD_ERROR", error),
|
||
};
|
||
let group_paths = match self.load_group_paths_for_policy(&policy).await {
|
||
Ok(paths) => paths,
|
||
Err(error) => return backend_tool_error("MCP_POLICY_UNAVAILABLE", error),
|
||
};
|
||
let allowed = connections
|
||
.iter()
|
||
.filter(|connection| policy_allows_connection(&policy, group_paths.get(&connection.id), connection))
|
||
.cloned()
|
||
.collect::<Vec<_>>();
|
||
let source =
|
||
if let Some(id) = request.selector.connection_id.as_deref().map(str::trim).filter(|id| !id.is_empty()) {
|
||
allowed.iter().find(|connection| connection.id == id).cloned()
|
||
} else if let Some(name) =
|
||
request.selector.connection_name.as_deref().map(str::trim).filter(|name| !name.is_empty())
|
||
{
|
||
let matching = allowed
|
||
.iter()
|
||
.filter(|connection| connection.name.eq_ignore_ascii_case(name))
|
||
.cloned()
|
||
.collect::<Vec<_>>();
|
||
if matching.len() > 1 {
|
||
return tool_error("AMBIGUOUS_CONNECTION", ambiguous_connections(name, &matching));
|
||
}
|
||
matching.into_iter().next()
|
||
} else {
|
||
return tool_error("CONNECTION_NOT_FOUND", "Either connection_id or connection_name is required.");
|
||
};
|
||
let Some(source) = source else {
|
||
return tool_error("CONNECTION_NOT_FOUND", "The source connection was not found or is outside MCP scope.");
|
||
};
|
||
let new_name = request.new_name.trim();
|
||
if new_name.is_empty() {
|
||
return tool_error("INVALID_CONNECTION", "The copied connection name must not be empty.");
|
||
}
|
||
if connections.iter().any(|connection| connection.name.eq_ignore_ascii_case(new_name)) {
|
||
return tool_error("CONNECTION_ALREADY_EXISTS", format!("Connection \"{new_name}\" already exists."));
|
||
}
|
||
match self.backend.duplicate_connection_for_mcp(&source.id, &Uuid::new_v4().to_string(), new_name).await {
|
||
Ok(copy) => text(format!("Connection \"{}\" duplicated (id: {}).", copy.name, copy.id)),
|
||
Err(error) => backend_tool_error("CONNECTION_SAVE_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(name = "dbx_remove_connection", description = "Remove a database connection from DBX")]
|
||
async fn remove_connection(&self, Parameters(request): Parameters<RemoveConnectionRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_remove_connection").await {
|
||
return error;
|
||
}
|
||
let policy = match self.load_policy().await {
|
||
Ok(policy) => policy,
|
||
Err(error) => return error,
|
||
};
|
||
if policy.read_only {
|
||
return tool_error(
|
||
"MCP_READ_ONLY",
|
||
"DBX global MCP read-only mode is enabled. Connection management is not allowed.",
|
||
);
|
||
}
|
||
let connections = match self.backend.load_connections().await {
|
||
Ok(connections) => connections,
|
||
Err(error) => return tool_error("CONNECTION_LOAD_ERROR", error),
|
||
};
|
||
let target = if let Some(id) = request.connection_id.as_deref().map(str::trim).filter(|id| !id.is_empty()) {
|
||
connections.iter().find(|connection| connection.id == id).cloned()
|
||
} else {
|
||
let Some(name) = request.connection_name.as_deref().map(str::trim).filter(|name| !name.is_empty()) else {
|
||
return tool_error("CONNECTION_NOT_FOUND", "Either connection_id or connection_name is required.");
|
||
};
|
||
let matching = connections
|
||
.iter()
|
||
.filter(|connection| connection.name.eq_ignore_ascii_case(name))
|
||
.cloned()
|
||
.collect::<Vec<_>>();
|
||
if matching.len() > 1 {
|
||
return tool_error("AMBIGUOUS_CONNECTION", ambiguous_connections(name, &matching));
|
||
}
|
||
matching.into_iter().next()
|
||
};
|
||
let Some(target) = target else {
|
||
return tool_error(
|
||
"CONNECTION_NOT_FOUND",
|
||
request
|
||
.connection_id
|
||
.as_deref()
|
||
.filter(|id| !id.trim().is_empty())
|
||
.map(|id| format!("Connection with id \"{id}\" not found."))
|
||
.unwrap_or_else(|| {
|
||
format!("Connection \"{}\" not found.", request.connection_name.as_deref().unwrap_or_default())
|
||
}),
|
||
);
|
||
};
|
||
let group_paths = match self.load_group_paths_for_policy(&policy).await {
|
||
Ok(paths) => paths,
|
||
Err(error) => return backend_tool_error("MCP_POLICY_UNAVAILABLE", error),
|
||
};
|
||
if !policy_allows_connection(&policy, group_paths.get(&target.id), &target) {
|
||
return tool_error(
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
format!("Connection \"{}\" is not allowed by DBX MCP settings.", target.id),
|
||
);
|
||
}
|
||
match self.backend.remove_connection_for_mcp(&target.id).await {
|
||
Ok(true) => text(format!("Connection \"{}\" (id: {}) removed.", target.name, target.id)),
|
||
Ok(false) => tool_error("CONNECTION_NOT_FOUND", format!("Connection \"{}\" not found.", target.name)),
|
||
Err(error) => backend_tool_error("CONNECTION_SAVE_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(name = "dbx_open_table", description = "Open a table in DBX desktop app. Requires DBX to be running.")]
|
||
async fn open_table(&self, Parameters(request): Parameters<OpenTableRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_open_table").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let schema = match self.resolve_schema(request.schema) {
|
||
Ok(schema) => schema,
|
||
Err(error) => return error,
|
||
};
|
||
match self
|
||
.backend
|
||
.bridge_request(
|
||
"/open-table",
|
||
json!({
|
||
"connection_id": connection.id,
|
||
"connection_name": connection.name,
|
||
"table": request.table,
|
||
"database": database,
|
||
"schema": schema,
|
||
}),
|
||
)
|
||
.await
|
||
{
|
||
Ok(()) => text(format!("Opened {} in DBX", request.table)),
|
||
Err(error) => backend_tool_error("DBX_NOT_RUNNING", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_execute_and_show",
|
||
description = "Execute a SQL query in DBX desktop app UI and show results there. Requires DBX to be running."
|
||
)]
|
||
async fn execute_and_show(&self, Parameters(request): Parameters<ExecuteAndShowRequest>) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_execute_and_show").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type == DatabaseType::Redis {
|
||
return tool_error("REDIS_COMMAND_REQUIRED", "Use dbx_execute_redis_command for Redis connections.");
|
||
}
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
let policy =
|
||
effective_policy_for_database_with_groups(&resolved.policy, &resolved.group_ids, connection, &database);
|
||
if connection.db_type != DatabaseType::MongoDb {
|
||
if let Err(error) = ensure_sql_database_scope(&resolved.database_scope, connection, &database, &request.sql)
|
||
{
|
||
return error;
|
||
}
|
||
if let Err(error) =
|
||
ensure_sql_database_execution_scope(&resolved.policy, connection, &database, &request.sql)
|
||
{
|
||
return error;
|
||
}
|
||
}
|
||
let permissions = if connection.db_type == DatabaseType::MongoDb {
|
||
mcp_permissions(connection, &policy)
|
||
} else {
|
||
match validate_sql_policy(connection, &policy, &database, &request.sql, false) {
|
||
Ok(permissions) => permissions,
|
||
Err(error) => return error,
|
||
}
|
||
};
|
||
if connection.db_type == DatabaseType::MongoDb {
|
||
if let Err(error) = validate_mongo_command_with_groups(
|
||
connection,
|
||
&resolved.policy,
|
||
&resolved.group_ids,
|
||
&resolved.database_scope,
|
||
&database,
|
||
&request.sql,
|
||
) {
|
||
return error;
|
||
}
|
||
}
|
||
match self
|
||
.backend
|
||
.bridge_request(
|
||
"/execute-query",
|
||
json!({
|
||
"connection_id": connection.id,
|
||
"connection_name": connection.name,
|
||
"sql": request.sql,
|
||
"database": database,
|
||
"allow_writes": permissions.allow_writes,
|
||
"allow_dangerous": permissions.allow_dangerous,
|
||
}),
|
||
)
|
||
.await
|
||
{
|
||
Ok(()) => text("Query sent to DBX"),
|
||
Err(error) => backend_tool_error("DBX_NOT_RUNNING", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_salesforce_current_user",
|
||
description = "Show the Salesforce identity behind a DBX connection: the connected user, their profile, whether that profile holds \"Modify All Data\" (which bypasses field-level security and record sharing), and the org. Read-only. Call it before preparing a write so the user knows who the change will be attributed to, and to tell a permission failure apart from a bad record Id."
|
||
)]
|
||
async fn salesforce_current_user(
|
||
&self,
|
||
Parameters(request): Parameters<SalesforceIdentityRequest>,
|
||
) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_salesforce_current_user").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type != DatabaseType::Salesforce {
|
||
return not_salesforce_error(connection);
|
||
}
|
||
match self.backend.salesforce_current_user(connection).await {
|
||
Ok(identity) => {
|
||
let mut result = text(format_salesforce_identity_block(connection, Some(&identity)));
|
||
result.structured_content = Some(salesforce_identity_json(&identity));
|
||
result
|
||
}
|
||
Err(error) => tool_error("SALESFORCE_IDENTITY_ERROR", error),
|
||
}
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_salesforce_prepare_write",
|
||
description = "Step 1 of 2 for a Salesforce write: prepare an insert, update or delete of exactly ONE record. Nothing is sent to Salesforce. The call validates the request against DBX MCP policy and returns a human-readable summary plus a single-use confirm_token. Show that summary to the user and wait for their approval, then call dbx_salesforce_apply_write with the token. Salesforce has no transactions, so an applied write cannot be rolled back. Reads never need this: use dbx_execute_query with SOQL."
|
||
)]
|
||
async fn salesforce_prepare_write(
|
||
&self,
|
||
Parameters(request): Parameters<SalesforcePrepareWriteRequest>,
|
||
) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_salesforce_prepare_write").await {
|
||
return error;
|
||
}
|
||
let resolved = match self.resolve_connection(&request.selector).await {
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type != DatabaseType::Salesforce {
|
||
return not_salesforce_error(connection);
|
||
}
|
||
let database = match self.resolve_database(request.database, &resolved) {
|
||
Ok(database) => database,
|
||
Err(error) => return error,
|
||
};
|
||
if !connection_allows_salesforce_dml(&resolved.policy, &connection.id) {
|
||
return tool_error(
|
||
"SALESFORCE_DML_DISABLED",
|
||
format!(
|
||
"Salesforce writes are disabled for connection \"{}\". The user has to enable the \"Allow DML\" switch for this connection in DBX Settings → MCP, and the connection must not be read-only. Reads are unaffected: use dbx_execute_query with SOQL.",
|
||
connection.name
|
||
),
|
||
);
|
||
}
|
||
let statement = match build_salesforce_dml_statement(
|
||
&request.op,
|
||
&request.object,
|
||
request.id.as_deref(),
|
||
request.fields.as_ref(),
|
||
) {
|
||
Ok(statement) => statement,
|
||
Err(error) => return tool_error("SALESFORCE_DML_INVALID", error),
|
||
};
|
||
// The driver is the authority on what a statement means. Refusing here
|
||
// rather than at apply time means a token is never handed out for a write
|
||
// the org would reject.
|
||
if let Err(error) = parse_salesforce_statement(&statement) {
|
||
return tool_error("SALESFORCE_DML_INVALID", error);
|
||
}
|
||
let policy =
|
||
effective_policy_for_database_with_groups(&resolved.policy, &resolved.group_ids, connection, &database);
|
||
// The same envelope every other statement passes through: global and
|
||
// connection read-only rules, the high-risk tier for a write whose scope
|
||
// the classifier cannot pin down, and the production block. SOQL and the
|
||
// DML pseudo-command cannot name another database, so the SQL
|
||
// database-scope guards have nothing to add here.
|
||
if let Err(error) = validate_sql_policy(connection, &policy, &database, &statement, false) {
|
||
return error;
|
||
}
|
||
// Best effort: a failed identity lookup must not block the confirmation,
|
||
// it only leaves the "signed in as" line out of the summary.
|
||
let identity = self.backend.salesforce_current_user(connection).await.ok();
|
||
let token = format!("sfdml-{}", Uuid::new_v4());
|
||
let expires_in_secs = self.pending_salesforce_writes.ttl_secs();
|
||
self.pending_salesforce_writes
|
||
.insert(
|
||
token.clone(),
|
||
PendingSalesforceWrite {
|
||
connection_id: connection.id.clone(),
|
||
database: database.clone(),
|
||
statement: statement.clone(),
|
||
created_at: Instant::now(),
|
||
},
|
||
)
|
||
.await;
|
||
let summary =
|
||
format_salesforce_write_summary(&statement, connection, identity.as_ref(), &token, expires_in_secs);
|
||
let mut result = text(summary);
|
||
result.structured_content = Some(json!({
|
||
"confirm_token": token,
|
||
"expires_in_secs": expires_in_secs,
|
||
"connection_id": connection.id,
|
||
"statement": statement,
|
||
"identity": identity.as_ref().map(salesforce_identity_json),
|
||
}));
|
||
result
|
||
}
|
||
|
||
#[tool(
|
||
name = "dbx_salesforce_apply_write",
|
||
description = "Step 2 of 2 for a Salesforce write: execute exactly the write prepared by dbx_salesforce_prepare_write, identified by its confirm_token. The token is single-use, expires 5 minutes after it was issued, and is bound to that one statement — a changed write needs a new prepare. Call this only after the user has approved the summary they were shown. Returns the Salesforce result, or the org's own per-record error text."
|
||
)]
|
||
async fn salesforce_apply_write(
|
||
&self,
|
||
Parameters(request): Parameters<SalesforceApplyWriteRequest>,
|
||
) -> CallToolResult {
|
||
if let Err(error) = self.ensure_tool_allowed("dbx_salesforce_apply_write").await {
|
||
return error;
|
||
}
|
||
let Some(pending) = self.pending_salesforce_writes.take(&request.confirm_token).await else {
|
||
return tool_error(
|
||
"CONFIRM_TOKEN_INVALID",
|
||
format!(
|
||
"No pending Salesforce write for confirm_token \"{}\". Tokens are single-use and expire {} seconds after they are issued; call dbx_salesforce_prepare_write again and show the new summary to the user.",
|
||
request.confirm_token.trim(),
|
||
self.pending_salesforce_writes.ttl_secs()
|
||
),
|
||
);
|
||
};
|
||
// Re-read the connection and the whole policy envelope at apply time: the
|
||
// user may have flipped the connection to read-only, withdrawn the DML
|
||
// opt-in or narrowed the scope while the summary was on screen.
|
||
let resolved = match self
|
||
.resolve_connection(&ConnectionSelector {
|
||
connection_id: Some(pending.connection_id.clone()),
|
||
connection_name: None,
|
||
})
|
||
.await
|
||
{
|
||
Ok(resolved) => resolved,
|
||
Err(error) => return error,
|
||
};
|
||
let connection = &resolved.connection;
|
||
if connection.db_type != DatabaseType::Salesforce {
|
||
return not_salesforce_error(connection);
|
||
}
|
||
if !connection_allows_salesforce_dml(&resolved.policy, &connection.id) {
|
||
return tool_error(
|
||
"SALESFORCE_DML_DISABLED",
|
||
format!(
|
||
"Salesforce writes were disabled for connection \"{}\" after this write was prepared. Nothing was sent. Re-enable the \"Allow DML\" switch in DBX Settings → MCP and prepare the write again.",
|
||
connection.name
|
||
),
|
||
);
|
||
}
|
||
let policy = effective_policy_for_database_with_groups(
|
||
&resolved.policy,
|
||
&resolved.group_ids,
|
||
connection,
|
||
&pending.database,
|
||
);
|
||
let permissions = match validate_sql_policy(connection, &policy, &pending.database, &pending.statement, false) {
|
||
Ok(permissions) => permissions,
|
||
Err(error) => return error,
|
||
};
|
||
let mut arguments = json!({ "sql": pending.statement, "limit": 1 });
|
||
if let Some(secs) = resolved.policy.query_timeout_secs {
|
||
arguments["timeout_secs"] = json!(secs);
|
||
}
|
||
let label = salesforce_write_label(&pending.statement);
|
||
let started_at = Instant::now();
|
||
let result = self
|
||
.backend
|
||
.execute_agent_tool(connection, &pending.database, "execute_query", arguments, permissions)
|
||
.await;
|
||
let success = !result.is_error;
|
||
let error = result.is_error.then(|| result.content.trim_start_matches("Error: ").to_string());
|
||
self.save_mcp_sql_history(
|
||
"dbx_salesforce_apply_write",
|
||
connection,
|
||
&pending.database,
|
||
&pending.statement,
|
||
started_at,
|
||
success,
|
||
error,
|
||
None,
|
||
)
|
||
.await;
|
||
if !success {
|
||
return agent_result(result);
|
||
}
|
||
text(format!("Salesforce write applied: {label}.\n{}", result.content))
|
||
}
|
||
}
|
||
|
||
impl DbxMcpServer {
|
||
async fn list_databases_for_resolved(&self, resolved: &ResolvedConnection) -> CallToolResult {
|
||
if resolved.connection.db_type == DatabaseType::Salesforce
|
||
&& !matches!(resolved.database_scope, DatabaseScope::None)
|
||
{
|
||
// An org has no database layer, so an empty list would read as a
|
||
// broken connection. Point at the surface that does exist instead.
|
||
return text(
|
||
"Salesforce has no databases: the whole org is one scope.\n\
|
||
List its objects with dbx_list_tables, then read them with dbx_execute_query using SOQL, e.g. SELECT Id, Name FROM Account LIMIT 10.\n\
|
||
Writes go through dbx_salesforce_prepare_write and dbx_salesforce_apply_write.",
|
||
);
|
||
}
|
||
match &resolved.database_scope {
|
||
DatabaseScope::None => tool_error(
|
||
"DATABASE_OUT_OF_SCOPE",
|
||
"This connection is configured with no database access in DBX MCP settings.",
|
||
),
|
||
DatabaseScope::Selected(databases) => text(format_database_names(databases)),
|
||
DatabaseScope::All => match self.backend.list_databases(&resolved.connection).await {
|
||
Ok(databases) => text(format_database_names(&databases)),
|
||
Err(error) => tool_error("DATABASE_LIST_ERROR", error),
|
||
},
|
||
}
|
||
}
|
||
|
||
async fn load_scoped_connections(&self) -> Result<Vec<dbx_core::models::connection::ConnectionConfig>, String> {
|
||
let policy = self.backend.load_mcp_global_policy().await?;
|
||
let connections = self.backend.load_connections().await?;
|
||
let group_paths = self.load_group_paths_for_policy(&policy).await?;
|
||
Ok(connections
|
||
.into_iter()
|
||
.filter(|connection| policy_allows_connection(&policy, group_paths.get(&connection.id), connection))
|
||
.filter(|connection| !self.scope.connection_scope_enabled() || self.scope.matches(connection))
|
||
.collect())
|
||
}
|
||
|
||
async fn load_group_paths_for_policy(
|
||
&self,
|
||
policy: &McpGlobalPolicy,
|
||
) -> Result<HashMap<String, dbx_core::mcp_policy::McpConnectionGroupPath>, String> {
|
||
match self.backend.load_connection_group_details().await {
|
||
Ok(paths) => Ok(paths),
|
||
Err(error) if dbx_core::mcp_policy::policy_uses_connection_groups(policy) => {
|
||
Err(format!("MCP_POLICY_UNAVAILABLE: {error}"))
|
||
}
|
||
Err(_) => Ok(HashMap::new()),
|
||
}
|
||
}
|
||
|
||
// CallToolResult is the rmcp wire response type; keeping it unboxed avoids conversions at every tool boundary.
|
||
#[allow(clippy::result_large_err)]
|
||
async fn load_policy(&self) -> Result<McpGlobalPolicy, CallToolResult> {
|
||
self.backend.load_mcp_global_policy().await.map_err(|error| backend_tool_error("MCP_POLICY_UNAVAILABLE", error))
|
||
}
|
||
|
||
// CallToolResult is the rmcp wire response type; keeping it unboxed avoids conversions at every tool boundary.
|
||
#[allow(clippy::result_large_err)]
|
||
async fn validate_transaction_control(&self, session: &McpSession, operation: &str) -> Result<(), CallToolResult> {
|
||
let resolved = self
|
||
.resolve_connection(&ConnectionSelector {
|
||
connection_id: Some(session.connection_id.clone()),
|
||
connection_name: None,
|
||
})
|
||
.await?;
|
||
if !transaction_connection_supported(&resolved.connection) {
|
||
return Err(tool_error(
|
||
"TRANSACTION_UNSUPPORTED",
|
||
"The session connection is no longer a native MySQL connection.",
|
||
));
|
||
}
|
||
ensure_database_in_scope(&resolved.database_scope, &session.database)?;
|
||
let policy = effective_policy_for_database_with_groups(
|
||
&resolved.policy,
|
||
&resolved.group_ids,
|
||
&resolved.connection,
|
||
&session.database,
|
||
);
|
||
if policy.read_only {
|
||
return Err(tool_error(
|
||
"MCP_READ_ONLY",
|
||
format!("MCP execution permission is read-only; {operation} is write-capable."),
|
||
));
|
||
}
|
||
if resolved.connection.read_only {
|
||
return Err(tool_error(
|
||
"CONNECTION_READ_ONLY",
|
||
format!("Connection \"{}\" is read-only; {operation} is blocked.", resolved.connection.name),
|
||
));
|
||
}
|
||
if is_production_database(&resolved.connection, &session.database) {
|
||
return Err(tool_error(
|
||
"PRODUCTION_WRITE_BLOCKED",
|
||
format!("{operation} is not allowed against a production database."),
|
||
));
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
// CallToolResult is the rmcp wire response type; keeping it unboxed avoids conversions at every tool boundary.
|
||
#[allow(clippy::result_large_err)]
|
||
async fn ensure_tool_allowed(&self, tool_name: &str) -> Result<(), CallToolResult> {
|
||
let policy = self.load_policy().await?;
|
||
if policy_allows_tool(&policy, tool_name) {
|
||
Ok(())
|
||
} else {
|
||
Err(tool_error("TOOL_OUT_OF_SCOPE", format!("Tool \"{tool_name}\" is not allowed by DBX MCP settings.")))
|
||
}
|
||
}
|
||
|
||
/// The advertised `tools/list` view: router-enabled tools narrowed to the
|
||
/// global policy's tool allowlist, plus the automatically exposed plugin
|
||
/// tools (`dbx_<prefix>__<tool>`). When the policy cannot be loaded every
|
||
/// tool call already fails with `MCP_POLICY_UNAVAILABLE`, so fall back to
|
||
/// the plain router view rather than adding a new failure mode here.
|
||
pub async fn policy_filtered_tools(&self) -> Vec<rmcp::model::Tool> {
|
||
let policy = self.load_policy().await.ok();
|
||
let mut tools: Vec<rmcp::model::Tool> = match &policy {
|
||
Some(policy) => self
|
||
.tool_router
|
||
.list_all()
|
||
.into_iter()
|
||
.filter(|tool| policy_allows_tool(policy, tool.name.as_ref()))
|
||
.collect(),
|
||
None => self.tool_router.list_all(),
|
||
};
|
||
if self.plugin_tools_mode.advertise_flat() {
|
||
tools.extend(self.plugin_tools_view(policy.as_ref()).await);
|
||
}
|
||
tools
|
||
}
|
||
|
||
// CallToolResult is the rmcp wire response type; keeping it unboxed avoids conversions at every tool boundary.
|
||
#[allow(clippy::result_large_err)]
|
||
fn resolve_database(
|
||
&self,
|
||
requested: Option<String>,
|
||
resolved: &ResolvedConnection,
|
||
) -> Result<String, CallToolResult> {
|
||
let requested = requested.map(|database| database.trim().to_string()).filter(|database| !database.is_empty());
|
||
let database = if let Some(scoped) = self.scope.database.as_deref() {
|
||
if let Some(requested) = requested.as_deref() {
|
||
if requested != scoped {
|
||
return Err(tool_error(
|
||
"DATABASE_OUT_OF_SCOPE",
|
||
format!("Database \"{requested}\" is outside the scoped database \"{scoped}\"."),
|
||
));
|
||
}
|
||
}
|
||
scoped.to_string()
|
||
} else {
|
||
requested.or_else(|| resolved.connection.database.clone()).unwrap_or_default()
|
||
};
|
||
ensure_database_in_scope(&resolved.database_scope, &database)?;
|
||
Ok(database)
|
||
}
|
||
|
||
/// Resolve the schema for scoped CLI agents. A selected schema is a hard
|
||
/// bound, matching the existing database scope behavior.
|
||
#[allow(clippy::result_large_err)]
|
||
fn resolve_schema(&self, requested: Option<String>) -> Result<String, CallToolResult> {
|
||
let requested = requested.map(|schema| schema.trim().to_string()).filter(|schema| !schema.is_empty());
|
||
if let Some(scoped) = self.scope.schema.as_deref() {
|
||
if let Some(requested) = requested.as_deref() {
|
||
if requested != scoped {
|
||
return Err(tool_error(
|
||
"SCHEMA_OUT_OF_SCOPE",
|
||
format!("Schema \"{requested}\" is outside the scoped schema \"{scoped}\"."),
|
||
));
|
||
}
|
||
}
|
||
return Ok(scoped.to_string());
|
||
}
|
||
Ok(requested.unwrap_or_default())
|
||
}
|
||
|
||
// CallToolResult is the rmcp wire response type; keeping it unboxed avoids conversions at every tool boundary.
|
||
#[allow(clippy::result_large_err)]
|
||
fn resolve_redis_database(
|
||
&self,
|
||
requested: Option<u32>,
|
||
resolved: &ResolvedConnection,
|
||
) -> Result<u32, CallToolResult> {
|
||
if let Some(scoped) = self.scope.database.as_deref() {
|
||
let scoped_database = parse_redis_database(scoped).ok_or_else(|| {
|
||
tool_error(
|
||
"INVALID_DATABASE_SCOPE",
|
||
format!("Redis database scope \"{scoped}\" must be a non-negative integer."),
|
||
)
|
||
})?;
|
||
if let Some(requested) = requested {
|
||
if requested != scoped_database {
|
||
return Err(tool_error(
|
||
"DATABASE_OUT_OF_SCOPE",
|
||
format!("Redis database {requested} is outside the scoped database {scoped_database}."),
|
||
));
|
||
}
|
||
}
|
||
ensure_database_in_scope(&resolved.database_scope, &scoped_database.to_string())?;
|
||
return Ok(scoped_database);
|
||
}
|
||
let database = requested.or_else(|| redis_database(&resolved.connection)).unwrap_or(0);
|
||
ensure_database_in_scope(&resolved.database_scope, &database.to_string())?;
|
||
Ok(database)
|
||
}
|
||
|
||
// CallToolResult is the rmcp wire response type; keeping it unboxed avoids conversions at every tool boundary.
|
||
#[allow(clippy::result_large_err)]
|
||
async fn resolve_connection(&self, selector: &ConnectionSelector) -> Result<ResolvedConnection, CallToolResult> {
|
||
let policy = self.load_policy().await?;
|
||
let group_paths = self
|
||
.load_group_paths_for_policy(&policy)
|
||
.await
|
||
.map_err(|error| backend_tool_error("MCP_POLICY_UNAVAILABLE", error))?;
|
||
let connections =
|
||
self.backend.load_connections().await.map_err(|error| tool_error("CONNECTION_LOAD_ERROR", error))?;
|
||
if let Some(id) = selector.connection_id.as_deref().map(str::trim).filter(|id| !id.is_empty()) {
|
||
let connection = connections
|
||
.into_iter()
|
||
.find(|connection| connection.id == id)
|
||
.ok_or_else(|| tool_error("CONNECTION_NOT_FOUND", format!("Connection with id \"{id}\" not found.")))?;
|
||
if self.scope.connection_scope_enabled() && !self.scope.matches(&connection) {
|
||
return Err(tool_error(
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
format!("Connection \"{id}\" is outside this DBX AI session scope."),
|
||
));
|
||
}
|
||
if !policy_allows_connection(&policy, group_paths.get(&connection.id), &connection) {
|
||
return Err(tool_error(
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
format!("Connection \"{id}\" is not allowed by DBX MCP settings."),
|
||
));
|
||
}
|
||
return Ok(resolved_connection(policy, connection, group_paths.get(id)));
|
||
}
|
||
if self.scope.connection_scope_enabled() {
|
||
let connection = connections
|
||
.into_iter()
|
||
.find(|connection| self.scope.matches(connection))
|
||
.ok_or_else(|| tool_error("CONNECTION_NOT_FOUND", "Scoped DBX connection was not found."))?;
|
||
if let Some(name) = selector.connection_name.as_deref().map(str::trim).filter(|name| !name.is_empty()) {
|
||
if name != connection.name && name != connection.id {
|
||
return Err(tool_error(
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
format!("Connection \"{name}\" is outside this DBX AI session scope."),
|
||
));
|
||
}
|
||
}
|
||
if !policy_allows_connection(&policy, group_paths.get(&connection.id), &connection) {
|
||
return Err(tool_error(
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
"The DBX AI session scope is outside the global MCP connection allowlist.",
|
||
));
|
||
}
|
||
let path = group_paths.get(&connection.id);
|
||
return Ok(resolved_connection(policy, connection, path));
|
||
}
|
||
let Some(name) = selector.connection_name.as_deref().map(str::trim).filter(|name| !name.is_empty()) else {
|
||
return Err(tool_error("CONNECTION_NOT_FOUND", "Either connection_id or connection_name is required."));
|
||
};
|
||
let matching =
|
||
connections.into_iter().filter(|connection| connection.name.eq_ignore_ascii_case(name)).collect::<Vec<_>>();
|
||
let allowed = matching
|
||
.iter()
|
||
.filter(|connection| policy_allows_connection(&policy, group_paths.get(&connection.id), connection))
|
||
.cloned()
|
||
.collect::<Vec<_>>();
|
||
match allowed.as_slice() {
|
||
[] if matching.is_empty() => {
|
||
Err(tool_error("CONNECTION_NOT_FOUND", format!("Connection \"{name}\" not found.")))
|
||
}
|
||
[] => Err(tool_error(
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
format!("Connection \"{name}\" is not allowed by DBX MCP settings."),
|
||
)),
|
||
[connection] => Ok(resolved_connection(policy, connection.clone(), group_paths.get(&connection.id))),
|
||
_ => Err(tool_error("AMBIGUOUS_CONNECTION", ambiguous_connections(name, &allowed))),
|
||
}
|
||
}
|
||
/// Saved plugin connections the global MCP policy (and a scoped CLI/AI
|
||
/// session) allows, grouped per owning plugin. Used both to decorate the
|
||
/// exposed plugin tools with a connection selector and to bind calls.
|
||
/// Connections not in the map are unreachable through plugin tools.
|
||
#[allow(clippy::result_large_err)]
|
||
async fn allowed_plugin_connections(
|
||
&self,
|
||
) -> Result<std::collections::BTreeMap<String, Vec<(String, String)>>, CallToolResult> {
|
||
let policy = self.load_policy().await?;
|
||
let group_paths = self
|
||
.load_group_paths_for_policy(&policy)
|
||
.await
|
||
.map_err(|error| backend_tool_error("MCP_POLICY_UNAVAILABLE", error))?;
|
||
let connections =
|
||
self.backend.load_connections().await.map_err(|error| tool_error("CONNECTION_LOAD_ERROR", error))?;
|
||
let mut allowed: std::collections::BTreeMap<String, Vec<(String, String)>> = std::collections::BTreeMap::new();
|
||
for config in connections {
|
||
let Some(plugin_id) = config.plugin_id.as_deref().map(str::trim).filter(|id| !id.is_empty()) else {
|
||
continue;
|
||
};
|
||
if self.scope.connection_scope_enabled() && !self.scope.matches(&config) {
|
||
continue;
|
||
}
|
||
if !policy_allows_connection(&policy, group_paths.get(&config.id), &config) {
|
||
continue;
|
||
}
|
||
allowed.entry(plugin_id.to_string()).or_default().push((config.id.clone(), config.name.clone()));
|
||
}
|
||
for list in allowed.values_mut() {
|
||
list.sort();
|
||
}
|
||
Ok(allowed)
|
||
}
|
||
|
||
/// The plugin portion of the advertised `tools/list`. Discovery failures
|
||
/// degrade to an empty view (the static tools keep working); the global
|
||
/// policy's tool allowlist narrows exposed plugin names exactly like the
|
||
/// static ones. In a scoped session only plugins with at least one
|
||
/// in-scope connection are listed, matching the scoped dbx_* behavior.
|
||
async fn plugin_tools_view(&self, policy: Option<&McpGlobalPolicy>) -> Vec<rmcp::model::Tool> {
|
||
let providers = match self.backend.list_plugin_mcp_tools().await {
|
||
Ok(providers) => providers,
|
||
Err(error) => {
|
||
log::debug!("[mcp][plugin-tools] no plugin tools on this backend: {error}");
|
||
return Vec::new();
|
||
}
|
||
};
|
||
let entries = crate::plugin_tools::build_catalog(&providers);
|
||
// Tool calls fail closed on policy errors anyway; keep the view.
|
||
let allowed = self.allowed_plugin_connections().await.unwrap_or_default();
|
||
entries
|
||
.into_iter()
|
||
.filter(|entry| policy.is_none_or(|policy| policy_allows_tool(policy, &entry.exposed_name)))
|
||
.filter(|entry| !self.scope.enabled() || allowed.contains_key(&entry.plugin_id))
|
||
.map(|entry| {
|
||
let connections = allowed.get(&entry.plugin_id).cloned().unwrap_or_default();
|
||
crate::plugin_tools::to_rmcp_tool(&entry, &connections)
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// Dispatches a plugin-tool call (`dbx_<prefix>__<tool>`): policy check,
|
||
/// name resolution over a fresh discovery pass, host-side connection
|
||
/// binding from the policy-allowed set, and lifecycle generation from the
|
||
/// saved connection in the backend — credentials never reach the caller.
|
||
#[allow(clippy::result_large_err)]
|
||
pub async fn call_plugin_tool_dispatch(
|
||
&self,
|
||
name: &str,
|
||
mut arguments: serde_json::Value,
|
||
) -> Result<CallToolResult, ErrorData> {
|
||
if let Err(error) = self.ensure_tool_allowed(name).await {
|
||
return Ok(error);
|
||
}
|
||
let providers = match self.backend.list_plugin_mcp_tools().await {
|
||
Ok(providers) => providers,
|
||
Err(error) => return Ok(backend_tool_error("DBX_TOOL_ERROR", error)),
|
||
};
|
||
let entry = crate::plugin_tools::build_catalog(&providers).into_iter().find(|entry| entry.exposed_name == name);
|
||
let Some(entry) = entry else {
|
||
return Ok(tool_error("TOOL_NOT_FOUND", format!("Plugin tool \"{name}\" is not available.")));
|
||
};
|
||
let selector = crate::plugin_tools::connection_selector_from(&arguments).map(str::to_string);
|
||
if let Some(object) = arguments.as_object_mut() {
|
||
for key in crate::plugin_tools::CONNECTION_SELECTOR_ARGUMENTS {
|
||
object.remove(*key);
|
||
}
|
||
}
|
||
let allowed = match self.allowed_plugin_connections().await {
|
||
Ok(allowed) => allowed.get(&entry.plugin_id).cloned().unwrap_or_default(),
|
||
Err(error) => return Ok(error),
|
||
};
|
||
let bound = match crate::plugin_tools::select_connection(&allowed, selector.as_deref()) {
|
||
Ok(bound) => bound.cloned(),
|
||
Err(message) => return Ok(tool_error("CONNECTION_NOT_FOUND", message)),
|
||
};
|
||
if let Some((connection_id, connection_name)) = &bound {
|
||
let _ = CALL_HISTORY.try_with(|history| {
|
||
let mut history = history.lock().unwrap();
|
||
history.connection_id.clone_from(connection_id);
|
||
history.connection_name.clone_from(connection_name);
|
||
});
|
||
}
|
||
if entry.injects_connection_id {
|
||
if let Some((connection_id, _)) = &bound {
|
||
if let Some(object) = arguments.as_object_mut() {
|
||
object.insert("connectionId".to_string(), serde_json::Value::String(connection_id.clone()));
|
||
}
|
||
}
|
||
}
|
||
match self
|
||
.backend
|
||
.call_plugin_mcp_tool(
|
||
&entry.plugin_id,
|
||
&entry.tool.name,
|
||
bound.as_ref().map(|(connection_id, _)| connection_id.as_str()),
|
||
&arguments,
|
||
)
|
||
.await
|
||
{
|
||
Ok(value) => Ok(crate::plugin_tools::call_result_to_rmcp(value)),
|
||
Err(error) => Ok(backend_tool_error("DBX_TOOL_ERROR", error)),
|
||
}
|
||
}
|
||
|
||
/// Loaded plugin-tool catalog for the meta tools: `(plugin id, name,
|
||
/// tool count, allowed-connection count)` rows plus an optional note
|
||
/// when policy filtering hid plugins. Discovery errors degrade to a
|
||
/// note instead of failing `dbx_plugin_list`.
|
||
async fn plugin_tool_catalog(
|
||
&self,
|
||
) -> Result<(Vec<(String, String, usize, usize)>, Option<String>), CallToolResult> {
|
||
let providers = match self.backend.list_plugin_mcp_tools().await {
|
||
Ok(providers) => providers,
|
||
Err(error) => {
|
||
return Ok((Vec::new(), Some(format!("Plugin tools are unavailable: {error}"))));
|
||
}
|
||
};
|
||
// The catalog computes the real (possibly extended) exposed names, so
|
||
// the allowlist check below uses exactly the names a flat tools/list
|
||
// would advertise.
|
||
let entries = crate::plugin_tools::build_catalog(&providers);
|
||
// Listing degrades on policy errors the same way the flat view does;
|
||
// `dbx_plugin_tools`/`dbx_plugin_call` still fail closed.
|
||
let allowed = self.allowed_plugin_connections().await.unwrap_or_default();
|
||
let policy = self.load_policy().await.ok();
|
||
let mut grouped: std::collections::BTreeMap<String, (String, usize, bool)> = Default::default();
|
||
for entry in &entries {
|
||
let record =
|
||
grouped.entry(entry.plugin_id.clone()).or_insert_with(|| (entry.plugin_name.clone(), 0, false));
|
||
record.1 += 1;
|
||
if policy.as_ref().is_none_or(|policy| policy_allows_tool(policy, &entry.exposed_name)) {
|
||
record.2 = true;
|
||
}
|
||
}
|
||
let mut rows = Vec::new();
|
||
let mut hidden = 0usize;
|
||
for (plugin_id, (plugin_name, tool_count, any_allowed)) in grouped {
|
||
if any_allowed {
|
||
let connections = allowed.get(&plugin_id).map_or(0, Vec::len);
|
||
rows.push((plugin_id, plugin_name, tool_count, connections));
|
||
} else {
|
||
hidden += 1;
|
||
}
|
||
}
|
||
let note = (hidden > 0).then(|| format!("{hidden} plugin(s) are hidden by the DBX MCP tool allowlist."));
|
||
Ok((rows, note))
|
||
}
|
||
|
||
/// Resolves the policy-allowed connections of one plugin for the meta
|
||
/// tools. Fails closed on policy errors (same as flat calls).
|
||
async fn allowed_plugin_connections_for(&self, plugin_id: &str) -> Result<Vec<(String, String)>, CallToolResult> {
|
||
let allowed = self.allowed_plugin_connections().await?;
|
||
Ok(allowed.get(plugin_id).cloned().unwrap_or_default())
|
||
}
|
||
|
||
/// Shared call core for `dbx_plugin_call`: locates the tool by
|
||
/// `(plugin_id, tool name)` over a fresh discovery pass, strips
|
||
/// selector arguments, binds the connection, and forwards to the
|
||
/// backend. Returns the raw plugin answer for the caller to render.
|
||
async fn call_plugin_by_id(
|
||
&self,
|
||
plugin_id: &str,
|
||
tool: &str,
|
||
mut arguments: serde_json::Value,
|
||
) -> Result<serde_json::Value, CallToolResult> {
|
||
let providers = match self.backend.list_plugin_mcp_tools().await {
|
||
Ok(providers) => providers,
|
||
Err(error) => return Err(backend_tool_error("DBX_TOOL_ERROR", error)),
|
||
};
|
||
let entry = crate::plugin_tools::build_catalog(&providers)
|
||
.into_iter()
|
||
.find(|entry| entry.plugin_id == plugin_id && entry.tool.name == tool);
|
||
let Some(entry) = entry else {
|
||
return Err(tool_error(
|
||
"TOOL_NOT_FOUND",
|
||
format!(
|
||
"Plugin \"{plugin_id}\" does not provide a tool named \"{tool}\". Use dbx_plugin_tools to list this plugin's tools."
|
||
),
|
||
));
|
||
};
|
||
// Lazy calls are governed by the same per-tool allowlist as the flat
|
||
// surface: gate on the exposed name so an allowlist cannot be bypassed
|
||
// by addressing a tool through its plugin id instead.
|
||
self.ensure_tool_allowed(&entry.exposed_name).await?;
|
||
let selector = crate::plugin_tools::connection_selector_from(&arguments).map(str::to_string);
|
||
if let Some(object) = arguments.as_object_mut() {
|
||
for key in crate::plugin_tools::CONNECTION_SELECTOR_ARGUMENTS {
|
||
object.remove(*key);
|
||
}
|
||
}
|
||
let allowed = match self.allowed_plugin_connections().await {
|
||
Ok(allowed) => allowed.get(plugin_id).cloned().unwrap_or_default(),
|
||
Err(error) => return Err(error),
|
||
};
|
||
let bound = match crate::plugin_tools::select_connection(&allowed, selector.as_deref()) {
|
||
Ok(bound) => bound.cloned(),
|
||
Err(message) => return Err(tool_error("CONNECTION_NOT_FOUND", message)),
|
||
};
|
||
if let Some((connection_id, connection_name)) = &bound {
|
||
let _ = CALL_HISTORY.try_with(|history| {
|
||
let mut history = history.lock().unwrap();
|
||
history.connection_id.clone_from(connection_id);
|
||
history.connection_name.clone_from(connection_name);
|
||
});
|
||
}
|
||
if entry.injects_connection_id {
|
||
if let Some((connection_id, _)) = &bound {
|
||
if let Some(object) = arguments.as_object_mut() {
|
||
object.insert("connectionId".to_string(), serde_json::Value::String(connection_id.clone()));
|
||
}
|
||
}
|
||
}
|
||
self.backend
|
||
.call_plugin_mcp_tool(
|
||
plugin_id,
|
||
tool,
|
||
bound.as_ref().map(|(connection_id, _)| connection_id.as_str()),
|
||
&arguments,
|
||
)
|
||
.await
|
||
.map_err(|error| backend_tool_error("DBX_TOOL_ERROR", error))
|
||
}
|
||
|
||
/// Renders a `dbx_plugin_call` answer: converts the plugin result,
|
||
/// appends a connection hint when the caller must pick one explicitly.
|
||
async fn postprocess_plugin_result(
|
||
&self,
|
||
plugin_id: &str,
|
||
tool: &str,
|
||
requested_selector: &Option<String>,
|
||
value: serde_json::Value,
|
||
) -> CallToolResult {
|
||
let mut result = crate::plugin_tools::call_result_to_rmcp(value);
|
||
if requested_selector.is_none() {
|
||
if let Ok(allowed) = self.allowed_plugin_connections_for(plugin_id).await {
|
||
if allowed.len() > 1 {
|
||
let choices =
|
||
allowed.iter().map(|(id, name)| format!("{id} = {name}")).collect::<Vec<_>>().join("; ");
|
||
let hint = format!(
|
||
"\n[This plugin has several allowed connections; pass dbx_connection to choose: {choices}]"
|
||
);
|
||
result.content.push(rmcp::model::ContentBlock::text(hint));
|
||
}
|
||
}
|
||
}
|
||
let _ = (plugin_id, tool);
|
||
result
|
||
}
|
||
}
|
||
|
||
#[tool_handler(router = self.tool_router)]
|
||
impl ServerHandler for DbxMcpServer {
|
||
async fn call_tool(
|
||
&self,
|
||
request: rmcp::model::CallToolRequestParams,
|
||
context: rmcp::service::RequestContext<rmcp::RoleServer>,
|
||
) -> Result<CallToolResult, rmcp::ErrorData> {
|
||
let started = Instant::now();
|
||
let args = serde_json::Value::Object(request.arguments.clone().unwrap_or_default());
|
||
let arg = |name: &str| args.get(name).and_then(|value| value.as_str()).unwrap_or_default().to_string();
|
||
let entry = HistoryEntry {
|
||
id: Uuid::new_v4().to_string(),
|
||
connection_id: arg("connection_id"),
|
||
connection_name: arg("connection_name"),
|
||
database: arg("database"),
|
||
sql: arg("sql"),
|
||
executed_at: chrono::Utc::now().to_rfc3339(),
|
||
execution_time_ms: 0,
|
||
success: false,
|
||
error: None,
|
||
activity_kind: "mcp".into(),
|
||
operation: request.name.to_string(),
|
||
target: arg("table"),
|
||
affected_rows: None,
|
||
rollback_sql: None,
|
||
details_json: Some(r#"{"source":"mcp"}"#.into()),
|
||
source: "mcp".into(),
|
||
mcp_tool_name: Some(request.name.to_string()),
|
||
mcp_request_json: Some(bounded_history_request(&args)),
|
||
mcp_response_json: None,
|
||
mcp_session_id: args.get("session_id").and_then(|v| v.as_str()).map(str::to_owned),
|
||
};
|
||
let mut guard = CallHistoryGuard { backend: self.backend.clone(), fallback: Some(entry.clone()), started };
|
||
let tool_name = request.name.to_string();
|
||
let is_plugin_tool = crate::plugin_tools::is_plugin_tool_name(&tool_name);
|
||
CALL_HISTORY.scope(std::sync::Mutex::new(entry), async {
|
||
let cancellation = context.ct.clone();
|
||
let result = if is_plugin_tool {
|
||
tokio::select! {
|
||
result = self.call_plugin_tool_dispatch(&tool_name, args) => result,
|
||
_ = cancellation.cancelled() => Ok(tool_error("REQUEST_CANCELLED", "The MCP request was cancelled.")),
|
||
}
|
||
} else {
|
||
let tcc = rmcp::handler::server::tool::ToolCallContext::new(self, request, context);
|
||
tokio::select! {
|
||
result = self.tool_router.call(tcc) => result,
|
||
_ = cancellation.cancelled() => Ok(tool_error("REQUEST_CANCELLED", "The MCP request was cancelled.")),
|
||
}
|
||
};
|
||
let mut entry = CALL_HISTORY.with(|entry| entry.lock().unwrap().clone());
|
||
entry.execution_time_ms = started.elapsed().as_millis();
|
||
entry.success = result.as_ref().is_ok_and(|result| result.is_error != Some(true));
|
||
// Keep the complete response within a bounded, redacted payload so
|
||
// the history detail view can be used for troubleshooting without
|
||
// allowing a large result to grow the local database indefinitely.
|
||
entry.mcp_response_json = Some(match &result {
|
||
Ok(result) => bounded_history_response(result),
|
||
Err(error) => bounded_history_response(error),
|
||
});
|
||
if !entry.success {
|
||
entry.error = Some(if cancellation.is_cancelled() { "MCP request cancelled" } else { "MCP tool call failed (see response summary)" }.into());
|
||
}
|
||
// Persist in a separate task so cancellation during the write cannot
|
||
// lose the record or schedule a second write from the drop guard.
|
||
guard.fallback = None;
|
||
let backend = self.backend.clone();
|
||
let write = tokio::spawn(async move {
|
||
if let Err(error) = backend.save_history_entry(&entry).await {
|
||
log::warn!("failed to save MCP call history: {error}");
|
||
}
|
||
});
|
||
let _ = write.await;
|
||
result
|
||
}).await
|
||
}
|
||
|
||
fn get_info(&self) -> ServerInfo {
|
||
ServerInfo::new(ServerCapabilities::builder().enable_tools().enable_resources().build())
|
||
.with_server_info(Implementation::new("dbx", env!("CARGO_PKG_VERSION")))
|
||
.with_instructions("Use DBX connections to inspect schemas and query databases safely.")
|
||
}
|
||
|
||
async fn list_resources(
|
||
&self,
|
||
_request: Option<rmcp::model::PaginatedRequestParams>,
|
||
_context: rmcp::service::RequestContext<rmcp::service::RoleServer>,
|
||
) -> Result<ListResourcesResult, ErrorData> {
|
||
let tools = self.policy_filtered_tools().await;
|
||
let resources = tools
|
||
.iter()
|
||
.any(|tool| tool.name.as_ref() == "dbx_list_connections")
|
||
.then(|| {
|
||
Resource::new(CONNECTIONS_RESOURCE_URI, "dbx_connections")
|
||
.with_title("DBX connections")
|
||
.with_description("Database connections visible to the current DBX MCP scope")
|
||
.with_mime_type("text/markdown")
|
||
})
|
||
.into_iter()
|
||
.collect();
|
||
Ok(ListResourcesResult { resources, meta: None, next_cursor: None })
|
||
}
|
||
|
||
async fn list_resource_templates(
|
||
&self,
|
||
_request: Option<rmcp::model::PaginatedRequestParams>,
|
||
_context: rmcp::service::RequestContext<rmcp::service::RoleServer>,
|
||
) -> Result<ListResourceTemplatesResult, ErrorData> {
|
||
let tools = self.policy_filtered_tools().await;
|
||
let has_tool = |name: &str| tools.iter().any(|tool| tool.name.as_ref() == name);
|
||
let mut resource_templates = Vec::new();
|
||
if has_tool("dbx_list_databases") {
|
||
resource_templates.push(
|
||
ResourceTemplate::new(DATABASES_RESOURCE_TEMPLATE, "dbx_connection_databases")
|
||
.with_title("DBX connection databases")
|
||
.with_description("Databases visible through a DBX connection")
|
||
.with_mime_type("text/markdown"),
|
||
);
|
||
}
|
||
if has_tool("dbx_list_tables") {
|
||
resource_templates.push(
|
||
ResourceTemplate::new(TABLES_RESOURCE_TEMPLATE, "dbx_connection_tables")
|
||
.with_title("DBX connection tables")
|
||
.with_description("Tables and views visible through a DBX connection and optional database/schema")
|
||
.with_mime_type("text/markdown"),
|
||
);
|
||
}
|
||
if has_tool("dbx_describe_table") {
|
||
resource_templates.push(
|
||
ResourceTemplate::new(TABLE_SCHEMA_RESOURCE_TEMPLATE, "dbx_table_schema")
|
||
.with_title("DBX table schema")
|
||
.with_description("Column definitions for a table visible through a DBX connection")
|
||
.with_mime_type("text/markdown"),
|
||
);
|
||
}
|
||
Ok(ListResourceTemplatesResult { resource_templates, meta: None, next_cursor: None })
|
||
}
|
||
|
||
async fn read_resource(
|
||
&self,
|
||
request: ReadResourceRequestParams,
|
||
_context: rmcp::service::RequestContext<rmcp::service::RoleServer>,
|
||
) -> Result<ReadResourceResult, ErrorData> {
|
||
let uri = request.uri;
|
||
let result = match parse_dbx_resource_uri(&uri)? {
|
||
DbxResourceRequest::Connections => self.list_connections(Parameters(ListConnectionsRequest {})).await,
|
||
DbxResourceRequest::Databases { connection_id } => {
|
||
self.list_databases(Parameters(ListDatabasesRequest {
|
||
selector: ConnectionSelector { connection_id: Some(connection_id), connection_name: None },
|
||
}))
|
||
.await
|
||
}
|
||
DbxResourceRequest::Tables { connection_id, database, schema } => {
|
||
self.list_tables(Parameters(ListTablesRequest {
|
||
selector: ConnectionSelector { connection_id: Some(connection_id), connection_name: None },
|
||
database,
|
||
schema,
|
||
}))
|
||
.await
|
||
}
|
||
DbxResourceRequest::TableSchema { connection_id, database, schema, table } => {
|
||
self.describe_table(Parameters(DescribeTableRequest {
|
||
selector: ConnectionSelector { connection_id: Some(connection_id), connection_name: None },
|
||
table,
|
||
database,
|
||
schema,
|
||
}))
|
||
.await
|
||
}
|
||
};
|
||
resource_result_from_tool(uri, result)
|
||
}
|
||
|
||
/// Hide tools the global policy disallows from the advertised list, the
|
||
/// same way scope-based route disabling does. Per-call enforcement stays
|
||
/// in `ensure_tool_allowed`; this only stops clients (especially LLMs)
|
||
/// from seeing — and repeatedly retrying — capabilities that would be
|
||
/// rejected anyway. When the policy cannot be loaded, every call already
|
||
/// fails with `MCP_POLICY_UNAVAILABLE`, so the listing falls back to the
|
||
/// router view instead of adding a new failure mode here.
|
||
async fn list_tools(
|
||
&self,
|
||
_request: Option<rmcp::model::PaginatedRequestParams>,
|
||
_context: rmcp::service::RequestContext<rmcp::service::RoleServer>,
|
||
) -> Result<rmcp::model::ListToolsResult, rmcp::ErrorData> {
|
||
Ok(rmcp::model::ListToolsResult { tools: self.policy_filtered_tools().await, meta: None, next_cursor: None })
|
||
}
|
||
}
|
||
|
||
fn parse_dbx_resource_uri(uri: &str) -> Result<DbxResourceRequest, ErrorData> {
|
||
let parsed = Url::parse(uri).map_err(|_| ErrorData::invalid_params("Invalid DBX resource URI.", None))?;
|
||
if parsed.scheme() != "dbx"
|
||
|| parsed.host_str() != Some("connections")
|
||
|| !parsed.username().is_empty()
|
||
|| parsed.password().is_some()
|
||
|| parsed.port().is_some()
|
||
|| parsed.fragment().is_some()
|
||
{
|
||
return Err(ErrorData::resource_not_found(format!("Unknown DBX resource: {uri}"), None));
|
||
}
|
||
|
||
let path = parsed.path().trim_matches('/');
|
||
let segments = if path.is_empty() { Vec::new() } else { path.split('/').collect::<Vec<_>>() };
|
||
let mut query = HashMap::new();
|
||
for (key, value) in parsed.query_pairs() {
|
||
let key = key.into_owned();
|
||
if query.insert(key.clone(), value.into_owned()).is_some() {
|
||
return Err(ErrorData::invalid_params(format!("Duplicate DBX resource parameter: {key}"), None));
|
||
}
|
||
}
|
||
|
||
match segments.as_slice() {
|
||
[] => {
|
||
reject_resource_parameters(&query, &[])?;
|
||
Ok(DbxResourceRequest::Connections)
|
||
}
|
||
[connection_id, "databases"] => {
|
||
reject_resource_parameters(&query, &[])?;
|
||
Ok(DbxResourceRequest::Databases {
|
||
connection_id: required_resource_value("connection_id", connection_id)?,
|
||
})
|
||
}
|
||
[connection_id, "tables"] => {
|
||
reject_resource_parameters(&query, &["database", "schema"])?;
|
||
Ok(DbxResourceRequest::Tables {
|
||
connection_id: required_resource_value("connection_id", connection_id)?,
|
||
database: optional_resource_parameter(&query, "database"),
|
||
schema: optional_resource_parameter(&query, "schema"),
|
||
})
|
||
}
|
||
[connection_id, "table-schema"] => {
|
||
reject_resource_parameters(&query, &["database", "schema", "table"])?;
|
||
Ok(DbxResourceRequest::TableSchema {
|
||
connection_id: required_resource_value("connection_id", connection_id)?,
|
||
database: optional_resource_parameter(&query, "database"),
|
||
schema: optional_resource_parameter(&query, "schema"),
|
||
table: required_resource_parameter(&query, "table")?,
|
||
})
|
||
}
|
||
_ => Err(ErrorData::resource_not_found(format!("Unknown DBX resource: {uri}"), None)),
|
||
}
|
||
}
|
||
|
||
fn reject_resource_parameters(parameters: &HashMap<String, String>, allowed: &[&str]) -> Result<(), ErrorData> {
|
||
if let Some(name) = parameters.keys().find(|name| !allowed.contains(&name.as_str())) {
|
||
return Err(ErrorData::invalid_params(format!("Unknown DBX resource parameter: {name}"), None));
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn optional_resource_parameter(parameters: &HashMap<String, String>, name: &str) -> Option<String> {
|
||
parameters.get(name).map(|value| value.trim()).filter(|value| !value.is_empty()).map(str::to_string)
|
||
}
|
||
|
||
fn required_resource_parameter(parameters: &HashMap<String, String>, name: &str) -> Result<String, ErrorData> {
|
||
optional_resource_parameter(parameters, name)
|
||
.ok_or_else(|| ErrorData::invalid_params(format!("Missing DBX resource parameter: {name}"), None))
|
||
}
|
||
|
||
fn required_resource_value(name: &str, value: &str) -> Result<String, ErrorData> {
|
||
let value = value.trim();
|
||
if value.is_empty() {
|
||
Err(ErrorData::invalid_params(format!("Missing DBX resource parameter: {name}"), None))
|
||
} else {
|
||
Ok(value.to_string())
|
||
}
|
||
}
|
||
|
||
fn resource_result_from_tool(uri: String, result: CallToolResult) -> Result<ReadResourceResult, ErrorData> {
|
||
let output = result
|
||
.content
|
||
.iter()
|
||
.filter_map(|content| content.as_text().map(|text| text.text.as_str()))
|
||
.collect::<Vec<_>>()
|
||
.join("\n");
|
||
if result.is_error == Some(true) {
|
||
let message = if output.is_empty() { "DBX resource read failed.".to_string() } else { output };
|
||
return Err(ErrorData::invalid_params(message, Some(json!({ "uri": uri }))));
|
||
}
|
||
if output.is_empty() {
|
||
return Err(ErrorData::internal_error("DBX resource returned no text content.", Some(json!({ "uri": uri }))));
|
||
}
|
||
Ok(ReadResourceResult::new(vec![ResourceContents::text(output, uri).with_mime_type("text/markdown")]))
|
||
}
|
||
|
||
fn text(value: impl Into<String>) -> CallToolResult {
|
||
CallToolResult::success(vec![ContentBlock::text(value)])
|
||
}
|
||
|
||
async fn cancellable_tool_call(
|
||
cancellation: tokio_util::sync::CancellationToken,
|
||
operation: impl std::future::Future<Output = CallToolResult>,
|
||
) -> CallToolResult {
|
||
tokio::select! {
|
||
result = operation => result,
|
||
_ = cancellation.cancelled() => tool_error("REQUEST_CANCELLED", "The MCP request was cancelled."),
|
||
}
|
||
}
|
||
|
||
fn transaction_success_result(session_id: &str, message: &str, execution: TransactionResult) -> CallToolResult {
|
||
let mut result = text(format!(
|
||
"{message}\nsession_id: {session_id}\ntransaction_state: {}{}",
|
||
execution.state.as_str(),
|
||
execution.outcome.map(|outcome| format!("\ntransaction_outcome: {}", outcome.as_str())).unwrap_or_default()
|
||
));
|
||
result.structured_content = Some(json!({
|
||
"session_id": session_id,
|
||
"transaction_state": execution.state,
|
||
"transaction_outcome": execution.outcome,
|
||
"result": execution.result,
|
||
}));
|
||
result
|
||
}
|
||
|
||
fn transaction_failure_result(session_id: &str, failure: TransactionFailure) -> CallToolResult {
|
||
let mut result = tool_error(failure.code, &failure.message);
|
||
result.structured_content = Some(json!({
|
||
"session_id": session_id,
|
||
"transaction_state": failure.state,
|
||
"transaction_outcome": failure.outcome,
|
||
"mysql_code": failure.mysql_code,
|
||
"error": failure.message,
|
||
}));
|
||
result
|
||
}
|
||
|
||
fn tool_error(code: &str, message: impl Into<String>) -> CallToolResult {
|
||
CallToolResult::error(vec![ContentBlock::text(format!("Error [{code}]: {}", message.into()))])
|
||
}
|
||
|
||
fn backend_tool_error(default_code: &str, error: impl Into<String>) -> CallToolResult {
|
||
let error = error.into();
|
||
for code in [
|
||
"MCP_POLICY_UNAVAILABLE",
|
||
"MCP_READ_ONLY",
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
"DATABASE_OUT_OF_SCOPE",
|
||
"DATABASE_EXECUTION_POLICY_OUT_OF_SCOPE",
|
||
"INVALID_DATABASE_SCOPE",
|
||
"CONNECTION_READ_ONLY",
|
||
"PRODUCTION_DATABASE_READ_ONLY",
|
||
"PRODUCTION_WRITE_BLOCKED",
|
||
"SQL_BLOCKED",
|
||
"TRANSACTION_UNSUPPORTED",
|
||
] {
|
||
let marker = format!("{code}:");
|
||
if let Some(index) = error.find(&marker) {
|
||
return tool_error(code, error[index + marker.len()..].trim());
|
||
}
|
||
}
|
||
tool_error(default_code, error)
|
||
}
|
||
|
||
/// Keep older MCP clients compatible with the original single-query tool when
|
||
/// they send a complete SQL script. The batch executor removes client-side
|
||
/// commands such as MySQL `DELIMITER` and preserves semicolons inside routine
|
||
/// bodies before dispatching statements to the database.
|
||
fn sql_requires_batch_execution(sql: &str, database_type: DatabaseType) -> bool {
|
||
if sql.lines().any(|line| line.trim_start().to_ascii_lowercase().starts_with("delimiter ")) {
|
||
return true;
|
||
}
|
||
dbx_core::sql::sql_execution_plan_for_database(sql, database_type).statements.len() > 1
|
||
}
|
||
|
||
/// Maximum rows returned per statement in a `dbx_execute_batch` call. The batch
|
||
/// executor is deliberately tighter than dbx_execute_query's default: a script
|
||
/// has many statements, so its row budget multiplies.
|
||
const BATCH_MAX_ROWS: usize = 100;
|
||
|
||
fn mcp_sql_activity_kind(sql: &str, database_type: DatabaseType) -> &'static str {
|
||
if database_type == DatabaseType::Salesforce {
|
||
// The generic path below derives the kind from SQL risk tiers, and the
|
||
// Salesforce tiers deliberately fail closed: an unscoped or unrecognized
|
||
// write lands in the DDL tier, which would file a record mutation under
|
||
// "schema_change". Every Salesforce statement is either a SOQL read or a
|
||
// DML write, so classify it as one unit instead.
|
||
return match classify_salesforce_statement_risk(sql) {
|
||
SalesforceStatementRisk::Read => "query",
|
||
SalesforceStatementRisk::ScopedWrite | SalesforceStatementRisk::OpaqueWrite => "data_change",
|
||
};
|
||
}
|
||
let risks = dbx_core::sql::sql_execution_plan_for_database(sql, database_type)
|
||
.statements
|
||
.into_iter()
|
||
.filter_map(|statement| classify_sql_risk_for_database(&statement, database_type).ok())
|
||
.collect::<Vec<_>>();
|
||
if risks.contains(&SqlRisk::Ddl) {
|
||
"schema_change"
|
||
} else if risks.contains(&SqlRisk::Write) {
|
||
"data_change"
|
||
} else {
|
||
"query"
|
||
}
|
||
}
|
||
|
||
fn mcp_sql_operation(sql: &str, database_type: DatabaseType) -> String {
|
||
if database_type == DatabaseType::Salesforce {
|
||
// Naming the DML verb keeps history readable; "DBX" (the first word of
|
||
// the pseudo-command header) would say nothing about what changed.
|
||
return match classify_salesforce_statement_risk(sql) {
|
||
SalesforceStatementRisk::Read => "SELECT".to_string(),
|
||
SalesforceStatementRisk::ScopedWrite | SalesforceStatementRisk::OpaqueWrite => {
|
||
parse_salesforce_statement(sql)
|
||
.map(|parsed| parsed.op.as_str().to_ascii_uppercase())
|
||
.unwrap_or_else(|_| "DML".to_string())
|
||
}
|
||
};
|
||
}
|
||
dbx_core::sql::sql_execution_plan_for_database(sql, database_type)
|
||
.statements
|
||
.first()
|
||
.map(|statement| dbx_core::query_execution_sql::strip_sql_comments(statement))
|
||
.and_then(|statement| statement.split_whitespace().next().map(str::to_string))
|
||
.map(|operation| operation.trim_matches(|character: char| !character.is_ascii_alphabetic()).to_string())
|
||
.filter(|operation| !operation.is_empty())
|
||
.map(|operation| operation.to_ascii_uppercase())
|
||
.unwrap_or_else(|| "SQL".to_string())
|
||
}
|
||
|
||
/// Render a multi-statement batch result as one Markdown text block per
|
||
/// statement. Each statement is labelled by its index so callers can see which
|
||
/// statement failed, how many rows each affected, or what each returned. A
|
||
/// `merged` entry (use_transaction mode) is labelled as the transaction outcome
|
||
/// instead of a per-statement result.
|
||
fn format_batch_results(results: &[crate::backend::BatchStatementResult], cell_window: QueryCellWindow) -> String {
|
||
let mut output = String::new();
|
||
for (index, result) in results.iter().enumerate() {
|
||
if index > 0 {
|
||
output.push('\n');
|
||
}
|
||
if result.merged {
|
||
output.push_str("### Transaction outcome");
|
||
output.push('\n');
|
||
if result.execution_error {
|
||
let message = result.error_message.as_deref().unwrap_or("Transaction failed");
|
||
output.push_str(&format!("**Status:** failed\n\n{message}\n"));
|
||
} else {
|
||
let rendered = format_query_result_as_text(&result.result, BATCH_MAX_ROWS, cell_window)
|
||
.unwrap_or_else(|error| error);
|
||
output.push_str(rendered.trim_start_matches("Query executed. "));
|
||
}
|
||
continue;
|
||
}
|
||
let heading = match result.statement_index {
|
||
Some(statement_index) => format!("### Statement {}", statement_index + 1),
|
||
None => format!("### Statement {}", index + 1),
|
||
};
|
||
output.push_str(&heading);
|
||
output.push('\n');
|
||
if result.execution_error {
|
||
let message = result.error_message.as_deref().unwrap_or("Statement failed");
|
||
output.push_str(&format!("**Status:** failed\n\n{message}\n"));
|
||
} else {
|
||
let rendered =
|
||
format_query_result_as_text(&result.result, BATCH_MAX_ROWS, cell_window).unwrap_or_else(|error| error);
|
||
output.push_str(rendered.trim_start_matches("Query executed. "));
|
||
}
|
||
}
|
||
output
|
||
}
|
||
|
||
fn empty_query_result() -> dbx_core::db::QueryResult {
|
||
dbx_core::db::QueryResult {
|
||
columns: Vec::new(),
|
||
column_types: Vec::new(),
|
||
column_sortables: Vec::new(),
|
||
spatial_columns: Vec::new(),
|
||
spatial_values: Vec::new(),
|
||
rows: Vec::new(),
|
||
affected_rows: 0,
|
||
execution_time_ms: 0,
|
||
server_execute_time_us: None,
|
||
query_timings_ms: None,
|
||
truncated: false,
|
||
session_id: None,
|
||
has_more: false,
|
||
elasticsearch_raw_body: None,
|
||
messages: Vec::new(),
|
||
}
|
||
}
|
||
|
||
fn agent_result(result: dbx_core::agent_events::ToolResult) -> CallToolResult {
|
||
if result.is_error {
|
||
backend_tool_error("DBX_TOOL_ERROR", result.content.trim_start_matches("Error: "))
|
||
} else {
|
||
text(result.content)
|
||
}
|
||
}
|
||
|
||
fn policy_allows_connection(
|
||
policy: &McpGlobalPolicy,
|
||
group_path: Option<&dbx_core::mcp_policy::McpConnectionGroupPath>,
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
) -> bool {
|
||
dbx_core::mcp_policy::policy_allows_connection(policy, group_path, &connection.id)
|
||
}
|
||
|
||
fn policy_allows_tool(policy: &McpGlobalPolicy, tool_name: &str) -> bool {
|
||
policy.allowed_tool_names.as_ref().is_none_or(|allowed| allowed.iter().any(|name| name == tool_name))
|
||
}
|
||
|
||
fn database_scope_for_connection(
|
||
policy: &McpGlobalPolicy,
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
) -> DatabaseScope {
|
||
let Some(rule) = policy.connection_policies.iter().find(|rule| rule.connection_id == connection.id) else {
|
||
return DatabaseScope::All;
|
||
};
|
||
match rule.database_scope {
|
||
McpDatabaseScope::All => DatabaseScope::All,
|
||
McpDatabaseScope::Selected => DatabaseScope::Selected(rule.allowed_databases.clone()),
|
||
McpDatabaseScope::None => DatabaseScope::None,
|
||
}
|
||
}
|
||
|
||
fn resolved_connection(
|
||
policy: McpGlobalPolicy,
|
||
connection: dbx_core::models::connection::ConnectionConfig,
|
||
group_path: Option<&dbx_core::mcp_policy::McpConnectionGroupPath>,
|
||
) -> ResolvedConnection {
|
||
let _ = CALL_HISTORY.try_with(|entry| {
|
||
let mut entry = entry.lock().unwrap();
|
||
entry.connection_id = connection.id.clone();
|
||
entry.connection_name = connection.name.clone();
|
||
});
|
||
let database_scope = database_scope_for_connection(&policy, &connection);
|
||
let group_ids = group_path.map(|path| path.ids.clone()).unwrap_or_default();
|
||
ResolvedConnection { connection, policy, database_scope, group_ids }
|
||
}
|
||
|
||
#[allow(clippy::result_large_err)]
|
||
fn ensure_database_in_scope(scope: &DatabaseScope, database: &str) -> Result<(), CallToolResult> {
|
||
match scope {
|
||
DatabaseScope::All => Ok(()),
|
||
DatabaseScope::Selected(allowed) if allowed.iter().any(|allowed| allowed == database) => Ok(()),
|
||
DatabaseScope::Selected(_) | DatabaseScope::None => Err(tool_error(
|
||
"DATABASE_OUT_OF_SCOPE",
|
||
format!("Database \"{database}\" is not allowed by DBX MCP settings for this connection."),
|
||
)),
|
||
}
|
||
}
|
||
|
||
/// A selected database scope applies to SQL object references as well as the
|
||
/// request-level `database` field. Without this guard an MCP client could pick
|
||
/// an allowed default and access another MySQL/SQL Server database through a
|
||
/// qualified name such as `other_db.users`.
|
||
#[allow(clippy::result_large_err)]
|
||
fn ensure_sql_database_scope(
|
||
scope: &DatabaseScope,
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
active_database: &str,
|
||
sql: &str,
|
||
) -> Result<(), CallToolResult> {
|
||
let DatabaseScope::Selected(allowed_databases) = scope else {
|
||
return Ok(());
|
||
};
|
||
if sql_references_disallowed_database(sql, &connection.db_type, active_database, allowed_databases) {
|
||
return Err(tool_error(
|
||
"DATABASE_OUT_OF_SCOPE",
|
||
"SQL references a database that is not allowed by DBX MCP settings for this connection.",
|
||
));
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn is_database_discovery_sql(sql: &str) -> bool {
|
||
let normalized = sql.trim().trim_end_matches(';').trim().to_ascii_lowercase();
|
||
matches!(normalized.as_str(), "show databases" | "show schemas")
|
||
}
|
||
|
||
fn format_database_names(databases: &[String]) -> String {
|
||
if databases.is_empty() {
|
||
"No databases are available through this MCP connection.".to_string()
|
||
} else {
|
||
databases.iter().map(|database| format!("- {database}")).collect::<Vec<_>>().join("\n")
|
||
}
|
||
}
|
||
|
||
/// Execution modes are scoped defaults: a database rule overrides a configured
|
||
/// connection default, which in turn overrides the global default. Connection
|
||
/// read-only protection and production-database protections are enforced
|
||
/// separately and cannot be bypassed by these defaults.
|
||
#[cfg(test)]
|
||
fn effective_policy_for_database(
|
||
policy: &McpGlobalPolicy,
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
database: &str,
|
||
) -> McpGlobalPolicy {
|
||
effective_policy_for_database_with_groups(policy, &[], connection, database)
|
||
}
|
||
|
||
fn effective_policy_for_database_with_groups(
|
||
policy: &McpGlobalPolicy,
|
||
group_ids: &[String],
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
database: &str,
|
||
) -> McpGlobalPolicy {
|
||
let mut policy = policy.clone();
|
||
(policy.read_only, policy.allow_dangerous_sql) =
|
||
dbx_core::mcp_policy::effective_database_execution_policy_with_groups(
|
||
&policy,
|
||
group_ids,
|
||
&connection.id,
|
||
database,
|
||
);
|
||
// This returned value is carried through the request only; retaining a
|
||
// complete policy document here could accidentally be reused for another
|
||
// connection by a future caller.
|
||
policy.connection_policies.clear();
|
||
policy
|
||
}
|
||
|
||
/// A database-level execution rule must not be bypassed by qualifying another
|
||
/// allowed database in SQL. Until individual references are evaluated with
|
||
/// their own policies, cross-database SQL is intentionally rejected whenever
|
||
/// this connection has database-specific execution rules.
|
||
#[allow(clippy::result_large_err)]
|
||
fn ensure_sql_database_execution_scope(
|
||
policy: &McpGlobalPolicy,
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
active_database: &str,
|
||
sql: &str,
|
||
) -> Result<(), CallToolResult> {
|
||
dbx_core::mcp_policy::ensure_sql_database_execution_scope(policy, connection, active_database, sql)
|
||
.map_err(|error| tool_error("DATABASE_EXECUTION_POLICY_OUT_OF_SCOPE", error))
|
||
}
|
||
|
||
fn mcp_permissions(
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
policy: &McpGlobalPolicy,
|
||
) -> dbx_core::agent_tools::AgentSqlPermissions {
|
||
dbx_core::agent_tools::AgentSqlPermissions {
|
||
allow_writes: !policy.read_only && !connection.read_only,
|
||
allow_dangerous: !policy.read_only && !connection.read_only && policy.allow_dangerous_sql,
|
||
confirmed_write_sql: mcp_confirmed_write_sql_from_env(),
|
||
}
|
||
}
|
||
|
||
fn transaction_connection_supported(connection: &dbx_core::models::connection::ConnectionConfig) -> bool {
|
||
crate::backend::native_mysql_transaction_connection(connection)
|
||
}
|
||
|
||
/// Read the DBX_MCP_CONFIRMED_WRITE_SQL env var (set by the CLI agent when the
|
||
/// user confirmed a specific write SQL). Returns None when the var is unset or
|
||
/// empty, so desktop-embedded MCP contexts (which don't set this var) continue
|
||
/// to work without a confirmed-SQL binding.
|
||
fn mcp_confirmed_write_sql_from_env() -> Option<String> {
|
||
normalize_confirmed_write_sql(std::env::var("DBX_MCP_CONFIRMED_WRITE_SQL").ok())
|
||
}
|
||
|
||
fn normalize_confirmed_write_sql(value: Option<String>) -> Option<String> {
|
||
let trimmed = value?.trim().to_string();
|
||
(!trimmed.is_empty()).then_some(trimmed)
|
||
}
|
||
|
||
/// When the user confirmed a specific write SQL for this run, a batch that
|
||
/// contains a write/DDL statement must be exactly that confirmed SQL. Returns
|
||
/// the block message when the script differs from the confirmation and is not
|
||
/// read-only; `None` means the script is allowed (read-only, exact match, or
|
||
/// no binding). Unparseable SQL is treated as a write and fails closed.
|
||
fn confirmed_batch_sql_block_reason(
|
||
sql: &str,
|
||
db_type: dbx_core::models::connection::DatabaseType,
|
||
confirmed: Option<&str>,
|
||
) -> Option<String> {
|
||
let confirmed = confirmed?;
|
||
if normalize_sql_for_confirmation(sql) == normalize_sql_for_confirmation(confirmed) {
|
||
return None;
|
||
}
|
||
let is_write = match classify_sql_risk_for_database(sql, db_type) {
|
||
Ok(risk) => risk != dbx_core::sql_risk::SqlRisk::ReadOnly,
|
||
Err(_) => true,
|
||
};
|
||
if !is_write {
|
||
return None;
|
||
}
|
||
Some(format!(
|
||
"Blocked: the executed SQL does not match the user-confirmed SQL.\n\
|
||
Confirmed: {}\n\
|
||
Attempted: {}",
|
||
confirmed, sql
|
||
))
|
||
}
|
||
|
||
fn validate_transaction_sql_shape(sql: &str) -> Result<(), String> {
|
||
use sqlparser::{
|
||
ast::{Expr, Statement, Visit, Visitor},
|
||
dialect::MySqlDialect,
|
||
parser::Parser,
|
||
tokenizer::{Token, Tokenizer},
|
||
};
|
||
use std::ops::ControlFlow;
|
||
|
||
const SAFE_FUNCTIONS: &[&str] = &[
|
||
"abs",
|
||
"ascii",
|
||
"avg",
|
||
"bin",
|
||
"ceiling",
|
||
"char_length",
|
||
"character_length",
|
||
"coalesce",
|
||
"concat",
|
||
"concat_ws",
|
||
"connection_id",
|
||
"conv",
|
||
"count",
|
||
"crc32",
|
||
"curdate",
|
||
"curtime",
|
||
"current_date",
|
||
"current_time",
|
||
"current_timestamp",
|
||
"date_format",
|
||
"datediff",
|
||
"dayname",
|
||
"dayofmonth",
|
||
"dayofweek",
|
||
"dayofyear",
|
||
"exp",
|
||
"floor",
|
||
"format",
|
||
"greatest",
|
||
"hex",
|
||
"hour",
|
||
"if",
|
||
"ifnull",
|
||
"inet_aton",
|
||
"inet_ntoa",
|
||
"instr",
|
||
"isnull",
|
||
"json_extract",
|
||
"json_length",
|
||
"json_unquote",
|
||
"json_valid",
|
||
"last_day",
|
||
"lcase",
|
||
"least",
|
||
"left",
|
||
"length",
|
||
"ln",
|
||
"locate",
|
||
"log",
|
||
"log10",
|
||
"log2",
|
||
"lower",
|
||
"lpad",
|
||
"ltrim",
|
||
"max",
|
||
"md5",
|
||
"microsecond",
|
||
"min",
|
||
"minute",
|
||
"mod",
|
||
"month",
|
||
"monthname",
|
||
"now",
|
||
"nullif",
|
||
"oct",
|
||
"ord",
|
||
"position",
|
||
"pow",
|
||
"power",
|
||
"quarter",
|
||
"rand",
|
||
"repeat",
|
||
"replace",
|
||
"reverse",
|
||
"right",
|
||
"round",
|
||
"rpad",
|
||
"rtrim",
|
||
"second",
|
||
"sha",
|
||
"sha1",
|
||
"sha2",
|
||
"sign",
|
||
"sleep",
|
||
"space",
|
||
"sqrt",
|
||
"str_to_date",
|
||
"substring",
|
||
"substr",
|
||
"time_format",
|
||
"timediff",
|
||
"timestampadd",
|
||
"timestampdiff",
|
||
"truncate",
|
||
"unhex",
|
||
"unix_timestamp",
|
||
"upper",
|
||
"ucase",
|
||
"utc_date",
|
||
"utc_time",
|
||
"utc_timestamp",
|
||
"uuid",
|
||
"version",
|
||
"week",
|
||
"weekday",
|
||
"year",
|
||
];
|
||
|
||
struct TransactionFunctionVisitor {
|
||
rejected: bool,
|
||
}
|
||
|
||
impl Visitor for TransactionFunctionVisitor {
|
||
type Break = ();
|
||
|
||
fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow<()> {
|
||
if let Expr::Function(function) = expr {
|
||
let parts = &function.name.0;
|
||
let allowed = parts.len() == 1
|
||
&& parts.last().and_then(|part| part.as_ident()).is_some_and(|ident| {
|
||
SAFE_FUNCTIONS.iter().any(|candidate| ident.value.eq_ignore_ascii_case(candidate))
|
||
});
|
||
if !allowed {
|
||
self.rejected = true;
|
||
return ControlFlow::Break(());
|
||
}
|
||
}
|
||
ControlFlow::Continue(())
|
||
}
|
||
}
|
||
|
||
if sql.contains("/*!") || sql.contains("/*+") {
|
||
return Err("Executable comments and optimizer hints are not allowed in transaction sessions.".to_string());
|
||
}
|
||
let dialect = MySqlDialect {};
|
||
let statements = Parser::parse_sql(&dialect, sql).map_err(|error| format!("SQL cannot be proven safe: {error}"))?;
|
||
let [statement] = statements.as_slice() else {
|
||
return Err("Transaction session calls must contain exactly one SQL statement.".to_string());
|
||
};
|
||
let tokens =
|
||
Tokenizer::new(&dialect, sql).tokenize().map_err(|error| format!("SQL cannot be tokenized safely: {error}"))?;
|
||
let has_word = |expected: &str| {
|
||
tokens.iter().any(|token| matches!(token, Token::Word(word) if word.value.eq_ignore_ascii_case(expected)))
|
||
};
|
||
if tokens.iter().any(|token| matches!(token, Token::Assignment)) {
|
||
return Err("User-variable assignment is not allowed in transaction sessions.".to_string());
|
||
}
|
||
|
||
match statement {
|
||
Statement::Query(_) => {
|
||
for forbidden in [
|
||
"INTO",
|
||
"OUTFILE",
|
||
"DUMPFILE",
|
||
"LOAD_FILE",
|
||
"GET_LOCK",
|
||
"RELEASE_LOCK",
|
||
"IS_FREE_LOCK",
|
||
"IS_USED_LOCK",
|
||
"MASTER_POS_WAIT",
|
||
"SQL_CALC_FOUND_ROWS",
|
||
] {
|
||
if has_word(forbidden) {
|
||
return Err(format!("{forbidden} is not allowed in transaction session queries."));
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
Statement::Insert(insert)
|
||
if insert.output.is_none()
|
||
&& insert.returning.is_none()
|
||
&& insert.settings.is_none()
|
||
&& insert.format_clause.is_none()
|
||
&& insert.multi_table_insert_type.is_none()
|
||
&& insert.multi_table_into_clauses.is_empty()
|
||
&& insert.multi_table_when_clauses.is_empty()
|
||
&& insert.multi_table_else_clause.is_none() =>
|
||
{
|
||
Ok(())
|
||
}
|
||
Statement::Update(update) if update.output.is_none() && update.returning.is_none() => Ok(()),
|
||
Statement::Delete(delete) if delete.output.is_none() && delete.returning.is_none() => Ok(()),
|
||
_ => Err(
|
||
"Transaction sessions allow only SELECT (including locking reads), INSERT, UPDATE, DELETE, and REPLACE."
|
||
.to_string(),
|
||
),
|
||
}?;
|
||
|
||
let mut visitor = TransactionFunctionVisitor { rejected: false };
|
||
let _ = statement.visit(&mut visitor);
|
||
if visitor.rejected {
|
||
return Err(
|
||
"Only unqualified, known-safe MySQL built-in functions are allowed in transaction sessions.".to_string()
|
||
);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
// CallToolResult is the transport-native error payload; boxing it would complicate every MCP call site.
|
||
#[allow(clippy::result_large_err)]
|
||
fn not_salesforce_error(connection: &ConnectionConfig) -> CallToolResult {
|
||
tool_error(
|
||
"NOT_SALESFORCE_CONNECTION",
|
||
format!(
|
||
"Connection \"{}\" is a {:?} connection, not Salesforce. The dbx_salesforce_* tools only work against a Salesforce org.",
|
||
connection.name, connection.db_type
|
||
),
|
||
)
|
||
}
|
||
|
||
/// Build the exact `DBX SALESFORCE DML` pseudo-command the driver executes.
|
||
///
|
||
/// Validation lives here rather than in the driver so a rejected shape never
|
||
/// receives a confirm token: the statement that gets summarized is the statement
|
||
/// that gets sent, one record at a time. Upsert and bulk shapes are refused
|
||
/// outright — the driver cannot express them, and a token must not promise what
|
||
/// the org cannot do.
|
||
fn build_salesforce_dml_statement(
|
||
op: &str,
|
||
object: &str,
|
||
id: Option<&str>,
|
||
fields: Option<&serde_json::Value>,
|
||
) -> Result<String, String> {
|
||
let op = op.trim().to_ascii_lowercase();
|
||
let object = object.trim();
|
||
if object.is_empty() {
|
||
return Err("'object' must be a non-empty Salesforce object API name, e.g. \"Account\".".to_string());
|
||
}
|
||
let id = id.map(str::trim).filter(|id| !id.is_empty());
|
||
let fields = match fields {
|
||
None => None,
|
||
Some(serde_json::Value::Object(map)) => (!map.is_empty()).then_some(map),
|
||
Some(_) => return Err("'fields' must be a JSON object mapping field API names to values.".to_string()),
|
||
};
|
||
let body = match op.as_str() {
|
||
"insert" => {
|
||
if id.is_some() {
|
||
return Err("insert creates a new record: drop 'id' and let Salesforce assign it.".to_string());
|
||
}
|
||
let Some(fields) = fields else {
|
||
return Err("insert requires a non-empty 'fields' object.".to_string());
|
||
};
|
||
reject_salesforce_identity_field(fields)?;
|
||
json!({ "op": "insert", "object": object, "fields": fields })
|
||
}
|
||
"update" => {
|
||
let Some(id) = id else {
|
||
return Err("update requires the 'id' of the record to change.".to_string());
|
||
};
|
||
let Some(fields) = fields else {
|
||
return Err("update requires a non-empty 'fields' object.".to_string());
|
||
};
|
||
reject_salesforce_identity_field(fields)?;
|
||
json!({ "op": "update", "object": object, "id": id, "fields": fields })
|
||
}
|
||
"delete" => {
|
||
let Some(id) = id else {
|
||
return Err("delete requires the 'id' of the record to remove.".to_string());
|
||
};
|
||
if fields.is_some() {
|
||
return Err("delete takes no 'fields' — it removes the whole record.".to_string());
|
||
}
|
||
json!({ "op": "delete", "object": object, "id": id })
|
||
}
|
||
other => {
|
||
return Err(format!(
|
||
"Unknown op \"{other}\". Expected insert, update or delete — upsert, bulk and composite writes are not supported."
|
||
));
|
||
}
|
||
};
|
||
Ok(format!("{SALESFORCE_DML_HEADER}\n{body}"))
|
||
}
|
||
|
||
/// `Id` is the record identity, never a write target: sending it would either be
|
||
/// ignored (insert) or read as an attempt to re-key a record (update).
|
||
fn reject_salesforce_identity_field(fields: &serde_json::Map<String, serde_json::Value>) -> Result<(), String> {
|
||
if fields.keys().any(|name| name.eq_ignore_ascii_case("Id")) {
|
||
return Err(
|
||
"'fields' must not contain Id — the record identity is the 'id' parameter, and Salesforce assigns it on insert."
|
||
.to_string(),
|
||
);
|
||
}
|
||
if fields.keys().any(|name| name.trim().is_empty()) {
|
||
return Err("'fields' contains an empty field name.".to_string());
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// One-line description of a prepared statement, in the same words the driver
|
||
/// uses in its own errors, so a summary and a failure line up.
|
||
fn salesforce_write_label(statement: &str) -> String {
|
||
match parse_salesforce_statement(statement) {
|
||
Ok(parsed) => match parsed.id.as_deref().filter(|id| !id.is_empty()) {
|
||
Some(id) => format!("{} on {} (Id {id})", parsed.op.as_str(), parsed.object),
|
||
None => format!("{} on {}", parsed.op.as_str(), parsed.object),
|
||
},
|
||
// Unreachable for a token the server issued; keep the line honest anyway.
|
||
Err(_) => "Salesforce write".to_string(),
|
||
}
|
||
}
|
||
|
||
/// The confirmation an agent must show the user before applying a prepared
|
||
/// write. It names the operation, the exact field values, and the identity the
|
||
/// change will be attributed to, then states the two properties that make
|
||
/// Salesforce different from SQL: no transaction and no rollback.
|
||
fn format_salesforce_write_summary(
|
||
statement: &str,
|
||
connection: &ConnectionConfig,
|
||
identity: Option<&SalesforceCurrentUser>,
|
||
token: &str,
|
||
expires_in_secs: u64,
|
||
) -> String {
|
||
let mut lines = vec!["Salesforce write prepared — nothing has been sent yet.".to_string(), String::new()];
|
||
match parse_salesforce_statement(statement) {
|
||
Ok(parsed) => {
|
||
lines.push(format!("Operation: {}", parsed.op.as_str()));
|
||
lines.push(format!("Object: {}", parsed.object));
|
||
if let Some(id) = parsed.id.as_deref().filter(|id| !id.is_empty()) {
|
||
lines.push(format!("Record Id: {id}"));
|
||
}
|
||
if let Some(fields) = parsed.fields.as_ref() {
|
||
lines.push(format!("Fields ({}):", fields.len()));
|
||
for (index, (name, value)) in fields.iter().enumerate() {
|
||
if index >= SALESFORCE_SUMMARY_MAX_FIELDS {
|
||
lines.push(format!(
|
||
" … and {} more (full statement in structured_content)",
|
||
fields.len() - index
|
||
));
|
||
break;
|
||
}
|
||
lines.push(format!(" - {name} = {}", truncate_salesforce_value(value)));
|
||
}
|
||
}
|
||
}
|
||
Err(error) => lines.push(format!("Operation: unparseable ({error})")),
|
||
}
|
||
lines.push(String::new());
|
||
lines.push(format!("Connection: {} ({})", connection.name, connection.id));
|
||
lines.extend(format_salesforce_identity_lines(identity));
|
||
lines.push(String::new());
|
||
lines.push(
|
||
"Salesforce writes are not transactional: once applied, this cannot be rolled back. Field-level security, record sharing, validation rules and flows all still apply, and a refusal comes back as Salesforce's own error text."
|
||
.to_string(),
|
||
);
|
||
lines.push(String::new());
|
||
lines.push(format!(
|
||
"Show this summary to the user. Only if they approve, call dbx_salesforce_apply_write with confirm_token \"{token}\". The token is single-use and expires in {expires_in_secs} seconds; any change to the write needs a new dbx_salesforce_prepare_write."
|
||
));
|
||
lines.join("\n")
|
||
}
|
||
|
||
/// The whole identity block, for `dbx_salesforce_current_user`.
|
||
fn format_salesforce_identity_block(connection: &ConnectionConfig, identity: Option<&SalesforceCurrentUser>) -> String {
|
||
let mut lines = vec![format!("Salesforce identity for connection \"{}\" ({})", connection.name, connection.id)];
|
||
lines.extend(format_salesforce_identity_lines(identity));
|
||
lines.join("\n")
|
||
}
|
||
|
||
fn format_salesforce_identity_lines(identity: Option<&SalesforceCurrentUser>) -> Vec<String> {
|
||
let Some(identity) = identity else {
|
||
return vec![
|
||
"Signed in as: unknown — the identity lookup failed, so treat every permission as unverified. Salesforce still enforces its own rules on the write."
|
||
.to_string(),
|
||
];
|
||
};
|
||
let profile = identity.profile_name.as_deref().map(str::trim).filter(|name| !name.is_empty()).unwrap_or("unknown");
|
||
let rights = match identity.is_admin {
|
||
Some(true) => "has \"Modify All Data\": it bypasses field-level security and record sharing",
|
||
Some(false) => "no \"Modify All Data\": field-level security and record sharing apply",
|
||
None => "\"Modify All Data\" could not be determined, so treat it as if it were granted",
|
||
};
|
||
vec![
|
||
format!("Signed in as: {} <{}> (user Id {})", identity.name, identity.email, identity.user_id),
|
||
format!("Organization: {} ({})", identity.org_name, identity.organization_id),
|
||
format!("Profile: \"{profile}\" — {rights}"),
|
||
]
|
||
}
|
||
|
||
fn salesforce_identity_json(identity: &SalesforceCurrentUser) -> serde_json::Value {
|
||
json!({
|
||
"user_id": identity.user_id,
|
||
"name": identity.name,
|
||
"email": identity.email,
|
||
"username": identity.username,
|
||
"organization_id": identity.organization_id,
|
||
"org_name": identity.org_name,
|
||
"profile_name": identity.profile_name,
|
||
"is_admin": identity.is_admin,
|
||
})
|
||
}
|
||
|
||
fn truncate_salesforce_value(value: &serde_json::Value) -> String {
|
||
let rendered = value.to_string();
|
||
if rendered.chars().count() <= SALESFORCE_SUMMARY_MAX_VALUE_CHARS {
|
||
return rendered;
|
||
}
|
||
let kept: String = rendered.chars().take(SALESFORCE_SUMMARY_MAX_VALUE_CHARS).collect();
|
||
format!("{kept}…")
|
||
}
|
||
|
||
// CallToolResult is the transport-native error payload; boxing it would complicate every MCP call site.
|
||
#[allow(clippy::result_large_err)]
|
||
fn validate_sql_policy(
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
policy: &McpGlobalPolicy,
|
||
database: &str,
|
||
sql: &str,
|
||
allow_database_switch: bool,
|
||
) -> Result<dbx_core::agent_tools::AgentSqlPermissions, CallToolResult> {
|
||
if !allow_database_switch && mcp_sql_has_forbidden_database_switch(sql, connection.db_type) {
|
||
return Err(tool_error(
|
||
"SQL_BLOCKED",
|
||
"MCP does not allow USE or persistent database switching outside a session. Open one with dbx_open_session to run stateful queries.",
|
||
));
|
||
}
|
||
let risk =
|
||
classify_sql_risk_for_database(sql, connection.db_type).map_err(|error| tool_error("SQL_BLOCKED", error))?;
|
||
if risk == SqlRisk::Transaction {
|
||
return Err(tool_error("SQL_BLOCKED", "Transaction statements are not supported by MCP."));
|
||
}
|
||
// The keyword scan alone misses write-capable SQL that the risk classifier
|
||
// does recognize (locking reads, side-effect functions, writable CTEs), and
|
||
// those statements would otherwise reach the database whenever high-risk SQL
|
||
// is permitted. Fail closed on either signal so read-only stays read-only.
|
||
let is_write = risk != SqlRisk::ReadOnly || is_write_sql_for_database(sql, connection.db_type);
|
||
if policy.read_only && is_write {
|
||
return Err(tool_error(
|
||
"MCP_READ_ONLY",
|
||
format!("MCP execution permission for database \"{database}\" is read-only. SQL write blocked."),
|
||
));
|
||
}
|
||
if connection.read_only && is_write {
|
||
return Err(tool_error(
|
||
"CONNECTION_READ_ONLY",
|
||
format!("Connection \"{}\" has read-only protection enabled. SQL write blocked.", connection.name),
|
||
));
|
||
}
|
||
let high_risk = risk == SqlRisk::Ddl || is_dangerous_sql_for_database(sql, connection.db_type);
|
||
if high_risk && !policy.allow_dangerous_sql {
|
||
return Err(tool_error("SQL_BLOCKED", "High-risk SQL is disabled in DBX MCP settings."));
|
||
}
|
||
if is_write && targets_production_database(connection, database, sql) {
|
||
return Err(tool_error("PRODUCTION_WRITE_BLOCKED", "MCP cannot execute writes against a production database."));
|
||
}
|
||
Ok(mcp_permissions(connection, policy))
|
||
}
|
||
|
||
// CallToolResult is the transport-native error payload; boxing it would complicate every MCP call site.
|
||
#[cfg(test)]
|
||
#[allow(clippy::result_large_err)]
|
||
#[cfg(test)]
|
||
fn validate_mongo_command(
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
policy: &McpGlobalPolicy,
|
||
database_scope: &DatabaseScope,
|
||
database: &str,
|
||
source: &str,
|
||
) -> Result<MongoCommand, CallToolResult> {
|
||
validate_mongo_command_with_groups(connection, policy, &[], database_scope, database, source)
|
||
}
|
||
|
||
#[allow(clippy::result_large_err)]
|
||
fn validate_mongo_command_with_groups(
|
||
connection: &dbx_core::models::connection::ConnectionConfig,
|
||
policy: &McpGlobalPolicy,
|
||
group_ids: &[String],
|
||
database_scope: &DatabaseScope,
|
||
database: &str,
|
||
source: &str,
|
||
) -> Result<MongoCommand, CallToolResult> {
|
||
let command = mongo::parse(source).map_err(|error| {
|
||
tool_error(
|
||
"QUERY_ERROR",
|
||
format!(
|
||
"{error} Use MongoDB shell-style commands such as db.collection.find({{}}), db.collection.aggregate([]), or db.collection.countDocuments({{}})."
|
||
),
|
||
)
|
||
})?;
|
||
let (target_database, command_to_validate) = match &command {
|
||
MongoCommand::InDatabase { database, command } => (database.as_str(), command.as_ref()),
|
||
command => (database, command),
|
||
};
|
||
ensure_database_in_scope(database_scope, target_database)?;
|
||
if matches!(command_to_validate, MongoCommand::RunCommand { .. }) {
|
||
return Err(tool_error(
|
||
"SQL_BLOCKED",
|
||
"MongoDB runCommand is not available through MCP; review and execute it manually in DBX.",
|
||
));
|
||
}
|
||
if let MongoCommand::Aggregate { pipeline, .. } = command_to_validate {
|
||
dbx_core::mcp_policy::ensure_mongo_database_execution_scope(policy, &connection.id, target_database, pipeline)
|
||
.map_err(|error| {
|
||
let (code, message) = error
|
||
.strip_prefix("QUERY_ERROR: ")
|
||
.map_or(("DATABASE_EXECUTION_POLICY_OUT_OF_SCOPE", error.as_str()), |message| {
|
||
("QUERY_ERROR", message)
|
||
});
|
||
tool_error(code, message)
|
||
})?;
|
||
for output_database in mongo_aggregate_target_databases(pipeline, target_database)? {
|
||
ensure_database_in_scope(database_scope, &output_database)?;
|
||
}
|
||
}
|
||
let effective_policy = effective_policy_for_database_with_groups(policy, group_ids, connection, target_database);
|
||
let permissions = mcp_permissions(connection, &effective_policy);
|
||
let production_database = match command_to_validate {
|
||
MongoCommand::Aggregate { pipeline, .. } => {
|
||
mongo_pipeline_targets_production_database(connection, target_database, pipeline)
|
||
}
|
||
_ => is_production_database(connection, target_database),
|
||
};
|
||
if let Err(error) = mongo::validate_safety(
|
||
command_to_validate,
|
||
permissions.allow_writes,
|
||
permissions.allow_dangerous,
|
||
production_database,
|
||
) {
|
||
return Err(match error {
|
||
MongoSafetyError::WritesDisabled => tool_error(
|
||
if effective_policy.read_only { "MCP_READ_ONLY" } else { "CONNECTION_READ_ONLY" },
|
||
"MCP MongoDB execution is read-only for this database in DBX MCP settings.",
|
||
),
|
||
MongoSafetyError::EmptyFilter => tool_error(
|
||
"SQL_BLOCKED",
|
||
"MongoDB update/delete commands must include a non-empty filter unless high-risk operations are enabled in DBX MCP settings.",
|
||
),
|
||
MongoSafetyError::Dangerous => {
|
||
tool_error("SQL_BLOCKED", "Dangerous MongoDB command is disabled in DBX MCP settings.")
|
||
}
|
||
MongoSafetyError::ProductionWrite => {
|
||
tool_error("PRODUCTION_WRITE_BLOCKED", "MCP cannot execute writes against a production database.")
|
||
}
|
||
});
|
||
}
|
||
Ok(command)
|
||
}
|
||
|
||
#[allow(clippy::result_large_err)]
|
||
fn mongo_aggregate_target_databases(pipeline: &str, active_database: &str) -> Result<Vec<String>, CallToolResult> {
|
||
dbx_core::mcp_policy::mongo_pipeline_output_databases(pipeline, active_database)
|
||
.map_err(|error| tool_error("QUERY_ERROR", error.strip_prefix("QUERY_ERROR: ").unwrap_or(&error)))
|
||
}
|
||
|
||
fn non_empty_env(name: &str) -> Option<String> {
|
||
std::env::var(name).ok().map(|value| value.trim().to_string()).filter(|value| !value.is_empty())
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
fn format_peek_messages_result(result: dbx_core::mq::PeekMessagesResult, count: usize) -> String {
|
||
let mut messages = Vec::new();
|
||
let mut bytes = 0;
|
||
let mut truncated = result.messages.len() > count;
|
||
for message in result.messages.into_iter().take(count) {
|
||
let value = serde_json::to_value(message).expect("message is JSON serializable");
|
||
bytes += value.to_string().len();
|
||
if bytes > 256 * 1024 {
|
||
truncated = true;
|
||
break;
|
||
}
|
||
messages.push(value);
|
||
}
|
||
json!({ "messages": messages, "incomplete": result.incomplete, "outputTruncated": truncated }).to_string()
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
fn format_send_message_result(
|
||
system_kind: &dbx_core::mq::MqSystemKind,
|
||
result: &dbx_core::mq::SendMessageResponse,
|
||
) -> String {
|
||
let mut output = format!(
|
||
"Message sent to {}.\ntopic: {}\npartition: {}\noffset: {}",
|
||
system_kind.as_str(),
|
||
result.topic,
|
||
result.partition,
|
||
result.offset
|
||
);
|
||
if let Some(timestamp) = result.timestamp.as_deref() {
|
||
output.push_str(&format!("\ntimestamp: {timestamp}"));
|
||
}
|
||
output
|
||
}
|
||
|
||
fn scoped_connection_ids(value: Option<&str>) -> Vec<String> {
|
||
let mut ids = Vec::new();
|
||
for id in value.unwrap_or_default().split(',').map(str::trim).filter(|id| !id.is_empty()) {
|
||
if !ids.iter().any(|existing| existing == id) {
|
||
ids.push(id.to_string());
|
||
}
|
||
}
|
||
ids
|
||
}
|
||
|
||
fn ambiguous_connections(name: &str, connections: &[dbx_core::models::connection::ConnectionConfig]) -> String {
|
||
let lines = connections
|
||
.iter()
|
||
.map(|connection| {
|
||
format!("- {}: {:?} @ {}:{}", connection.id, connection.db_type, connection.host, connection.port)
|
||
})
|
||
.collect::<Vec<_>>()
|
||
.join("\n");
|
||
format!("Multiple connections found with name \"{name}\". Please specify connection_id:\n{lines}")
|
||
}
|
||
|
||
fn format_connections(connections: &[ConnectionSummary]) -> String {
|
||
let mut output = String::from(
|
||
"| ID | Name | Group Path | Type | Host | Port | Database |\n| --- | --- | --- | --- | --- | --- | --- |",
|
||
);
|
||
for connection in connections {
|
||
output.push_str(&format!(
|
||
"\n| {} | {} | {} | {} | {} | {} | {} |",
|
||
escape_cell(&connection.id),
|
||
escape_cell(&connection.name),
|
||
escape_cell(&connection.group_path.join(" / ")),
|
||
escape_cell(&connection.db_type),
|
||
escape_cell(&connection.host),
|
||
connection.port,
|
||
escape_cell(&connection.database),
|
||
));
|
||
}
|
||
output
|
||
}
|
||
|
||
/// Normalize a user-supplied routine type ("procedure", "PROCEDURE", ...) to
|
||
/// the canonical SCREAMING form used by the object listing protocol.
|
||
fn normalize_routine_type(value: &str) -> Result<String, String> {
|
||
match value.trim().to_ascii_uppercase().as_str() {
|
||
"PROCEDURE" => Ok("PROCEDURE".to_string()),
|
||
"FUNCTION" => Ok("FUNCTION".to_string()),
|
||
other => Err(format!("Unsupported routine type \"{other}\"; use PROCEDURE or FUNCTION.")),
|
||
}
|
||
}
|
||
|
||
fn format_routines(routines: &[dbx_core::db::ObjectInfo]) -> String {
|
||
let rows = routines
|
||
.iter()
|
||
.map(|routine| {
|
||
vec![
|
||
routine.name.clone(),
|
||
routine.object_type.clone(),
|
||
routine.schema.clone().unwrap_or_default(),
|
||
routine.signature.clone().unwrap_or_default(),
|
||
routine.comment.clone().unwrap_or_default(),
|
||
]
|
||
})
|
||
.collect::<Vec<_>>();
|
||
markdown_table(&["Routine", "Type", "Schema", "Signature", "Comment"], &rows)
|
||
}
|
||
|
||
fn format_columns(columns: &[dbx_core::db::ColumnInfo]) -> String {
|
||
let rows = columns
|
||
.iter()
|
||
.map(|column| {
|
||
vec![
|
||
if column.is_primary_key { format!("{} (PK)", column.name) } else { column.name.clone() },
|
||
column.data_type.clone(),
|
||
if column.is_nullable { "YES".to_string() } else { "NO".to_string() },
|
||
column.column_default.clone().unwrap_or_default(),
|
||
column.comment.clone().unwrap_or_default(),
|
||
]
|
||
})
|
||
.collect::<Vec<_>>();
|
||
markdown_table(&["Column", "Type", "Nullable", "Default", "Comment"], &rows)
|
||
}
|
||
|
||
fn markdown_table(headers: &[&str], rows: &[Vec<String>]) -> String {
|
||
let mut output = format!("| {} |\n| {} |", headers.join(" | "), vec!["---"; headers.len()].join(" | "));
|
||
for row in rows {
|
||
output
|
||
.push_str(&format!("\n| {} |", row.iter().map(|value| escape_cell(value)).collect::<Vec<_>>().join(" | ")));
|
||
}
|
||
output
|
||
}
|
||
|
||
fn escape_cell(value: &str) -> String {
|
||
value.replace('|', "\\|").replace('\n', " ")
|
||
}
|
||
|
||
fn redis_database(connection: &dbx_core::models::connection::ConnectionConfig) -> Option<u32> {
|
||
connection.database.as_deref().and_then(parse_redis_database)
|
||
}
|
||
|
||
fn parse_redis_database(value: &str) -> Option<u32> {
|
||
value.trim().parse().ok()
|
||
}
|
||
|
||
fn format_redis_result(result: &RedisCommandResult) -> String {
|
||
let value =
|
||
result.value.as_str().map(ToOwned::to_owned).unwrap_or_else(|| {
|
||
serde_json::to_string_pretty(&result.value).unwrap_or_else(|_| result.value.to_string())
|
||
});
|
||
let safety = serde_json::to_value(&result.safety)
|
||
.ok()
|
||
.and_then(|value| value.as_str().map(ToOwned::to_owned))
|
||
.unwrap_or_else(|| format!("{:?}", result.safety).to_ascii_lowercase());
|
||
format!("Command: {}\nSafety: {}\n\n{}", result.command, safety, value)
|
||
}
|
||
|
||
fn format_schema_context(
|
||
connection: &str,
|
||
database: &str,
|
||
schema: &str,
|
||
tables: &[(dbx_core::db::TableInfo, Vec<dbx_core::db::ColumnInfo>)],
|
||
truncated: bool,
|
||
) -> String {
|
||
let mut output = format!("Connection: {connection}");
|
||
if !database.is_empty() {
|
||
output.push_str(&format!("\nDatabase: {database}"));
|
||
}
|
||
if !schema.is_empty() {
|
||
output.push_str(&format!("\nSchema: {schema}"));
|
||
}
|
||
for (table, columns) in tables {
|
||
output.push_str(&format!("\n\n## {}\nType: {}", table.name, table.table_type));
|
||
for column in columns {
|
||
output.push_str(&format!(
|
||
"\n- {} {} {}{}{}",
|
||
column.name,
|
||
column.data_type,
|
||
if column.is_nullable { "NULL" } else { "NOT NULL" },
|
||
if column.is_primary_key { " PK" } else { "" },
|
||
column.comment.as_ref().map(|comment| format!(" -- {comment}")).unwrap_or_default(),
|
||
));
|
||
}
|
||
}
|
||
if truncated {
|
||
output.push_str("\n\nNote: table list was truncated; request specific table names for more context.");
|
||
}
|
||
output
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
#[test]
|
||
fn history_response_keeps_long_text_and_all_rows() {
|
||
let value = serde_json::json!({"content": [{"type": "text", "text": "x".repeat(4000)}], "rows": (0..100).collect::<Vec<_>>()});
|
||
let stored: serde_json::Value = serde_json::from_str(&super::bounded_history_response(&value)).unwrap();
|
||
assert_eq!(stored, value);
|
||
}
|
||
|
||
#[test]
|
||
fn history_response_redacts_nested_json_and_marks_size_limit() {
|
||
let value =
|
||
serde_json::json!({"content": [{"type": "text", "text": r#"{"password":"secret-value","rows":[1,2]}"#}]});
|
||
let stored = super::bounded_history_response(&value);
|
||
assert!(!stored.contains("secret-value"));
|
||
assert!(stored.contains("[redacted]"));
|
||
let large = super::bounded_history_response(&serde_json::json!({"text": "中".repeat(70000)}));
|
||
assert!(large.len() <= 64 * 1024);
|
||
assert_eq!(serde_json::from_str::<serde_json::Value>(&large).unwrap()["truncated"], true);
|
||
}
|
||
|
||
use super::*;
|
||
use async_trait::async_trait;
|
||
use dbx_core::models::connection::ConnectionConfig;
|
||
use rmcp::{
|
||
model::{CallToolRequest, CallToolRequestParams, ClientRequest},
|
||
service::PeerRequestOptions,
|
||
ServiceExt,
|
||
};
|
||
use std::{collections::HashSet, sync::atomic::AtomicUsize, time::Duration};
|
||
|
||
#[test]
|
||
fn parses_dbx_resource_uris_and_decodes_query_values() {
|
||
assert_eq!(parse_dbx_resource_uri(CONNECTIONS_RESOURCE_URI).unwrap(), DbxResourceRequest::Connections);
|
||
assert_eq!(
|
||
parse_dbx_resource_uri("dbx://connections/connection-1/databases").unwrap(),
|
||
DbxResourceRequest::Databases { connection_id: "connection-1".to_string() }
|
||
);
|
||
assert_eq!(
|
||
parse_dbx_resource_uri(
|
||
"dbx://connections/connection-1/table-schema?database=sales%20data&schema=public&table=order%20items"
|
||
)
|
||
.unwrap(),
|
||
DbxResourceRequest::TableSchema {
|
||
connection_id: "connection-1".to_string(),
|
||
database: Some("sales data".to_string()),
|
||
schema: Some("public".to_string()),
|
||
table: "order items".to_string(),
|
||
}
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn rejects_invalid_dbx_resource_uris() {
|
||
assert!(parse_dbx_resource_uri("dbx://connections/connection-1/table-schema").is_err());
|
||
assert!(parse_dbx_resource_uri("dbx://connections/connection-1/tables?unknown=value").is_err());
|
||
assert!(parse_dbx_resource_uri("file:///tmp/connections").is_err());
|
||
}
|
||
|
||
struct FakeTransactionIo {
|
||
in_transaction: bool,
|
||
executed_sql: Arc<std::sync::Mutex<Vec<String>>>,
|
||
block_next_sql: Arc<std::sync::Mutex<Option<Arc<tokio::sync::Notify>>>>,
|
||
disconnects: Arc<AtomicUsize>,
|
||
}
|
||
|
||
#[async_trait]
|
||
impl crate::transaction::TransactionIo for FakeTransactionIo {
|
||
async fn execute(
|
||
&mut self,
|
||
sql: &str,
|
||
_max_rows: Option<usize>,
|
||
) -> Result<crate::transaction::TransactionIoSuccess, crate::transaction::TransactionIoError> {
|
||
self.executed_sql.lock().unwrap().push(sql.to_string());
|
||
let block = self.block_next_sql.lock().unwrap().take();
|
||
if let Some(block) = block {
|
||
block.notified().await;
|
||
}
|
||
match sql {
|
||
"START TRANSACTION" => self.in_transaction = true,
|
||
"COMMIT" | "ROLLBACK" => self.in_transaction = false,
|
||
_ => {}
|
||
}
|
||
Ok(crate::transaction::TransactionIoSuccess {
|
||
result: dbx_core::db::QueryResult {
|
||
columns: Vec::new(),
|
||
column_types: Vec::new(),
|
||
column_sortables: Vec::new(),
|
||
spatial_columns: Vec::new(),
|
||
spatial_values: Vec::new(),
|
||
rows: Vec::new(),
|
||
affected_rows: 0,
|
||
execution_time_ms: 0,
|
||
server_execute_time_us: None,
|
||
query_timings_ms: None,
|
||
truncated: false,
|
||
session_id: None,
|
||
has_more: false,
|
||
elasticsearch_raw_body: None,
|
||
messages: Vec::new(),
|
||
},
|
||
in_transaction: self.in_transaction,
|
||
})
|
||
}
|
||
|
||
async fn ping_in_transaction(&mut self) -> Result<bool, crate::transaction::TransactionIoError> {
|
||
Ok(self.in_transaction)
|
||
}
|
||
|
||
async fn disconnect(&mut self) {
|
||
self.disconnects.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn transaction_sql_allowlist_accepts_only_rollback_safe_mysql_dml_and_queries() {
|
||
for sql in [
|
||
"SELECT id FROM accounts WHERE id = 1",
|
||
"SELECT id FROM accounts WHERE id = 1 FOR UPDATE",
|
||
"SELECT CONNECTION_ID(), VERSION(), SLEEP(0)",
|
||
"SELECT COUNT(*), LOWER(name), COALESCE(name, '') FROM accounts",
|
||
"INSERT INTO accounts(id) VALUES (1)",
|
||
"UPDATE accounts SET name = 'safe' WHERE id = 1",
|
||
"DELETE FROM accounts WHERE id = 1",
|
||
"REPLACE INTO accounts(id) VALUES (1)",
|
||
] {
|
||
assert!(validate_transaction_sql_shape(sql).is_ok(), "expected allowed: {sql}");
|
||
}
|
||
|
||
for sql in [
|
||
"CREATE TABLE t(id INT)",
|
||
"CREATE TEMPORARY TABLE t(id INT)",
|
||
"ALTER TABLE t ADD COLUMN name TEXT",
|
||
"DROP TABLE t",
|
||
"CALL mutate_data()",
|
||
"LOAD DATA INFILE '/tmp/input' INTO TABLE t",
|
||
"LOCK TABLES t WRITE",
|
||
"UNLOCK TABLES",
|
||
"SET autocommit = 0",
|
||
"USE another_database",
|
||
"XA START 'x'",
|
||
"BEGIN",
|
||
"COMMIT",
|
||
"ROLLBACK",
|
||
"SELECT 1 INTO OUTFILE '/tmp/output'",
|
||
"SELECT @value := 1",
|
||
"SELECT evil_udf(id) FROM accounts",
|
||
"SELECT app.evil_udf(id) FROM accounts",
|
||
"SELECT (SELECT evil_udf())",
|
||
"INSERT INTO accounts(id) VALUES (evil_udf(1))",
|
||
"UPDATE accounts SET name = evil_udf(name) WHERE id = 1",
|
||
"DELETE FROM accounts WHERE evil_udf(id) = 1",
|
||
"/*!40101 SET autocommit = 0 */",
|
||
"SELECT 1; DELETE FROM accounts",
|
||
] {
|
||
assert!(validate_transaction_sql_shape(sql).is_err(), "expected rejected: {sql}");
|
||
}
|
||
}
|
||
|
||
type RecordedPluginToolCalls = std::sync::Mutex<Vec<(String, String, Option<String>, serde_json::Value)>>;
|
||
|
||
struct FakeBackend {
|
||
connections: Vec<ConnectionConfig>,
|
||
policy: McpGlobalPolicy,
|
||
recorded_arguments: std::sync::Mutex<Vec<(String, serde_json::Value)>>,
|
||
history: std::sync::Mutex<Vec<dbx_core::history::HistoryEntry>>,
|
||
closed_sessions: std::sync::Mutex<Vec<String>>,
|
||
pinned_sessions: std::sync::Mutex<HashSet<String>>,
|
||
close_failures_remaining: std::sync::Mutex<usize>,
|
||
transaction_owners_opened: AtomicUsize,
|
||
transaction_owner_sql: Arc<std::sync::Mutex<Vec<String>>>,
|
||
transaction_block_next_sql: Arc<std::sync::Mutex<Option<Arc<tokio::sync::Notify>>>>,
|
||
transaction_owner_disconnects: Arc<AtomicUsize>,
|
||
transaction_owner_budget: Arc<tokio::sync::Semaphore>,
|
||
transaction_open_before: Option<(Arc<tokio::sync::Notify>, Arc<tokio::sync::Notify>)>,
|
||
transaction_open_after_owner: Option<(Arc<tokio::sync::Notify>, Arc<tokio::sync::Notify>)>,
|
||
transaction_open_error: Option<String>,
|
||
policy_override: std::sync::Mutex<Option<McpGlobalPolicy>>,
|
||
salesforce_identity: Option<SalesforceCurrentUser>,
|
||
plugin_providers: Vec<crate::plugin_tools::PluginToolProvider>,
|
||
plugin_tool_calls: RecordedPluginToolCalls,
|
||
}
|
||
|
||
impl Default for FakeBackend {
|
||
fn default() -> Self {
|
||
Self {
|
||
connections: Vec::new(),
|
||
policy: McpGlobalPolicy::default(),
|
||
recorded_arguments: std::sync::Mutex::new(Vec::new()),
|
||
history: std::sync::Mutex::new(Vec::new()),
|
||
closed_sessions: std::sync::Mutex::new(Vec::new()),
|
||
pinned_sessions: std::sync::Mutex::new(HashSet::new()),
|
||
close_failures_remaining: std::sync::Mutex::new(0),
|
||
transaction_owners_opened: AtomicUsize::new(0),
|
||
transaction_owner_sql: Arc::new(std::sync::Mutex::new(Vec::new())),
|
||
transaction_block_next_sql: Arc::new(std::sync::Mutex::new(None)),
|
||
transaction_owner_disconnects: Arc::new(AtomicUsize::new(0)),
|
||
transaction_owner_budget: Arc::new(tokio::sync::Semaphore::new(32)),
|
||
transaction_open_before: None,
|
||
transaction_open_after_owner: None,
|
||
transaction_open_error: None,
|
||
policy_override: std::sync::Mutex::new(None),
|
||
salesforce_identity: None,
|
||
plugin_providers: Vec::new(),
|
||
plugin_tool_calls: std::sync::Mutex::new(Vec::new()),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn connection(id: &str, name: &str, db_type: &str, database: &str) -> ConnectionConfig {
|
||
serde_json::from_value(serde_json::json!({
|
||
"id": id,
|
||
"name": name,
|
||
"db_type": db_type,
|
||
"host": "",
|
||
"port": 0,
|
||
"username": "",
|
||
"password": "",
|
||
"database": database,
|
||
"ssl": false
|
||
}))
|
||
.unwrap()
|
||
}
|
||
|
||
fn resolved_connection_for_test(connection: ConnectionConfig) -> ResolvedConnection {
|
||
ResolvedConnection {
|
||
connection,
|
||
policy: McpGlobalPolicy::default(),
|
||
database_scope: DatabaseScope::All,
|
||
group_ids: Vec::new(),
|
||
}
|
||
}
|
||
|
||
fn result_text(result: &CallToolResult) -> &str {
|
||
result.content[0].as_text().expect("text tool result").text.as_str()
|
||
}
|
||
|
||
fn opened_session_id(result: &CallToolResult) -> String {
|
||
result_text(result)
|
||
.lines()
|
||
.find_map(|line| line.strip_prefix("session_id: "))
|
||
.expect("open_session returns a session_id")
|
||
.to_string()
|
||
}
|
||
|
||
#[async_trait]
|
||
impl DbxBackend for FakeBackend {
|
||
async fn save_history_entry(&self, entry: &dbx_core::history::HistoryEntry) -> Result<(), String> {
|
||
self.history.lock().unwrap().push(entry.clone());
|
||
Ok(())
|
||
}
|
||
async fn load_mcp_global_policy(&self) -> Result<McpGlobalPolicy, String> {
|
||
Ok(self.policy_override.lock().unwrap().clone().unwrap_or_else(|| self.policy.clone()))
|
||
}
|
||
|
||
async fn load_connections(&self) -> Result<Vec<ConnectionConfig>, String> {
|
||
Ok(self.connections.clone())
|
||
}
|
||
|
||
async fn list_plugin_mcp_tools(&self) -> Result<Vec<crate::plugin_tools::PluginToolProvider>, String> {
|
||
Ok(self.plugin_providers.clone())
|
||
}
|
||
|
||
async fn call_plugin_mcp_tool(
|
||
&self,
|
||
plugin_id: &str,
|
||
tool: &str,
|
||
connection_id: Option<&str>,
|
||
arguments: &serde_json::Value,
|
||
) -> Result<serde_json::Value, String> {
|
||
self.plugin_tool_calls.lock().unwrap().push((
|
||
plugin_id.to_string(),
|
||
tool.to_string(),
|
||
connection_id.map(str::to_string),
|
||
arguments.clone(),
|
||
));
|
||
Ok(serde_json::json!({
|
||
"content": [{ "type": "text", "text": format!("{plugin_id}/{tool} ok") }],
|
||
"isError": false
|
||
}))
|
||
}
|
||
|
||
async fn open_transaction_owner(
|
||
&self,
|
||
_connection: &ConnectionConfig,
|
||
_database: &str,
|
||
_client_session_id: &str,
|
||
) -> Result<Arc<crate::transaction::TransactionOwner>, String> {
|
||
if let Some(error) = &self.transaction_open_error {
|
||
return Err(error.clone());
|
||
}
|
||
if let Some((entered, release)) = &self.transaction_open_before {
|
||
entered.notify_one();
|
||
release.notified().await;
|
||
}
|
||
self.transaction_owners_opened.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||
let permit = self
|
||
.transaction_owner_budget
|
||
.clone()
|
||
.try_acquire_owned()
|
||
.map_err(|_| "Too many open transaction-enabled MCP sessions (max 32).".to_string())?;
|
||
let owner = crate::transaction::TransactionOwner::spawn_with_resource_permit(
|
||
FakeTransactionIo {
|
||
in_transaction: false,
|
||
executed_sql: self.transaction_owner_sql.clone(),
|
||
block_next_sql: self.transaction_block_next_sql.clone(),
|
||
disconnects: self.transaction_owner_disconnects.clone(),
|
||
},
|
||
crate::transaction::TransactionOwnerConfig::default(),
|
||
permit,
|
||
);
|
||
if let Some((entered, release)) = &self.transaction_open_after_owner {
|
||
entered.notify_one();
|
||
release.notified().await;
|
||
}
|
||
Ok(owner)
|
||
}
|
||
|
||
async fn execute_agent_tool(
|
||
&self,
|
||
_connection: &ConnectionConfig,
|
||
_database: &str,
|
||
tool_name: &str,
|
||
arguments: serde_json::Value,
|
||
_permissions: dbx_core::agent_tools::AgentSqlPermissions,
|
||
) -> dbx_core::agent_events::ToolResult {
|
||
let is_error = tool_name == "execute_query"
|
||
&& arguments["sql"].as_str().is_some_and(|sql| sql.contains("FAIL_MCP_TEST"));
|
||
if let Some(client_session_id) =
|
||
arguments.get("client_session_id").and_then(serde_json::Value::as_str).filter(|id| !id.is_empty())
|
||
{
|
||
self.pinned_sessions.lock().unwrap().insert(client_session_id.to_string());
|
||
}
|
||
self.recorded_arguments.lock().unwrap().push((tool_name.to_string(), arguments));
|
||
dbx_core::agent_events::ToolResult {
|
||
tool_call_id: "test".to_string(),
|
||
tool_name: tool_name.to_string(),
|
||
content: if is_error { "Error: query failed" } else { "ok" }.to_string(),
|
||
is_error,
|
||
explain_data: None,
|
||
}
|
||
}
|
||
|
||
async fn salesforce_current_user(
|
||
&self,
|
||
_connection: &ConnectionConfig,
|
||
) -> Result<SalesforceCurrentUser, String> {
|
||
self.salesforce_identity.clone().ok_or_else(|| "no Salesforce pool".to_string())
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
async fn peek_messages(
|
||
&self,
|
||
connection: &ConnectionConfig,
|
||
topic: dbx_core::mq::TopicRef,
|
||
count: u32,
|
||
options: dbx_core::mq::PeekMessagesOptions,
|
||
) -> Result<dbx_core::mq::PeekMessagesResult, String> {
|
||
self.recorded_arguments.lock().unwrap().push((
|
||
"peek_messages".into(),
|
||
json!({"connectionId": connection.id, "topic": topic, "count": count, "options": options}),
|
||
));
|
||
Ok(dbx_core::mq::PeekMessagesResult {
|
||
messages: vec![dbx_core::mq::PeekedMessage {
|
||
payload_base64: "aGk=".into(),
|
||
payload_text: Some("hi".into()),
|
||
..Default::default()
|
||
}],
|
||
incomplete: true,
|
||
})
|
||
}
|
||
|
||
async fn close_client_session(
|
||
&self,
|
||
_connection_id: &str,
|
||
_database: &str,
|
||
client_session_id: &str,
|
||
) -> Result<bool, String> {
|
||
let mut failures = self.close_failures_remaining.lock().unwrap();
|
||
if *failures > 0 {
|
||
*failures -= 1;
|
||
return Err("temporary close failure".to_string());
|
||
}
|
||
drop(failures);
|
||
self.closed_sessions.lock().unwrap().push(client_session_id.to_string());
|
||
self.pinned_sessions.lock().unwrap().remove(client_session_id);
|
||
Ok(true)
|
||
}
|
||
|
||
async fn add_connection_for_mcp(&self, config: ConnectionConfig) -> Result<ConnectionConfig, String> {
|
||
Ok(config)
|
||
}
|
||
|
||
async fn duplicate_connection_for_mcp(
|
||
&self,
|
||
source_id: &str,
|
||
copy_id: &str,
|
||
copy_name: &str,
|
||
) -> Result<ConnectionConfig, String> {
|
||
let mut copy = self
|
||
.connections
|
||
.iter()
|
||
.find(|connection| connection.id == source_id)
|
||
.cloned()
|
||
.ok_or_else(|| "source not found".to_string())?;
|
||
copy.id = copy_id.to_string();
|
||
copy.name = copy_name.to_string();
|
||
Ok(copy)
|
||
}
|
||
|
||
async fn remove_connection_for_mcp(&self, _connection_id: &str) -> Result<bool, String> {
|
||
Ok(true)
|
||
}
|
||
|
||
async fn execute_batch(
|
||
&self,
|
||
_connection: &ConnectionConfig,
|
||
_database: &str,
|
||
schema: Option<&str>,
|
||
sql: &str,
|
||
options: dbx_core::query::QueryExecutionOptions,
|
||
) -> Result<Vec<crate::backend::BatchStatementResult>, String> {
|
||
let client_session_id =
|
||
options.client_session_id.as_deref().filter(|id| !id.trim().is_empty()).map(str::to_owned);
|
||
if let Some(client_session_id) = &client_session_id {
|
||
self.pinned_sessions.lock().unwrap().insert(client_session_id.clone());
|
||
}
|
||
self.recorded_arguments.lock().unwrap().push((
|
||
"execute_batch".to_string(),
|
||
json!({
|
||
"sql": sql,
|
||
"schema": schema,
|
||
"continue_on_error": options.continue_on_error,
|
||
"use_transaction": options.use_transaction,
|
||
"client_session_id": client_session_id,
|
||
}),
|
||
));
|
||
let execution_error = sql.contains("FAIL_MCP_TEST") || sql.contains("FAIL_MCP_NO_MESSAGE_TEST");
|
||
|
||
Ok(vec![crate::backend::BatchStatementResult {
|
||
result: dbx_core::db::QueryResult {
|
||
columns: vec![],
|
||
column_types: vec![],
|
||
column_sortables: vec![],
|
||
spatial_columns: vec![],
|
||
spatial_values: vec![],
|
||
rows: vec![],
|
||
affected_rows: 0,
|
||
execution_time_ms: 1,
|
||
server_execute_time_us: None,
|
||
query_timings_ms: None,
|
||
truncated: false,
|
||
session_id: None,
|
||
has_more: false,
|
||
elasticsearch_raw_body: None,
|
||
messages: vec![],
|
||
},
|
||
execution_error,
|
||
statement_index: Some(0),
|
||
error_message: sql.contains("FAIL_MCP_TEST").then(|| "statement failed".to_string()),
|
||
merged: false,
|
||
transaction_state: None,
|
||
transaction_outcome: None,
|
||
}])
|
||
}
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
fn kafka_connection() -> ConnectionConfig {
|
||
let mut conn = connection("kafka", "Kafka", "mq", "");
|
||
conn.read_only = true;
|
||
conn.is_production = true;
|
||
conn.external_config = Some(
|
||
json!({"systemKind":"kafka", "adminUrl":"", "auth":{"kind":"none"}, "extra":{"bootstrapServers":"localhost:9092"}}),
|
||
);
|
||
conn
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[tokio::test]
|
||
async fn peek_messages_reads_with_read_only_policy_and_forwards_positions() {
|
||
let backend = Arc::new(FakeBackend { connections: vec![kafka_connection()], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
for (extra, expected) in [
|
||
(json!({}), json!({"startPosition":"latest"})),
|
||
(json!({"start_position":"earliest", "partition":0}), json!({"startPosition":"earliest", "partition":0})),
|
||
(
|
||
json!({"start_position":"offset", "partition":2, "offset":17}),
|
||
json!({"startPosition":"offset", "partition":2, "offset":17}),
|
||
),
|
||
(json!({"start_position":"offset", "offset":0}), json!({"startPosition":"offset", "offset":0})),
|
||
] {
|
||
let mut request = json!({"connection_id":"kafka", "topic":" events "});
|
||
request.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||
let result = server.peek_messages(Parameters(serde_json::from_value(request).unwrap())).await;
|
||
assert_ne!(result.is_error, Some(true), "{}", result_text(&result));
|
||
let response: serde_json::Value = serde_json::from_str(result_text(&result)).unwrap();
|
||
assert_eq!(response["messages"][0]["payloadBase64"], "aGk=");
|
||
assert_eq!(response["incomplete"], true);
|
||
assert_eq!(response["outputTruncated"], false);
|
||
let calls = backend.recorded_arguments.lock().unwrap();
|
||
let args = &calls.last().unwrap().1;
|
||
assert_eq!(args["options"], expected);
|
||
assert_eq!(args["count"], 20);
|
||
assert_eq!(args["topic"]["topic"], "events");
|
||
}
|
||
}
|
||
|
||
fn plugin_connection(id: &str, name: &str, plugin_id: &str) -> ConnectionConfig {
|
||
serde_json::from_value(json!({
|
||
"id": id,
|
||
"name": name,
|
||
"db_type": "plugin",
|
||
"plugin_id": plugin_id,
|
||
"host": "",
|
||
"port": 0,
|
||
"username": "",
|
||
"password": ""
|
||
}))
|
||
.unwrap()
|
||
}
|
||
|
||
fn plugin_provider(
|
||
plugin_id: &str,
|
||
plugin_name: &str,
|
||
tools: serde_json::Value,
|
||
) -> crate::plugin_tools::PluginToolProvider {
|
||
crate::plugin_tools::PluginToolProvider {
|
||
plugin_id: plugin_id.to_string(),
|
||
plugin_name: plugin_name.to_string(),
|
||
tools: dbx_core::ai::plugin_tools::parse_tool_list(&tools),
|
||
}
|
||
}
|
||
|
||
fn kafka_plugin_listing() -> serde_json::Value {
|
||
json!({
|
||
"tools": [
|
||
{
|
||
"name": "kafka_topics_delete",
|
||
"description": "Delete topics",
|
||
"inputSchema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"connectionId": { "type": "string" },
|
||
"topics": { "type": "array", "items": { "type": "string" } }
|
||
},
|
||
"required": ["connectionId", "topics"]
|
||
}
|
||
},
|
||
{
|
||
"name": "kafka_topics_list",
|
||
"description": "List topics",
|
||
"annotations": { "readOnlyHint": true },
|
||
"inputSchema": {
|
||
"type": "object",
|
||
"properties": { "connectionId": { "type": "string" } }
|
||
}
|
||
}
|
||
]
|
||
})
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_tools_merge_into_tools_list_with_connection_selector() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![
|
||
plugin_connection("k1", "prod", "io.dbx.kafka"),
|
||
plugin_connection("k2", "test", "io.dbx.kafka"),
|
||
plugin_connection("s1", "shell", "io.dbx.ssh"),
|
||
],
|
||
plugin_providers: vec![plugin_provider("io.dbx.kafka", "Kafka Studio", kafka_plugin_listing())],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
let tools = server.policy_filtered_tools().await;
|
||
assert!(tools.iter().any(|tool| tool.name.as_ref() == "dbx_list_connections"), "static tools remain");
|
||
let delete = tools
|
||
.iter()
|
||
.find(|tool| tool.name.as_ref() == "dbx_kafka__kafka_topics_delete")
|
||
.expect("plugin tool listed");
|
||
let properties = delete.input_schema.get("properties").expect("object schema");
|
||
let selector = properties.get("dbx_connection").expect("selector present for multiple connections");
|
||
assert_eq!(selector["enum"], json!(["k1", "k2"]));
|
||
assert!(properties.get("connectionId").is_none(), "host-bound argument stays out of the advertised schema");
|
||
let list = tools.iter().find(|tool| tool.name.as_ref() == "dbx_kafka__kafka_topics_list").unwrap();
|
||
assert!(list.annotations.as_ref().and_then(|a| a.read_only_hint).expect("readOnlyHint passthrough"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_meta_tools_discover_and_call_by_plugin_id() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![
|
||
plugin_connection("k1", "prod", "io.dbx.kafka"),
|
||
plugin_connection("k2", "test", "io.dbx.kafka"),
|
||
],
|
||
plugin_providers: vec![plugin_provider("io.dbx.kafka", "Kafka Studio", kafka_plugin_listing())],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
// dbx_plugin_list: one row, id + counts.
|
||
let list = server.plugin_list(Parameters(PluginListRequest { filter: None })).await;
|
||
assert_eq!(list.is_error, Some(false));
|
||
let text = result_text(&list);
|
||
assert!(text.contains("io.dbx.kafka"), "{text}");
|
||
assert!(text.contains("2 tool(s)") && text.contains("2 allowed connection(s)"), "{text}");
|
||
|
||
// dbx_plugin_list with a filter that matches nothing.
|
||
let none = server.plugin_list(Parameters(PluginListRequest { filter: Some("postgres".into()) })).await;
|
||
assert!(result_text(&none).contains("No DBX plugin matches"), "{}", result_text(&none));
|
||
|
||
// dbx_plugin_tools: per-plugin schemas with the connection selector note.
|
||
let tools = server.plugin_tools(Parameters(PluginToolsRequest { plugin_id: "io.dbx.kafka".into() })).await;
|
||
assert_eq!(tools.is_error, Some(false));
|
||
let text = result_text(&tools);
|
||
assert!(text.contains("kafka_topics_delete") && text.contains("kafka_topics_list"), "{text}");
|
||
assert!(text.contains("dbx_connection"), "multi-connection hint expected: {text}");
|
||
|
||
// Unknown plugin id fails with a discovery pointer.
|
||
let unknown = server.plugin_tools(Parameters(PluginToolsRequest { plugin_id: "io.nope".into() })).await;
|
||
assert_eq!(unknown.is_error, Some(true));
|
||
assert!(result_text(&unknown).contains("does not contribute MCP tools"), "{}", result_text(&unknown));
|
||
|
||
// dbx_plugin_call routes by plugin id + tool name; selector stripped.
|
||
let call = server
|
||
.plugin_call(Parameters(PluginCallRequest {
|
||
plugin_id: "io.dbx.kafka".into(),
|
||
tool: "kafka_topics_delete".into(),
|
||
arguments: Some(json!({ "topics": ["t"], "dbx_connection": "k2" })),
|
||
dbx_connection: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(call.is_error, Some(false), "{}", result_text(&call));
|
||
{
|
||
let calls = backend.plugin_tool_calls.lock().unwrap();
|
||
assert_eq!(calls.len(), 1);
|
||
assert_eq!(calls[0].0, "io.dbx.kafka");
|
||
assert_eq!(calls[0].1, "kafka_topics_delete");
|
||
assert_eq!(calls[0].2.as_deref(), Some("k2"));
|
||
}
|
||
|
||
// Unknown tool under a known plugin id.
|
||
let unknown_tool = server
|
||
.plugin_call(Parameters(PluginCallRequest {
|
||
plugin_id: "io.dbx.kafka".into(),
|
||
tool: "nope".into(),
|
||
arguments: None,
|
||
dbx_connection: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(unknown_tool.is_error, Some(true));
|
||
assert!(result_text(&unknown_tool).contains("does not provide a tool named"), "{}", result_text(&unknown_tool));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_meta_tools_respect_mode_and_policy() {
|
||
// flat 模式(默认构造走 env;此处直接构造 Lazy 验证过滤)——先验证 policy。
|
||
let restricted = Arc::new(FakeBackend {
|
||
policy: McpGlobalPolicy {
|
||
allowed_tool_names: Some(vec!["dbx_plugin_list".to_string(), "dbx_list_connections".to_string()]),
|
||
..Default::default()
|
||
},
|
||
plugin_providers: vec![plugin_provider("io.dbx.kafka", "Kafka Studio", kafka_plugin_listing())],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(restricted, McpScope::default(), false);
|
||
// call/tools 被白名单拒绝。
|
||
let call = server
|
||
.plugin_call(Parameters(PluginCallRequest {
|
||
plugin_id: "io.dbx.kafka".into(),
|
||
tool: "kafka_topics_list".into(),
|
||
arguments: None,
|
||
dbx_connection: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(call.is_error, Some(true));
|
||
assert!(result_text(&call).contains("TOOL_OUT_OF_SCOPE"), "{}", result_text(&call));
|
||
// list 仍在白名单内,可列出。
|
||
let list = server.plugin_list(Parameters(PluginListRequest { filter: None })).await;
|
||
assert_eq!(list.is_error, Some(false), "{}", result_text(&list));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_tools_listing_is_filtered_by_the_flat_allowlist() {
|
||
// dbx_plugin_tools must disclose only what the flat surface would:
|
||
// denied tools stay hidden (with a count note) even though calls are
|
||
// gated separately.
|
||
let restricted = Arc::new(FakeBackend {
|
||
policy: McpGlobalPolicy {
|
||
allowed_tool_names: Some(vec![
|
||
"dbx_plugin_tools".to_string(),
|
||
"dbx_kafka__kafka_topics_list".to_string(),
|
||
]),
|
||
..Default::default()
|
||
},
|
||
plugin_providers: vec![
|
||
plugin_provider("io.dbx.kafka", "Kafka Studio", kafka_plugin_listing()),
|
||
plugin_provider(
|
||
"io.dbx.ssh",
|
||
"Terminal",
|
||
json!({ "tools": [{ "name": "ssh_exec", "description": "Run a command" }] }),
|
||
),
|
||
],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(restricted, McpScope::default(), false);
|
||
let listing = server.plugin_tools(Parameters(PluginToolsRequest { plugin_id: "io.dbx.kafka".into() })).await;
|
||
assert_eq!(listing.is_error, Some(false));
|
||
let text = result_text(&listing);
|
||
assert!(text.contains("kafka_topics_list"), "{text}");
|
||
assert!(!text.contains("kafka_topics_delete"), "denied tool must be hidden: {text}");
|
||
assert!(text.contains("1 further tool(s)"), "{text}");
|
||
|
||
let all_hidden = server.plugin_tools(Parameters(PluginToolsRequest { plugin_id: "io.dbx.ssh".into() })).await;
|
||
assert_eq!(all_hidden.is_error, Some(true));
|
||
assert!(result_text(&all_hidden).contains("All 1 tool(s)"), "{}", result_text(&all_hidden));
|
||
|
||
// A plugin whose every tool is denied resolves to the hidden reason.
|
||
// Unknown plugin ids (never installed) keep the plain not-found text.
|
||
let unknown = server.plugin_tools(Parameters(PluginToolsRequest { plugin_id: "io.nope".into() })).await;
|
||
assert_eq!(unknown.is_error, Some(true));
|
||
assert!(result_text(&unknown).contains("does not contribute MCP tools"), "{}", result_text(&unknown));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_call_is_gated_by_the_flat_tool_allowlist() {
|
||
// The meta tool itself is allowed, but the flat name of the targeted
|
||
// plugin tool is not: lazy access must not bypass the allowlist.
|
||
let restricted = Arc::new(FakeBackend {
|
||
policy: McpGlobalPolicy {
|
||
allowed_tool_names: Some(vec![
|
||
"dbx_plugin_call".to_string(),
|
||
"dbx_kafka__kafka_topics_list".to_string(),
|
||
]),
|
||
..Default::default()
|
||
},
|
||
connections: vec![plugin_connection("k1", "prod", "io.dbx.kafka")],
|
||
plugin_providers: vec![plugin_provider("io.dbx.kafka", "Kafka Studio", kafka_plugin_listing())],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(restricted.clone(), McpScope::default(), false);
|
||
|
||
let denied = server
|
||
.plugin_call(Parameters(PluginCallRequest {
|
||
plugin_id: "io.dbx.kafka".into(),
|
||
tool: "kafka_topics_delete".into(),
|
||
arguments: None,
|
||
dbx_connection: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(denied.is_error, Some(true));
|
||
assert!(result_text(&denied).contains("TOOL_OUT_OF_SCOPE"), "{}", result_text(&denied));
|
||
assert!(restricted.plugin_tool_calls.lock().unwrap().is_empty(), "the backend must not be reached");
|
||
|
||
let allowed = server
|
||
.plugin_call(Parameters(PluginCallRequest {
|
||
plugin_id: "io.dbx.kafka".into(),
|
||
tool: "kafka_topics_list".into(),
|
||
arguments: None,
|
||
dbx_connection: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(allowed.is_error, Some(false), "{}", result_text(&allowed));
|
||
assert_eq!(restricted.plugin_tool_calls.lock().unwrap().len(), 1);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_tools_mode_switches_advertised_views() {
|
||
// default(flat):router 禁用 meta 路由。
|
||
let flat = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
let flat_router = &flat.tool_router;
|
||
assert!(flat_router.list_all().iter().all(|tool| !tool.name.as_ref().starts_with("dbx_plugin_")));
|
||
// lazy 模式:保留 meta 路由(mode 注入,避免并行测试间的环境变量竞态)。
|
||
let lazy = DbxMcpServer::with_plugin_tools_mode(
|
||
Arc::new(FakeBackend::default()),
|
||
McpScope::default(),
|
||
false,
|
||
PluginToolsMode::Lazy,
|
||
);
|
||
let binding = lazy.tool_router.list_all();
|
||
let names: Vec<&str> = binding.iter().map(|tool| tool.name.as_ref()).collect();
|
||
for expected in ["dbx_plugin_list", "dbx_plugin_tools", "dbx_plugin_call"] {
|
||
assert!(names.contains(&expected), "{expected} missing in {names:?}");
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn plugin_tool_calls_bind_connections_and_respect_policy() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![
|
||
plugin_connection("k1", "prod", "io.dbx.kafka"),
|
||
plugin_connection("k2", "test", "io.dbx.kafka"),
|
||
plugin_connection("s1", "shell", "io.dbx.ssh"),
|
||
],
|
||
plugin_providers: vec![plugin_provider("io.dbx.kafka", "Kafka Studio", kafka_plugin_listing())],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
// Several connections: a missing selector is an error that names the argument.
|
||
let missing = server
|
||
.call_plugin_tool_dispatch("dbx_kafka__kafka_topics_delete", json!({ "topics": ["t"] }))
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(missing.is_error, Some(true));
|
||
assert!(result_text(&missing).contains("dbx_connection"), "{}", result_text(&missing));
|
||
|
||
// A selector pointing at another plugin's connection is rejected.
|
||
let cross = server
|
||
.call_plugin_tool_dispatch(
|
||
"dbx_kafka__kafka_topics_delete",
|
||
json!({ "topics": ["t"], "dbx_connection": "s1" }),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(cross.is_error, Some(true));
|
||
assert!(result_text(&cross).contains("not an allowed connection"), "{}", result_text(&cross));
|
||
|
||
// An explicit selector binds host-side; selector keys are stripped and
|
||
// the plugin's declared connectionId is injected.
|
||
let ok = server
|
||
.call_plugin_tool_dispatch(
|
||
"dbx_kafka__kafka_topics_delete",
|
||
json!({ "topics": ["t"], "dbx_connection": "k2" }),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(ok.is_error, Some(false), "{}", result_text(&ok));
|
||
{
|
||
let calls = backend.plugin_tool_calls.lock().unwrap();
|
||
assert_eq!(calls.len(), 1);
|
||
assert_eq!(calls[0].0, "io.dbx.kafka");
|
||
assert_eq!(calls[0].1, "kafka_topics_delete");
|
||
assert_eq!(calls[0].2.as_deref(), Some("k2"));
|
||
assert_eq!(calls[0].3["connectionId"], "k2");
|
||
assert!(calls[0].3.get("dbx_connection").is_none());
|
||
}
|
||
|
||
// Unknown plugin namespace name fails cleanly.
|
||
let unknown = server.call_plugin_tool_dispatch("dbx_kafka__nope", json!({})).await.unwrap();
|
||
assert!(result_text(&unknown).contains("not available"), "{}", result_text(&unknown));
|
||
|
||
// The global policy tool allowlist applies to exposed plugin names.
|
||
let restricted = Arc::new(FakeBackend {
|
||
policy: McpGlobalPolicy {
|
||
allowed_tool_names: Some(vec!["dbx_list_connections".to_string()]),
|
||
..Default::default()
|
||
},
|
||
connections: backend.connections.clone(),
|
||
plugin_providers: backend.plugin_providers.clone(),
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(restricted, McpScope::default(), false);
|
||
let blocked = server
|
||
.call_plugin_tool_dispatch("dbx_kafka__kafka_topics_delete", json!({ "topics": ["t"] }))
|
||
.await
|
||
.unwrap();
|
||
assert_eq!(blocked.is_error, Some(true));
|
||
assert!(result_text(&blocked).contains("TOOL_OUT_OF_SCOPE"), "{}", result_text(&blocked));
|
||
let tools = server.policy_filtered_tools().await;
|
||
assert!(!tools.iter().any(|tool| tool.name.as_ref() == "dbx_kafka__kafka_topics_delete"));
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[tokio::test]
|
||
async fn peek_messages_rejects_invalid_options_before_backend_call() {
|
||
let backend = Arc::new(FakeBackend { connections: vec![kafka_connection()], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
for extra in [
|
||
json!({"count":0}),
|
||
json!({"count":101}),
|
||
json!({"partition":-1}),
|
||
json!({"start_position":"offset"}),
|
||
json!({"offset":1}),
|
||
json!({"start_position":"earliest", "offset":0}),
|
||
json!({"start_position":"offset", "offset":-1}),
|
||
json!({"topic":" "}),
|
||
] {
|
||
let mut request = json!({"connection_id":"kafka", "topic":"events"});
|
||
request.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
|
||
let result = server.peek_messages(Parameters(serde_json::from_value(request).unwrap())).await;
|
||
assert_eq!(result.is_error, Some(true), "{}", result_text(&result));
|
||
}
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[tokio::test]
|
||
async fn peek_messages_enforces_tool_connection_scope_and_kafka_only() {
|
||
for (policy, conn, expected) in [
|
||
(
|
||
McpGlobalPolicy { allowed_tool_names: Some(vec![]), ..Default::default() },
|
||
kafka_connection(),
|
||
"TOOL_OUT_OF_SCOPE",
|
||
),
|
||
(
|
||
McpGlobalPolicy { allowed_connection_ids: Some(vec![]), ..Default::default() },
|
||
kafka_connection(),
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
),
|
||
(McpGlobalPolicy::default(), connection("kafka", "redis", "redis", "0"), "MQ_UNSUPPORTED"),
|
||
] {
|
||
let backend = Arc::new(FakeBackend { policy, connections: vec![conn], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let result = server
|
||
.peek_messages(Parameters(
|
||
serde_json::from_value(json!({"connection_id":"kafka", "topic":"events"})).unwrap(),
|
||
))
|
||
.await;
|
||
assert_eq!(result.is_error, Some(true));
|
||
assert!(result_text(&result).contains(expected), "{}", result_text(&result));
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[tokio::test]
|
||
async fn peek_messages_respects_session_scope_and_rejects_other_queues() {
|
||
let mut rabbit = kafka_connection();
|
||
rabbit.external_config.as_mut().unwrap()["systemKind"] = json!("rabbitmq");
|
||
for (conn, scope, expected) in [
|
||
(
|
||
kafka_connection(),
|
||
McpScope { connection_ids: vec!["other".into()], ..Default::default() },
|
||
"CONNECTION_OUT_OF_SCOPE",
|
||
),
|
||
(rabbit, McpScope::default(), "MQ_UNSUPPORTED"),
|
||
] {
|
||
let backend = Arc::new(FakeBackend { connections: vec![conn], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), scope, false);
|
||
let result = server
|
||
.peek_messages(Parameters(
|
||
serde_json::from_value(json!({"connection_id":"kafka", "topic":"events"})).unwrap(),
|
||
))
|
||
.await;
|
||
assert_eq!(result.is_error, Some(true));
|
||
assert!(result_text(&result).contains(expected), "{}", result_text(&result));
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[test]
|
||
fn peek_messages_output_preserves_metadata_and_bounds_whole_messages() {
|
||
use dbx_core::mq::{PeekMessagesResult, PeekedMessage};
|
||
let message = PeekedMessage {
|
||
payload_base64: "/w==".into(),
|
||
message_id: Some("2:17".into()),
|
||
headers: [("kind".into(), "event".into())].into(),
|
||
..Default::default()
|
||
};
|
||
let output = format_peek_messages_result(PeekMessagesResult::complete(vec![message.clone(), message]), 1);
|
||
let result: serde_json::Value = serde_json::from_str(&output).unwrap();
|
||
assert_eq!(result["messages"].as_array().unwrap().len(), 1);
|
||
assert_eq!(result["messages"][0]["messageId"], "2:17");
|
||
assert_eq!(result["messages"][0]["headers"]["kind"], "event");
|
||
assert_eq!(result["outputTruncated"], true);
|
||
assert_eq!(result["incomplete"], false);
|
||
let output = format_peek_messages_result(
|
||
PeekMessagesResult::complete(vec![PeekedMessage {
|
||
payload_base64: "a".repeat(300_000),
|
||
..Default::default()
|
||
}]),
|
||
20,
|
||
);
|
||
let result: serde_json::Value = serde_json::from_str(&output).unwrap();
|
||
assert!(result["messages"].as_array().unwrap().is_empty());
|
||
assert_eq!(result["outputTruncated"], true);
|
||
assert!(output.len() < 256 * 1024);
|
||
}
|
||
|
||
#[test]
|
||
fn connection_table_escapes_markdown_cells() {
|
||
let output = format_connections(&[ConnectionSummary {
|
||
id: "id|1".to_string(),
|
||
name: "local\npg".to_string(),
|
||
db_type: "postgres".to_string(),
|
||
host: "127.0.0.1".to_string(),
|
||
port: 5432,
|
||
database: "app".to_string(),
|
||
group_path: vec!["Project|A".to_string(), "Staging\nWest".to_string()],
|
||
}]);
|
||
assert!(output.contains("id\\|1"));
|
||
assert!(output.contains("local pg"));
|
||
assert!(output.contains("Project\\|A / Staging West"));
|
||
}
|
||
|
||
#[test]
|
||
fn server_registers_list_connections_tool() {
|
||
let server = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
let tools = server.tool_router.list_all();
|
||
let names = tools.iter().map(|tool| tool.name.as_ref()).collect::<Vec<_>>();
|
||
#[cfg(feature = "mq-admin")]
|
||
assert_eq!(tools.len(), 25);
|
||
#[cfg(not(feature = "mq-admin"))]
|
||
assert_eq!(tools.len(), 23);
|
||
#[cfg(feature = "mq-admin")]
|
||
assert!(names.contains(&"dbx_peek_messages"));
|
||
#[cfg(not(feature = "mq-admin"))]
|
||
assert!(!names.contains(&"dbx_peek_messages"));
|
||
assert!(names.contains(&"dbx_list_connections"));
|
||
assert!(names.contains(&"dbx_list_databases"));
|
||
assert!(names.contains(&"dbx_list_tables"));
|
||
assert!(names.contains(&"dbx_describe_table"));
|
||
assert!(names.contains(&"dbx_list_routines"));
|
||
assert!(names.contains(&"dbx_get_routine_source"));
|
||
assert!(names.contains(&"dbx_execute_query"));
|
||
assert!(names.contains(&"dbx_execute_batch"));
|
||
assert!(names.contains(&"dbx_begin_transaction"));
|
||
assert!(names.contains(&"dbx_commit_transaction"));
|
||
assert!(names.contains(&"dbx_rollback_transaction"));
|
||
assert!(names.contains(&"dbx_add_connection"));
|
||
assert!(names.contains(&"dbx_duplicate_connection"));
|
||
assert!(names.contains(&"dbx_remove_connection"));
|
||
assert!(names.contains(&"dbx_execute_redis_command"));
|
||
assert!(names.contains(&"dbx_salesforce_current_user"));
|
||
assert!(names.contains(&"dbx_salesforce_prepare_write"));
|
||
assert!(names.contains(&"dbx_salesforce_apply_write"));
|
||
assert!(names.contains(&"dbx_get_schema_context"));
|
||
assert!(names.contains(&"dbx_open_table"));
|
||
assert!(names.contains(&"dbx_execute_and_show"));
|
||
assert!(names.contains(&"dbx_open_session"));
|
||
assert!(names.contains(&"dbx_close_session"));
|
||
#[cfg(feature = "mq-admin")]
|
||
assert!(names.contains(&"dbx_send_message"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn tools_list_hides_tools_the_policy_disallows() {
|
||
let policy = McpGlobalPolicy {
|
||
allowed_tool_names: Some(vec!["dbx_list_connections".to_string(), "dbx_execute_query".to_string()]),
|
||
..Default::default()
|
||
};
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend { policy, ..Default::default() }),
|
||
McpScope::default(),
|
||
false,
|
||
);
|
||
|
||
let tools = server.policy_filtered_tools().await;
|
||
let names = tools.iter().map(|tool| tool.name.as_ref()).collect::<Vec<_>>();
|
||
|
||
assert_eq!(names, vec!["dbx_execute_query", "dbx_list_connections"]);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn tools_list_keeps_the_full_view_without_an_allowlist() {
|
||
let server = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
|
||
let tools = server.policy_filtered_tools().await;
|
||
|
||
assert_eq!(tools.len(), server.tool_router.list_all().len());
|
||
}
|
||
|
||
#[test]
|
||
fn schema_context_tables_schema_is_gemini_compatible() {
|
||
let server = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
let tool = server
|
||
.tool_router
|
||
.list_all()
|
||
.into_iter()
|
||
.find(|tool| tool.name == "dbx_get_schema_context")
|
||
.expect("schema context tool should be registered");
|
||
let tables = tool
|
||
.input_schema
|
||
.get("properties")
|
||
.and_then(serde_json::Value::as_object)
|
||
.and_then(|properties| properties.get("tables"))
|
||
.expect("tables property should be published");
|
||
|
||
assert_eq!(tables.get("type"), Some(&serde_json::json!("array")));
|
||
assert_eq!(tables.pointer("/items/type"), Some(&serde_json::json!("string")));
|
||
assert!(!tool
|
||
.input_schema
|
||
.get("required")
|
||
.and_then(serde_json::Value::as_array)
|
||
.is_some_and(|required| required.iter().any(|field| field == "tables")));
|
||
}
|
||
|
||
#[test]
|
||
fn connection_selector_schema_uses_optional_strings() {
|
||
let server = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
let tools = server.tool_router.list_all();
|
||
|
||
for tool_name in ["dbx_execute_query", "dbx_list_tables", "dbx_open_session"] {
|
||
let tool = tools.iter().find(|tool| tool.name == tool_name).expect("selector tool should be registered");
|
||
let properties = tool
|
||
.input_schema
|
||
.get("properties")
|
||
.and_then(serde_json::Value::as_object)
|
||
.expect("selector tool should publish object properties");
|
||
let required = tool
|
||
.input_schema
|
||
.get("required")
|
||
.and_then(serde_json::Value::as_array)
|
||
.into_iter()
|
||
.flatten()
|
||
.collect::<Vec<_>>();
|
||
|
||
for field in ["connection_id", "connection_name"] {
|
||
let selector = properties.get(field).expect("selector field should be published");
|
||
assert_eq!(selector.get("type"), Some(&serde_json::json!("string")), "{tool_name}.{field}");
|
||
assert!(!required.iter().any(|required| *required == field), "{tool_name}.{field} must stay optional");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn optional_fields_never_publish_nullable_union_types() {
|
||
// Some MCP clients (e.g. OpenCode, see #6344) cannot resolve a JSON Schema
|
||
// `"type": ["string", "null"]` union and fall back to wrapping the argument in a
|
||
// nested error object instead of passing the value through. b521d0377 fixed this for
|
||
// `ConnectionSelector`'s connection_id/connection_name but left every other optional
|
||
// field on these request structs emitting the same union shape. Every optional field
|
||
// must instead publish a single concrete `type`, relying on omission from `required`
|
||
// (not a `"null"` union member) to signal optionality.
|
||
let server = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
let tools = server.tool_router.list_all();
|
||
|
||
#[allow(unused_mut)]
|
||
let mut checks: Vec<(&str, &[&str])> = vec![
|
||
("dbx_list_tables", &["database", "schema"]),
|
||
("dbx_describe_table", &["database", "schema"]),
|
||
("dbx_list_routines", &["database", "schema", "routine_type"]),
|
||
("dbx_get_routine_source", &["database", "schema", "signature"]),
|
||
("dbx_execute_query", &["database", "session_id", "cell_char_offset", "cell_char_limit", "max_rows"]),
|
||
(
|
||
"dbx_execute_batch",
|
||
&[
|
||
"database",
|
||
"session_id",
|
||
"continue_on_error",
|
||
"use_transaction",
|
||
"cell_char_offset",
|
||
"cell_char_limit",
|
||
],
|
||
),
|
||
("dbx_open_session", &["database", "enable_transactions"]),
|
||
("dbx_open_table", &["database", "schema"]),
|
||
("dbx_execute_and_show", &["database"]),
|
||
("dbx_add_connection", &["port", "database", "driver_profile"]),
|
||
("dbx_remove_connection", &["connection_id", "connection_name"]),
|
||
("dbx_execute_redis_command", &["db"]),
|
||
("dbx_get_schema_context", &["database", "schema", "max_tables"]),
|
||
];
|
||
#[cfg(feature = "mq-admin")]
|
||
checks
|
||
.push(("dbx_send_message", &["key", "payload_text", "partition", "exchange", "routing_key", "namespace"]));
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
checks.push(("dbx_peek_messages", &["count", "partition", "offset"]));
|
||
for (tool_name, fields) in checks {
|
||
let tool = tools.iter().find(|tool| tool.name == *tool_name).expect("tool should be registered");
|
||
let properties = tool
|
||
.input_schema
|
||
.get("properties")
|
||
.and_then(serde_json::Value::as_object)
|
||
.expect("tool should publish object properties");
|
||
let required = tool
|
||
.input_schema
|
||
.get("required")
|
||
.and_then(serde_json::Value::as_array)
|
||
.into_iter()
|
||
.flatten()
|
||
.collect::<Vec<_>>();
|
||
|
||
for &field in fields {
|
||
let schema = properties.get(field).unwrap_or_else(|| panic!("{tool_name}.{field} should be published"));
|
||
let type_value =
|
||
schema.get("type").unwrap_or_else(|| panic!("{tool_name}.{field} should publish a type"));
|
||
assert!(
|
||
type_value.is_string(),
|
||
"{tool_name}.{field} must publish a single concrete type, not a union: {type_value:?}"
|
||
);
|
||
assert!(!required.iter().any(|required| *required == field), "{tool_name}.{field} must stay optional");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn execute_query_selector_preserves_serde_inputs() {
|
||
let omitted: ExecuteQueryRequest = serde_json::from_str(r#"{"sql":"SELECT 1"}"#).unwrap();
|
||
let explicit_nulls: ExecuteQueryRequest =
|
||
serde_json::from_str(r#"{"connection_id":null,"connection_name":null,"sql":"SELECT 1"}"#).unwrap();
|
||
let by_name: ExecuteQueryRequest =
|
||
serde_json::from_str(r#"{"connection_name":"test_conn","sql":"SELECT 1"}"#).unwrap();
|
||
let by_id: ExecuteQueryRequest =
|
||
serde_json::from_str(r#"{"connection_id":"123e4567-e89b-12d3-a456-426614174000","sql":"SELECT 1"}"#)
|
||
.unwrap();
|
||
|
||
assert!(omitted.selector.connection_id.is_none());
|
||
assert!(omitted.selector.connection_name.is_none());
|
||
assert!(omitted.max_rows.is_none());
|
||
assert!(explicit_nulls.selector.connection_id.is_none());
|
||
assert!(explicit_nulls.selector.connection_name.is_none());
|
||
assert_eq!(by_name.selector.connection_name.as_deref(), Some("test_conn"));
|
||
assert_eq!(by_id.selector.connection_id.as_deref(), Some("123e4567-e89b-12d3-a456-426614174000"));
|
||
|
||
let with_max_rows: ExecuteQueryRequest = serde_json::from_str(r#"{"sql":"SELECT 1","max_rows":500}"#).unwrap();
|
||
assert_eq!(with_max_rows.max_rows, Some(500));
|
||
|
||
let nested = serde_json::from_str::<ExecuteQueryRequest>(
|
||
r#"{"connection_name":{"tool":"dbx_dbx_execute_query","error":"Invalid input"},"sql":"SELECT 1"}"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(nested.to_string().contains("invalid type: map, expected a string"));
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[test]
|
||
fn send_message_request_preserves_binary_payload_and_optional_fields() {
|
||
let request: SendMessageRequest = serde_json::from_str(
|
||
r#"{"connection_name":"events","topic":"orders","payload_base64":"AP8=","key":"order-1","partition":2,"headers":{"trace":"abc"}}"#,
|
||
)
|
||
.expect("send message request");
|
||
|
||
assert_eq!(request.selector.connection_name.as_deref(), Some("events"));
|
||
assert_eq!(request.topic, "orders");
|
||
assert_eq!(request.payload_base64, "AP8=");
|
||
assert_eq!(request.key.as_deref(), Some("order-1"));
|
||
assert_eq!(request.partition, Some(2));
|
||
assert_eq!(request.headers.get("trace").map(String::as_str), Some("abc"));
|
||
}
|
||
|
||
#[cfg(feature = "mq-admin")]
|
||
#[test]
|
||
fn format_send_message_result_is_concise_and_includes_delivery_metadata() {
|
||
let result = dbx_core::mq::SendMessageResponse {
|
||
topic: "orders".to_string(),
|
||
partition: 2,
|
||
offset: 41,
|
||
timestamp: Some("1700000000000".to_string()),
|
||
};
|
||
let output = format_send_message_result(&dbx_core::mq::MqSystemKind::Kafka, &result);
|
||
|
||
assert!(output.contains("Message sent to kafka."));
|
||
assert!(output.contains("topic: orders"));
|
||
assert!(output.contains("partition: 2"));
|
||
assert!(output.contains("offset: 41"));
|
||
assert!(output.contains("timestamp: 1700000000000"));
|
||
assert!(!output.contains("AP8="));
|
||
}
|
||
|
||
#[test]
|
||
fn schema_context_tables_preserve_optional_inputs() {
|
||
let omitted: SchemaContextRequest = serde_json::from_str("{}").unwrap();
|
||
let explicit_null: SchemaContextRequest = serde_json::from_str(r#"{"tables":null}"#).unwrap();
|
||
let empty: SchemaContextRequest = serde_json::from_str(r#"{"tables":[]}"#).unwrap();
|
||
let populated: SchemaContextRequest = serde_json::from_str(r#"{"tables":["users","orders"]}"#).unwrap();
|
||
|
||
assert_eq!(omitted.tables, None);
|
||
assert_eq!(explicit_null.tables, None);
|
||
assert_eq!(empty.tables, Some(Vec::new()));
|
||
assert_eq!(populated.tables, Some(vec!["users".to_string(), "orders".to_string()]));
|
||
}
|
||
|
||
#[test]
|
||
fn scoped_server_hides_mutating_and_desktop_tools() {
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend::default()),
|
||
McpScope { connection_ids: vec!["scoped".to_string()], ..Default::default() },
|
||
false,
|
||
);
|
||
let names = server.tool_router.list_all().into_iter().map(|tool| tool.name).collect::<Vec<_>>();
|
||
#[cfg(feature = "mq-admin")]
|
||
assert_eq!(names.len(), 20);
|
||
#[cfg(not(feature = "mq-admin"))]
|
||
assert_eq!(names.len(), 18);
|
||
assert!(!names.iter().any(|name| name == "dbx_add_connection"));
|
||
assert!(!names.iter().any(|name| name == "dbx_duplicate_connection"));
|
||
assert!(!names.iter().any(|name| name == "dbx_remove_connection"));
|
||
assert!(!names.iter().any(|name| name == "dbx_open_table"));
|
||
assert!(!names.iter().any(|name| name == "dbx_execute_and_show"));
|
||
assert!(names.iter().any(|name| name == "dbx_execute_batch"));
|
||
assert!(names.iter().any(|name| name == "dbx_list_routines"));
|
||
assert!(names.iter().any(|name| name == "dbx_get_routine_source"));
|
||
assert!(names.iter().any(|name| name == "dbx_open_session"));
|
||
assert!(names.iter().any(|name| name == "dbx_close_session"));
|
||
assert!(names.iter().any(|name| name == "dbx_begin_transaction"));
|
||
assert!(names.iter().any(|name| name == "dbx_commit_transaction"));
|
||
assert!(names.iter().any(|name| name == "dbx_rollback_transaction"));
|
||
// The Salesforce tools act on the scoped connection itself, so connection
|
||
// scoping keeps them visible. What narrows them is the per-connection DML
|
||
// opt-in and the execution policy, both re-checked on every call.
|
||
assert!(names.iter().any(|name| name == "dbx_salesforce_current_user"));
|
||
assert!(names.iter().any(|name| name == "dbx_salesforce_prepare_write"));
|
||
assert!(names.iter().any(|name| name == "dbx_salesforce_apply_write"));
|
||
#[cfg(feature = "mq-admin")]
|
||
assert!(names.iter().any(|name| name == "dbx_send_message"));
|
||
}
|
||
|
||
#[test]
|
||
fn scoped_connection_ids_are_deduplicated_and_take_precedence_over_name() {
|
||
assert_eq!(scoped_connection_ids(Some(" first, second,first ,, ")), vec!["first", "second"]);
|
||
|
||
let first = connection("first", "other", "sqlite", ":memory:");
|
||
let named = ConnectionConfig { id: "named".to_string(), name: "scope-name".to_string(), ..first.clone() };
|
||
let scope = McpScope {
|
||
connection_ids: vec!["first".to_string()],
|
||
connection_name: Some("scope-name".to_string()),
|
||
database: None,
|
||
schema: None,
|
||
};
|
||
|
||
assert!(scope.matches(&first));
|
||
assert!(!scope.matches(&named));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn database_scope_is_a_hard_bound_without_filtering_connections() {
|
||
let scoped = connection("scoped", "scoped", "postgres", "configured");
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend { connections: vec![scoped.clone()], ..Default::default() }),
|
||
McpScope { database: Some("analytics".to_string()), ..Default::default() },
|
||
false,
|
||
);
|
||
|
||
assert_eq!(server.load_scoped_connections().await.unwrap().len(), 1);
|
||
let resolved = resolved_connection_for_test(scoped.clone());
|
||
assert_eq!(server.resolve_database(None, &resolved).unwrap(), "analytics");
|
||
assert_eq!(server.resolve_database(Some("analytics".to_string()), &resolved).unwrap(), "analytics");
|
||
let error = server.resolve_database(Some("production".to_string()), &resolved).unwrap_err();
|
||
assert!(result_text(&error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
|
||
let names = server.tool_router.list_all().into_iter().map(|tool| tool.name).collect::<Vec<_>>();
|
||
assert!(!names.iter().any(|name| name == "dbx_add_connection"));
|
||
assert!(!names.iter().any(|name| name == "dbx_execute_and_show"));
|
||
}
|
||
|
||
#[test]
|
||
fn configured_database_allowlist_is_enforced_for_sql_and_redis_targets() {
|
||
let sql = connection("sql", "sql", "mysql", "reporting");
|
||
let selected = ResolvedConnection {
|
||
connection: sql,
|
||
policy: McpGlobalPolicy::default(),
|
||
database_scope: DatabaseScope::Selected(vec!["reporting".to_string()]),
|
||
group_ids: Vec::new(),
|
||
};
|
||
let server = DbxMcpServer::with_runtime_options(Arc::new(FakeBackend::default()), McpScope::default(), false);
|
||
assert_eq!(server.resolve_database(Some("reporting".to_string()), &selected).unwrap(), "reporting");
|
||
let error = server.resolve_database(Some("production".to_string()), &selected).unwrap_err();
|
||
assert!(result_text(&error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
|
||
let redis = ResolvedConnection {
|
||
connection: connection("redis", "redis", "redis", "0"),
|
||
policy: McpGlobalPolicy::default(),
|
||
database_scope: DatabaseScope::Selected(vec!["2".to_string()]),
|
||
group_ids: Vec::new(),
|
||
};
|
||
assert_eq!(server.resolve_redis_database(Some(2), &redis).unwrap(), 2);
|
||
let error = server.resolve_redis_database(Some(3), &redis).unwrap_err();
|
||
assert!(result_text(&error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn redis_select_is_rejected_even_with_high_risk_access() {
|
||
let redis = connection("redis", "redis", "redis", "0");
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![redis],
|
||
policy: McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
},
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_redis_command(Parameters(ExecuteRedisCommandRequest {
|
||
selector: ConnectionSelector { connection_name: None, connection_id: Some("redis".to_string()) },
|
||
db: Some(8),
|
||
command: "SELECT 8".to_string(),
|
||
}))
|
||
.await;
|
||
|
||
assert_eq!(result.is_error, Some(true));
|
||
assert!(result_text(&result).contains("REDIS_DATABASE_SELECTION_REQUIRED"));
|
||
assert!(result_text(&result).contains("Set the db argument"));
|
||
}
|
||
|
||
#[test]
|
||
fn configured_database_allowlist_blocks_qualified_sql_references() {
|
||
let connection = connection("sql", "sql", "mysql", "reporting");
|
||
let scope = DatabaseScope::Selected(vec!["reporting".to_string()]);
|
||
|
||
assert!(ensure_sql_database_scope(&scope, &connection, "reporting", "SELECT * FROM reporting.users").is_ok());
|
||
let error =
|
||
ensure_sql_database_scope(&scope, &connection, "reporting", "SELECT * FROM production.users").unwrap_err();
|
||
assert!(result_text(&error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
}
|
||
|
||
#[test]
|
||
fn database_execution_policy_overrides_connection_and_global_defaults_and_blocks_cross_database_sql() {
|
||
let connection = connection("sql", "sql", "mysql", "operations");
|
||
let policy = McpGlobalPolicy {
|
||
connection_policies: vec![dbx_core::storage::McpConnectionPolicy {
|
||
connection_id: "sql".to_string(),
|
||
read_only: false,
|
||
allow_dangerous_sql: false,
|
||
execution_mode_configured: true,
|
||
execution_mode_policy_version: Some(dbx_core::mcp_policy::MCP_EXECUTION_POLICY_VERSION),
|
||
database_scope: McpDatabaseScope::Selected,
|
||
allowed_databases: vec!["operations".to_string(), "reporting".to_string()],
|
||
database_policies: vec![
|
||
dbx_core::storage::McpDatabasePolicy {
|
||
database_name: "operations".to_string(),
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
},
|
||
dbx_core::storage::McpDatabasePolicy {
|
||
database_name: "reporting".to_string(),
|
||
read_only: true,
|
||
allow_dangerous_sql: false,
|
||
},
|
||
],
|
||
allow_salesforce_dml: false,
|
||
}],
|
||
..Default::default()
|
||
};
|
||
|
||
let operations = effective_policy_for_database(&policy, &connection, "operations");
|
||
assert!(!operations.read_only);
|
||
assert!(operations.allow_dangerous_sql);
|
||
|
||
let reporting = effective_policy_for_database(&policy, &connection, "reporting");
|
||
assert!(reporting.read_only);
|
||
assert!(!reporting.allow_dangerous_sql);
|
||
|
||
let error = ensure_sql_database_execution_scope(
|
||
&policy,
|
||
&connection,
|
||
"operations",
|
||
"UPDATE reporting.jobs SET done = 1",
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&error).contains("DATABASE_EXECUTION_POLICY_OUT_OF_SCOPE"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn selected_database_scope_can_be_discovered_without_a_connection_default_database() {
|
||
let connection = connection("sql", "sql", "mysql", "");
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection],
|
||
policy: McpGlobalPolicy {
|
||
allowed_connection_ids: Some(vec!["sql".to_string()]),
|
||
connection_policies: vec![dbx_core::storage::McpConnectionPolicy {
|
||
connection_id: "sql".to_string(),
|
||
read_only: false,
|
||
allow_dangerous_sql: false,
|
||
database_scope: McpDatabaseScope::Selected,
|
||
allowed_databases: vec!["aa".to_string(), "aaa".to_string(), "abc".to_string()],
|
||
database_policies: Vec::new(),
|
||
execution_mode_configured: false,
|
||
execution_mode_policy_version: None,
|
||
allow_salesforce_dml: false,
|
||
}],
|
||
..Default::default()
|
||
},
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
let result = server.list_databases(Parameters(ListDatabasesRequest { selector: selector("sql") })).await;
|
||
assert_eq!(result_text(&result), "- aa\n- aaa\n- abc");
|
||
let show_databases = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sql"),
|
||
database: None,
|
||
sql: "SHOW DATABASES".to_string(),
|
||
session_id: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(result_text(&show_databases), "- aa\n- aaa\n- abc");
|
||
assert!(is_database_discovery_sql(" SHOW DATABASES; "));
|
||
assert!(is_database_discovery_sql("show schemas"));
|
||
assert!(!is_database_discovery_sql("show tables"));
|
||
}
|
||
|
||
#[test]
|
||
fn schema_scope_is_a_hard_bound() {
|
||
let dameng = connection("dameng-1", "Dameng", "dameng", "APPDB");
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend::default()),
|
||
McpScope {
|
||
database: Some("APPDB".to_string()),
|
||
schema: Some("REPORTING".to_string()),
|
||
..Default::default()
|
||
},
|
||
false,
|
||
);
|
||
|
||
let resolved = resolved_connection_for_test(dameng.clone());
|
||
assert_eq!(server.resolve_database(None, &resolved).unwrap(), "APPDB");
|
||
assert_eq!(server.resolve_schema(None).unwrap(), "REPORTING");
|
||
assert_eq!(server.resolve_schema(Some("REPORTING".to_string())).unwrap(), "REPORTING");
|
||
let error = server.resolve_schema(Some("APP_USER".to_string())).unwrap_err();
|
||
assert!(result_text(&error).contains("SCHEMA_OUT_OF_SCOPE"));
|
||
}
|
||
|
||
#[test]
|
||
fn redis_database_scope_fails_closed_and_cannot_be_overridden() {
|
||
let redis = connection("redis", "redis", "redis", "1");
|
||
let scoped = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend { connections: vec![redis.clone()], ..Default::default() }),
|
||
McpScope { database: Some("2".to_string()), ..Default::default() },
|
||
false,
|
||
);
|
||
let resolved = resolved_connection_for_test(redis.clone());
|
||
assert_eq!(scoped.resolve_redis_database(None, &resolved).unwrap(), 2);
|
||
let error = scoped.resolve_redis_database(Some(3), &resolved).unwrap_err();
|
||
assert!(result_text(&error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
|
||
let invalid = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend { connections: vec![redis.clone()], ..Default::default() }),
|
||
McpScope { database: Some("analytics".to_string()), ..Default::default() },
|
||
false,
|
||
);
|
||
let error = invalid.resolve_redis_database(None, &resolved).unwrap_err();
|
||
assert!(result_text(&error).contains("INVALID_DATABASE_SCOPE"));
|
||
}
|
||
|
||
#[test]
|
||
fn local_mongo_aggregate_cannot_write_to_a_production_database() {
|
||
let mut mongo = connection("mongo", "mongo", "mongodb", "staging");
|
||
mongo.production_databases = vec!["production".to_string()];
|
||
let policy = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
|
||
let error = validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::All,
|
||
"staging",
|
||
r#"db.items.aggregate([{"$out":{"db":"production","coll":"archive"}}])"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&error).contains("PRODUCTION_WRITE_BLOCKED"));
|
||
|
||
assert!(validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::All,
|
||
"staging",
|
||
r#"db.items.aggregate([{"$out":"archive"}])"#,
|
||
)
|
||
.is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn mongo_run_command_is_never_exposed_through_mcp() {
|
||
let mongo = connection("mongo", "mongo", "mongodb", "staging");
|
||
let source = r#"db.runCommand({ping: 1})"#;
|
||
|
||
for policy in [
|
||
McpGlobalPolicy {
|
||
read_only: true,
|
||
allow_dangerous_sql: false,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
},
|
||
McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: false,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
},
|
||
McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
},
|
||
] {
|
||
let error = validate_mongo_command(&mongo, &policy, &DatabaseScope::All, "staging", source).unwrap_err();
|
||
assert!(result_text(&error).contains("SQL_BLOCKED"));
|
||
assert!(result_text(&error).contains("runCommand"));
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn mongo_sibling_database_run_command_is_never_exposed_through_mcp() {
|
||
let mongo = connection("mongo", "mongo", "mongodb", "operations");
|
||
let policy = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
|
||
let error = validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::All,
|
||
"operations",
|
||
r#"db.getSiblingDB("staging").runCommand({ping: 1})"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&error).contains("SQL_BLOCKED"));
|
||
assert!(result_text(&error).contains("runCommand"));
|
||
}
|
||
|
||
#[test]
|
||
fn mongo_sibling_database_honors_target_scope_and_read_only_policy() {
|
||
let mongo = connection("mongo", "mongo", "mongodb", "operations");
|
||
let policy = McpGlobalPolicy {
|
||
connection_policies: vec![dbx_core::storage::McpConnectionPolicy {
|
||
connection_id: "mongo".to_string(),
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
execution_mode_configured: true,
|
||
execution_mode_policy_version: Some(dbx_core::mcp_policy::MCP_EXECUTION_POLICY_VERSION),
|
||
database_scope: McpDatabaseScope::Selected,
|
||
allowed_databases: vec!["operations".to_string(), "reporting".to_string()],
|
||
database_policies: vec![
|
||
dbx_core::storage::McpDatabasePolicy {
|
||
database_name: "operations".to_string(),
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
},
|
||
dbx_core::storage::McpDatabasePolicy {
|
||
database_name: "reporting".to_string(),
|
||
read_only: true,
|
||
allow_dangerous_sql: false,
|
||
},
|
||
],
|
||
allow_salesforce_dml: false,
|
||
}],
|
||
..Default::default()
|
||
};
|
||
|
||
let read_only_error = validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::Selected(vec!["operations".to_string(), "reporting".to_string()]),
|
||
"operations",
|
||
r#"db.getSiblingDB("reporting").users.deleteMany({_id: 1})"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&read_only_error).contains("MCP_READ_ONLY"));
|
||
|
||
let scope_error = validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::Selected(vec!["operations".to_string()]),
|
||
"operations",
|
||
r#"db.getSiblingDB("reporting").users.find({})"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&scope_error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
}
|
||
|
||
#[test]
|
||
fn mongo_sibling_database_aggregate_honors_output_scope_and_production_protection() {
|
||
let mut mongo = connection("mongo", "mongo", "mongodb", "operations");
|
||
mongo.production_databases = vec!["production".to_string()];
|
||
let policy = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
|
||
let production_error = validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::All,
|
||
"operations",
|
||
r#"db.getSiblingDB("staging").items.aggregate([{"$out":{"db":"production","coll":"archive"}}])"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&production_error).contains("PRODUCTION_WRITE_BLOCKED"));
|
||
|
||
let scope_error = validate_mongo_command(
|
||
&mongo,
|
||
&policy,
|
||
&DatabaseScope::Selected(vec!["operations".to_string(), "staging".to_string()]),
|
||
"operations",
|
||
r#"db.getSiblingDB("staging").items.aggregate([{"$merge":{"into":{"db":"archive","coll":"items"}}}])"#,
|
||
)
|
||
.unwrap_err();
|
||
assert!(result_text(&scope_error).contains("DATABASE_OUT_OF_SCOPE"));
|
||
}
|
||
|
||
#[test]
|
||
fn agent_results_preserve_stable_backend_policy_errors() {
|
||
let result = agent_result(dbx_core::agent_events::ToolResult {
|
||
tool_call_id: "test".to_string(),
|
||
tool_name: "execute_query".to_string(),
|
||
content: "Error: API request failed: MCP_READ_ONLY: policy changed".to_string(),
|
||
is_error: true,
|
||
explain_data: None,
|
||
});
|
||
assert!(result_text(&result).contains("Error [MCP_READ_ONLY]: policy changed"));
|
||
}
|
||
|
||
#[test]
|
||
fn mcp_confirmation_and_policy_guards_fail_closed() {
|
||
assert_eq!(
|
||
normalize_confirmed_write_sql(Some(" DELETE FROM sessions WHERE id = 7 ".to_string())),
|
||
Some("DELETE FROM sessions WHERE id = 7".to_string())
|
||
);
|
||
assert_eq!(normalize_confirmed_write_sql(Some(" \n ".to_string())), None);
|
||
|
||
let read_only = ConnectionConfig { read_only: true, ..connection("readonly", "readonly", "postgres", "app") };
|
||
let writable_policy = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
let read_only_error =
|
||
validate_sql_policy(&read_only, &writable_policy, "app", "DELETE FROM sessions", false).unwrap_err();
|
||
assert!(result_text(&read_only_error).contains("CONNECTION_READ_ONLY"));
|
||
|
||
let mut production = connection("production", "production", "postgres", "app");
|
||
production.production_databases = vec!["app".to_string()];
|
||
let production_error =
|
||
validate_sql_policy(&production, &writable_policy, "app", "DROP TABLE sessions", false).unwrap_err();
|
||
assert!(result_text(&production_error).contains("PRODUCTION_WRITE_BLOCKED"));
|
||
}
|
||
|
||
/// RAII guard that sets an env var and restores the original value (or
|
||
/// removes the var) on drop. Panic-safe — cleanup runs even when an
|
||
/// assertion fails.
|
||
struct EnvGuard {
|
||
key: &'static str,
|
||
original: Option<String>,
|
||
}
|
||
|
||
impl EnvGuard {
|
||
fn set(key: &'static str, value: &str) -> Self {
|
||
let original = std::env::var(key).ok();
|
||
std::env::set_var(key, value);
|
||
Self { key, original }
|
||
}
|
||
|
||
fn remove(key: &'static str) -> Self {
|
||
let original = std::env::var(key).ok();
|
||
std::env::remove_var(key);
|
||
Self { key, original }
|
||
}
|
||
}
|
||
|
||
impl Drop for EnvGuard {
|
||
fn drop(&mut self) {
|
||
match &self.original {
|
||
Some(original) => std::env::set_var(self.key, original),
|
||
None => std::env::remove_var(self.key),
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn confirmed_sql_binding_cannot_elevate_central_policy() {
|
||
let connection = connection("dev", "dev", "postgres", "app");
|
||
|
||
// An exact confirmation remains available as a narrowing constraint,
|
||
// but cannot turn the central safe-write policy into full access.
|
||
let _guard = EnvGuard::set("DBX_MCP_CONFIRMED_WRITE_SQL", "CREATE TABLE metrics (id INT)");
|
||
let safe_write = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: false,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
let permissions = mcp_permissions(&connection, &safe_write);
|
||
assert!(!permissions.allow_dangerous, "confirmed SQL must NOT elevate allow_dangerous for Redis/Mongo paths");
|
||
assert!(permissions.allow_writes);
|
||
assert_eq!(permissions.confirmed_write_sql.as_deref(), Some("CREATE TABLE metrics (id INT)"));
|
||
|
||
let error =
|
||
validate_sql_policy(&connection, &safe_write, "app", "CREATE TABLE metrics (id INT)", false).unwrap_err();
|
||
assert!(result_text(&error).contains("SQL_BLOCKED"));
|
||
assert!(result_text(&error).contains("High-risk SQL is disabled"));
|
||
drop(_guard);
|
||
|
||
// A missing binding cannot change the same safe-write boundary.
|
||
let _guard = EnvGuard::remove("DBX_MCP_CONFIRMED_WRITE_SQL");
|
||
let error = validate_sql_policy(&connection, &safe_write, "app", "DROP TABLE sessions", false).unwrap_err();
|
||
assert!(result_text(&error).contains("SQL_BLOCKED"));
|
||
assert!(result_text(&error).contains("High-risk SQL is disabled"));
|
||
drop(_guard);
|
||
|
||
// Full access still permits an exact confirmed DDL statement and keeps
|
||
// the binding for the execution-time anti-replay check.
|
||
let _guard = EnvGuard::set("DBX_MCP_CONFIRMED_WRITE_SQL", "CREATE TABLE metrics (id INT)");
|
||
let full_access = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: true,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
let permissions =
|
||
validate_sql_policy(&connection, &full_access, "app", "CREATE TABLE metrics (id INT)", false).unwrap();
|
||
assert!(permissions.allow_writes);
|
||
assert!(permissions.allow_dangerous);
|
||
assert_eq!(permissions.confirmed_write_sql.as_deref(), Some("CREATE TABLE metrics (id INT)"));
|
||
|
||
// A global read-only policy is still authoritative even for the exact
|
||
// confirmed statement, while read queries remain available.
|
||
let read_only_policy = McpGlobalPolicy {
|
||
read_only: true,
|
||
allow_dangerous_sql: false,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
let error = validate_sql_policy(&connection, &read_only_policy, "app", "CREATE TABLE metrics (id INT)", false)
|
||
.unwrap_err();
|
||
assert!(result_text(&error).contains("MCP_READ_ONLY"), "confirmed SQL must not bypass global read_only");
|
||
assert!(validate_sql_policy(&connection, &read_only_policy, "app", "SELECT 1", false).is_ok());
|
||
drop(_guard);
|
||
|
||
// Safe-write DML remains allowed, and an exact binding never grants the
|
||
// DDL/high-risk bit implicitly.
|
||
let _guard = EnvGuard::set("DBX_MCP_CONFIRMED_WRITE_SQL", "INSERT INTO metrics (id) VALUES (1)");
|
||
let permissions =
|
||
validate_sql_policy(&connection, &safe_write, "app", "INSERT INTO metrics (id) VALUES (1)", false).unwrap();
|
||
assert!(permissions.allow_writes);
|
||
assert!(!permissions.allow_dangerous);
|
||
assert_eq!(permissions.confirmed_write_sql.as_deref(), Some("INSERT INTO metrics (id) VALUES (1)"));
|
||
}
|
||
|
||
#[test]
|
||
fn use_statements_require_a_session() {
|
||
let starrocks = connection("sr", "sr", "starrocks", "default_catalog");
|
||
let policy = McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: false,
|
||
allowed_connection_ids: None,
|
||
..Default::default()
|
||
};
|
||
|
||
let blocked = validate_sql_policy(&starrocks, &policy, "default_catalog", "USE analytics", false).unwrap_err();
|
||
assert!(result_text(&blocked).contains("SQL_BLOCKED"));
|
||
assert!(result_text(&blocked).contains("dbx_open_session"));
|
||
|
||
// Inside a pinned session, USE is meaningful and passes policy checks.
|
||
assert!(validate_sql_policy(&starrocks, &policy, "default_catalog", "USE analytics", true).is_ok());
|
||
}
|
||
|
||
fn selector(id: &str) -> ConnectionSelector {
|
||
ConnectionSelector { connection_id: Some(id.to_string()), connection_name: None }
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn opted_in_session_exposes_transaction_tools_and_structured_state() {
|
||
let policy = McpGlobalPolicy { read_only: false, allow_dangerous_sql: true, ..Default::default() };
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
policy,
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
assert_eq!(backend.transaction_owners_opened.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||
assert_eq!(opened.structured_content.as_ref().unwrap()["transaction_state"], "idle");
|
||
|
||
let begun =
|
||
server.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(result_text(&begun).contains("transaction_state: active"));
|
||
assert_eq!(begun.structured_content.as_ref().unwrap()["transaction_state"], "active");
|
||
|
||
let queried = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
sql: "SELECT id FROM accounts WHERE id = 1 FOR UPDATE".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert!(queried.structured_content.is_some(), "{}", result_text(&queried));
|
||
assert_eq!(queried.structured_content.as_ref().unwrap()["transaction_state"], "active");
|
||
|
||
let committed =
|
||
server.commit_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
let structured = committed.structured_content.as_ref().unwrap();
|
||
assert!(result_text(&committed).contains("transaction_outcome: committed"));
|
||
assert_eq!(structured["transaction_state"], "idle");
|
||
assert_eq!(structured["transaction_outcome"], "committed");
|
||
|
||
let closed = server.close_session(Parameters(CloseSessionRequest { session_id })).await;
|
||
assert!(!closed.is_error.unwrap_or(false));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn legacy_session_open_text_is_unchanged_when_transactions_are_disabled() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
|
||
assert!(!result_text(&opened).contains("transactions:"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn transaction_opt_in_rejects_non_mysql_external_profiles_and_unsupported_backends() {
|
||
let postgres_backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("pg", "pg", "postgres", "app")],
|
||
..Default::default()
|
||
});
|
||
let postgres_server = DbxMcpServer::with_runtime_options(postgres_backend.clone(), McpScope::default(), false);
|
||
let rejected = postgres_server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("pg"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&rejected).contains("TRANSACTION_UNSUPPORTED"));
|
||
assert_eq!(postgres_backend.transaction_owners_opened.load(std::sync::atomic::Ordering::SeqCst), 0);
|
||
|
||
let mut builtin_mysql = connection("builtin", "builtin", "mysql", "app");
|
||
builtin_mysql.driver_profile = Some("mysql".to_string());
|
||
let builtin_backend = Arc::new(FakeBackend { connections: vec![builtin_mysql], ..Default::default() });
|
||
let builtin_server = DbxMcpServer::with_runtime_options(builtin_backend.clone(), McpScope::default(), false);
|
||
let opened = builtin_server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("builtin"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(!opened.is_error.unwrap_or(false));
|
||
assert_eq!(builtin_backend.transaction_owners_opened.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||
|
||
let mut external_mysql = connection("external", "external", "mysql", "app");
|
||
external_mysql.driver_profile = Some("custom-profile".to_string());
|
||
let external_backend = Arc::new(FakeBackend { connections: vec![external_mysql], ..Default::default() });
|
||
let external_server = DbxMcpServer::with_runtime_options(external_backend.clone(), McpScope::default(), false);
|
||
let rejected = external_server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("external"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&rejected).contains("TRANSACTION_UNSUPPORTED"));
|
||
assert_eq!(external_backend.transaction_owners_opened.load(std::sync::atomic::Ordering::SeqCst), 0);
|
||
|
||
let unsupported_backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
transaction_open_error: Some("TRANSACTION_UNSUPPORTED: backend has no native fixed session".to_string()),
|
||
..Default::default()
|
||
});
|
||
let unsupported_server = DbxMcpServer::with_runtime_options(unsupported_backend, McpScope::default(), false);
|
||
let rejected = unsupported_server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&rejected).contains("TRANSACTION_UNSUPPORTED"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn invalid_transaction_transitions_do_not_send_sql() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
|
||
let no_active_commit =
|
||
server.commit_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(result_text(&no_active_commit).contains("TRANSACTION_NOT_ACTIVE"));
|
||
server.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
let nested =
|
||
server.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(result_text(&nested).contains("TRANSACTION_ALREADY_ACTIVE"));
|
||
server.rollback_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
let no_active_rollback =
|
||
server.rollback_transaction(Parameters(TransactionSessionRequest { session_id })).await;
|
||
assert!(result_text(&no_active_rollback).contains("TRANSACTION_NOT_ACTIVE"));
|
||
assert_eq!(backend.transaction_owner_sql.lock().unwrap().as_slice(), ["START TRANSACTION", "ROLLBACK"]);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn queued_transaction_query_rechecks_revoked_policy_before_io() {
|
||
let policy = McpGlobalPolicy { allow_dangerous_sql: true, ..Default::default() };
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
policy: policy.clone(),
|
||
..Default::default()
|
||
});
|
||
let server = Arc::new(DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false));
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
server.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
|
||
let release_first = Arc::new(tokio::sync::Notify::new());
|
||
*backend.transaction_block_next_sql.lock().unwrap() = Some(release_first.clone());
|
||
let first = {
|
||
let server = server.clone();
|
||
let session_id = session_id.clone();
|
||
tokio::spawn(async move {
|
||
server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
sql: "SELECT id FROM accounts WHERE id = 1 FOR UPDATE".to_string(),
|
||
session_id: Some(session_id),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await
|
||
})
|
||
};
|
||
while backend.transaction_owner_sql.lock().unwrap().len() < 2 {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
let queued = {
|
||
let server = server.clone();
|
||
let session_id = session_id.clone();
|
||
tokio::spawn(async move {
|
||
server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
sql: "UPDATE accounts SET name = 'revoked' WHERE id = 1".to_string(),
|
||
session_id: Some(session_id),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await
|
||
})
|
||
};
|
||
tokio::task::yield_now().await;
|
||
let mut revoked = policy;
|
||
revoked.read_only = true;
|
||
*backend.policy_override.lock().unwrap() = Some(revoked);
|
||
release_first.notify_one();
|
||
assert!(!first.await.unwrap().is_error.unwrap_or(false));
|
||
|
||
let denied = queued.await.unwrap();
|
||
assert!(result_text(&denied).contains("MCP_READ_ONLY"));
|
||
assert_eq!(
|
||
backend.transaction_owner_sql.lock().unwrap().as_slice(),
|
||
["START TRANSACTION", "SELECT id FROM accounts WHERE id = 1 FOR UPDATE"]
|
||
);
|
||
|
||
let rolled_back =
|
||
server.rollback_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(!rolled_back.is_error.unwrap_or(false));
|
||
let closed = server.close_session(Parameters(CloseSessionRequest { session_id })).await;
|
||
assert!(!closed.is_error.unwrap_or(false));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn transaction_batch_keeps_one_lease_and_reports_each_resulting_state() {
|
||
let policy = McpGlobalPolicy { allow_dangerous_sql: true, ..Default::default() };
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
policy,
|
||
..Default::default()
|
||
});
|
||
let server = Arc::new(DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false));
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
server.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
|
||
let release_first = Arc::new(tokio::sync::Notify::new());
|
||
*backend.transaction_block_next_sql.lock().unwrap() = Some(release_first.clone());
|
||
let batch = {
|
||
let server = server.clone();
|
||
let session_id = session_id.clone();
|
||
tokio::spawn(async move {
|
||
server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("mysql"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "UPDATE accounts SET name = 'first' WHERE id = 1; SELECT id FROM accounts WHERE id = 1"
|
||
.to_string(),
|
||
session_id: Some(session_id),
|
||
continue_on_error: Some(true),
|
||
use_transaction: None,
|
||
}))
|
||
.await
|
||
})
|
||
};
|
||
while backend.transaction_owner_sql.lock().unwrap().len() < 2 {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
let queued_query = {
|
||
let server = server.clone();
|
||
let session_id = session_id.clone();
|
||
tokio::spawn(async move {
|
||
server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
sql: "SELECT id FROM accounts WHERE id = 2".to_string(),
|
||
session_id: Some(session_id),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await
|
||
})
|
||
};
|
||
release_first.notify_one();
|
||
let batch = batch.await.unwrap();
|
||
assert!(!batch.is_error.unwrap_or(false));
|
||
let structured = batch.structured_content.as_ref().unwrap();
|
||
assert_eq!(structured["transaction_state"], "active");
|
||
assert_eq!(structured["results"][0]["transaction_state"], "active");
|
||
assert_eq!(structured["results"][1]["transaction_state"], "active");
|
||
assert!(!queued_query.await.unwrap().is_error.unwrap_or(false));
|
||
assert_eq!(
|
||
backend.transaction_owner_sql.lock().unwrap().as_slice(),
|
||
[
|
||
"START TRANSACTION",
|
||
"UPDATE accounts SET name = 'first' WHERE id = 1",
|
||
"SELECT id FROM accounts WHERE id = 1",
|
||
"SELECT id FROM accounts WHERE id = 2",
|
||
]
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn dropping_protocol_server_rolls_back_its_active_transaction_sessions() {
|
||
let policy = McpGlobalPolicy { allow_dangerous_sql: true, ..Default::default() };
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
policy,
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
server.begin_transaction(Parameters(TransactionSessionRequest { session_id })).await;
|
||
|
||
drop(server);
|
||
|
||
tokio::time::timeout(std::time::Duration::from_millis(250), async {
|
||
loop {
|
||
if backend.transaction_owner_sql.lock().unwrap().as_slice() == ["START TRANSACTION", "ROLLBACK"] {
|
||
break;
|
||
}
|
||
tokio::task::yield_now().await;
|
||
}
|
||
})
|
||
.await
|
||
.expect("protocol session teardown must trigger bounded rollback");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn protocol_cancellation_drops_a_busy_transaction_tool_request() {
|
||
let policy = McpGlobalPolicy { allow_dangerous_sql: true, ..Default::default() };
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
policy,
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let (server_transport, client_transport) = tokio::io::duplex(64 * 1024);
|
||
let server_task = tokio::spawn(async move { server.serve(server_transport).await });
|
||
let mut client = ().serve(client_transport).await.unwrap();
|
||
let mut service = server_task.await.unwrap().unwrap();
|
||
let arguments = |value: serde_json::Value| value.as_object().cloned().unwrap();
|
||
|
||
let opened = client
|
||
.peer()
|
||
.call_tool(CallToolRequestParams::new("dbx_open_session").with_arguments(arguments(json!({
|
||
"connection_id": "mysql",
|
||
"database": "app",
|
||
"enable_transactions": true
|
||
}))))
|
||
.await
|
||
.unwrap();
|
||
let session_id = opened.structured_content.unwrap()["session_id"].as_str().unwrap().to_string();
|
||
client
|
||
.peer()
|
||
.call_tool(
|
||
CallToolRequestParams::new("dbx_begin_transaction")
|
||
.with_arguments(arguments(json!({"session_id": session_id}))),
|
||
)
|
||
.await
|
||
.unwrap();
|
||
|
||
*backend.transaction_block_next_sql.lock().unwrap() = Some(Arc::new(tokio::sync::Notify::new()));
|
||
let request = ClientRequest::CallToolRequest(CallToolRequest::new(
|
||
CallToolRequestParams::new("dbx_execute_query").with_arguments(arguments(json!({
|
||
"connection_id": "mysql",
|
||
"database": "app",
|
||
"session_id": session_id,
|
||
"sql": "SELECT id FROM accounts WHERE id = 1 FOR UPDATE"
|
||
}))),
|
||
));
|
||
let request = client.peer().send_cancellable_request(request, PeerRequestOptions::no_options()).await.unwrap();
|
||
while backend.transaction_owner_sql.lock().unwrap().len() < 2 {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
request.cancel(Some("test cancellation".to_string())).await.unwrap();
|
||
|
||
let follow_up = tokio::time::timeout(
|
||
std::time::Duration::from_millis(250),
|
||
client.peer().call_tool(CallToolRequestParams::new("dbx_execute_query").with_arguments(arguments(json!({
|
||
"connection_id": "mysql",
|
||
"database": "app",
|
||
"session_id": session_id,
|
||
"sql": "SELECT 2"
|
||
})))),
|
||
)
|
||
.await
|
||
.expect("protocol cancellation must release the transaction operation slot")
|
||
.unwrap();
|
||
assert_eq!(follow_up.is_error, Some(true));
|
||
|
||
let _ = client.close_with_timeout(std::time::Duration::from_millis(250)).await;
|
||
let _ = service.close_with_timeout(std::time::Duration::from_millis(250)).await;
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn session_queries_pin_client_session_and_close_releases_pool() {
|
||
let starrocks = connection("sr", "sr", "starrocks", "default_catalog");
|
||
let backend = Arc::new(FakeBackend { connections: vec![starrocks], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
|
||
// A USE statement is allowed inside the session and runs with the
|
||
// session's pinned client_session_id.
|
||
let result = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
sql: "USE analytics".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(result_text(&result), "ok");
|
||
let pinned_client_session = {
|
||
let recorded = backend.recorded_arguments.lock().unwrap();
|
||
let (_, arguments) = recorded.iter().find(|(name, _)| name == "execute_query").unwrap();
|
||
arguments["client_session_id"].as_str().unwrap().to_string()
|
||
};
|
||
assert_eq!(pinned_client_session, format!("mcp:{session_id}"));
|
||
|
||
// Queries bound to another database are rejected.
|
||
let mismatch = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sr"),
|
||
database: Some("other".to_string()),
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&mismatch).contains("SESSION_DATABASE_MISMATCH"));
|
||
|
||
let closed = server.close_session(Parameters(CloseSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(result_text(&closed).contains("closed"));
|
||
assert_eq!(backend.closed_sessions.lock().unwrap().as_slice(), [format!("mcp:{session_id}")]);
|
||
|
||
// The session is gone: further queries fail instead of silently
|
||
// falling back to an unpinned connection.
|
||
let missing = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&missing).contains("SESSION_NOT_FOUND"));
|
||
|
||
let second_close = server.close_session(Parameters(CloseSessionRequest { session_id })).await;
|
||
assert!(result_text(&second_close).contains("SESSION_NOT_FOUND"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_query_forwards_character_window_options() {
|
||
let elasticsearch = connection("es", "es", "elasticsearch", "");
|
||
let backend = Arc::new(FakeBackend { connections: vec![elasticsearch], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("es"),
|
||
database: None,
|
||
sql: "GET /logs/_search".to_string(),
|
||
session_id: None,
|
||
cell_char_offset: Some(200),
|
||
cell_char_limit: Some(800),
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
|
||
assert_eq!(result_text(&result), "ok");
|
||
let recorded = backend.recorded_arguments.lock().unwrap();
|
||
let (_, arguments) = recorded.iter().find(|(name, _)| name == "execute_query").unwrap();
|
||
assert_eq!(arguments["cell_char_offset"], 200);
|
||
assert_eq!(arguments["cell_char_limit"], 800);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_query_forwards_and_clamps_max_rows() {
|
||
let elasticsearch = connection("esm", "esm", "elasticsearch", "");
|
||
let backend = Arc::new(FakeBackend { connections: vec![elasticsearch], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
for max_rows in [None, Some(500), Some(100_000), Some(0)] {
|
||
let result = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("esm"),
|
||
database: None,
|
||
sql: "GET /logs/_search".to_string(),
|
||
session_id: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows,
|
||
}))
|
||
.await;
|
||
assert_eq!(result_text(&result), "ok");
|
||
}
|
||
|
||
let recorded = backend.recorded_arguments.lock().unwrap();
|
||
let limits = recorded
|
||
.iter()
|
||
.filter(|(name, _)| name == "execute_query")
|
||
.map(|(_, arguments)| arguments["limit"].as_u64().expect("limit should be published"))
|
||
.collect::<Vec<_>>();
|
||
// Omitted keeps the historical 100-row default; explicit values are clamped
|
||
// into 1..=MAX_EXECUTE_QUERY_ROWS rather than rejected.
|
||
assert_eq!(limits, vec![100, 500, MAX_EXECUTE_QUERY_ROWS as u64, 1]);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn expired_sessions_close_backend_pools_without_accumulating() {
|
||
let starrocks = connection("sr", "sr", "starrocks", "default_catalog");
|
||
let backend = Arc::new(FakeBackend { connections: vec![starrocks], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let mut expired_client_session_ids = Vec::new();
|
||
|
||
for _ in 0..3 {
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
let result = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(result_text(&result), "ok");
|
||
assert_eq!(backend.pinned_sessions.lock().unwrap().len(), 1);
|
||
|
||
server.sessions.expire_for_test(&session_id).await;
|
||
expired_client_session_ids.push(format!("mcp:{session_id}"));
|
||
}
|
||
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let final_session_id = opened_session_id(&opened);
|
||
assert!(backend.pinned_sessions.lock().unwrap().is_empty());
|
||
assert_eq!(backend.closed_sessions.lock().unwrap().as_slice(), expired_client_session_ids.as_slice());
|
||
|
||
let closed = server.close_session(Parameters(CloseSessionRequest { session_id: final_session_id })).await;
|
||
assert!(result_text(&closed).contains("closed"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn cancelled_eager_open_while_backend_acquisition_is_blocked_does_not_leak_capacity() {
|
||
let entered = Arc::new(tokio::sync::Notify::new());
|
||
let release = Arc::new(tokio::sync::Notify::new());
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
transaction_open_before: Some((entered.clone(), release.clone())),
|
||
..Default::default()
|
||
});
|
||
let server = Arc::new(DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false));
|
||
let opening = {
|
||
let server = server.clone();
|
||
tokio::spawn(async move {
|
||
server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await
|
||
})
|
||
};
|
||
entered.notified().await;
|
||
|
||
opening.abort();
|
||
assert!(opening.await.unwrap_err().is_cancelled());
|
||
release.notify_waiters();
|
||
|
||
tokio::time::timeout(Duration::from_millis(500), async {
|
||
while backend.closed_sessions.lock().unwrap().is_empty() {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
})
|
||
.await
|
||
.expect("cancelled provisional open must close its backend session");
|
||
assert_eq!(backend.transaction_owner_disconnects.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn cancelled_eager_open_after_owner_acquisition_disposes_owner_and_backend_session() {
|
||
let entered = Arc::new(tokio::sync::Notify::new());
|
||
let release = Arc::new(tokio::sync::Notify::new());
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
transaction_open_after_owner: Some((entered.clone(), release.clone())),
|
||
..Default::default()
|
||
});
|
||
let server = Arc::new(DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false));
|
||
let opening = {
|
||
let server = server.clone();
|
||
tokio::spawn(async move {
|
||
server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await
|
||
})
|
||
};
|
||
entered.notified().await;
|
||
|
||
opening.abort();
|
||
assert!(opening.await.unwrap_err().is_cancelled());
|
||
release.notify_waiters();
|
||
|
||
tokio::time::timeout(Duration::from_millis(500), async {
|
||
while backend.closed_sessions.lock().unwrap().is_empty() {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
})
|
||
.await
|
||
.expect("cancelled prepared open must close its backend session");
|
||
assert_eq!(backend.transaction_owner_disconnects.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn two_protocol_servers_share_physical_owner_budget_until_cleanup_finishes() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("mysql", "mysql", "mysql", "app")],
|
||
..Default::default()
|
||
});
|
||
let server_a = Arc::new(DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false));
|
||
let server_b = Arc::new(DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false));
|
||
let mut sessions_a = Vec::new();
|
||
for _ in 0..16 {
|
||
let opened = server_a
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(!opened.is_error.unwrap_or(false));
|
||
sessions_a.push(opened_session_id(&opened));
|
||
}
|
||
for _ in 0..16 {
|
||
let opened = server_b
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(!opened.is_error.unwrap_or(false));
|
||
}
|
||
|
||
let rejected = server_b
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&rejected).contains("max 32"));
|
||
|
||
let session_id = sessions_a.pop().unwrap();
|
||
let hidden_from_other_protocol =
|
||
server_b.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(result_text(&hidden_from_other_protocol).contains("SESSION_NOT_FOUND"));
|
||
server_a.begin_transaction(Parameters(TransactionSessionRequest { session_id: session_id.clone() })).await;
|
||
let rollback_release = Arc::new(tokio::sync::Notify::new());
|
||
*backend.transaction_block_next_sql.lock().unwrap() = Some(rollback_release.clone());
|
||
let closing = {
|
||
let server = server_a.clone();
|
||
let session_id = session_id.clone();
|
||
tokio::spawn(async move { server.close_session(Parameters(CloseSessionRequest { session_id })).await })
|
||
};
|
||
while !backend.transaction_owner_sql.lock().unwrap().iter().any(|sql| sql == "ROLLBACK") {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
closing.abort();
|
||
assert!(closing.await.unwrap_err().is_cancelled());
|
||
|
||
let still_rejected = server_b
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&still_rejected).contains("max 32"));
|
||
|
||
rollback_release.notify_one();
|
||
tokio::time::timeout(Duration::from_millis(500), async {
|
||
while backend.transaction_owner_budget.available_permits() == 0 {
|
||
tokio::task::yield_now().await;
|
||
}
|
||
})
|
||
.await
|
||
.expect("physical owner permit must return after disposal");
|
||
|
||
let opened = server_b
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("mysql"),
|
||
database: None,
|
||
enable_transactions: true,
|
||
}))
|
||
.await;
|
||
assert!(!opened.is_error.unwrap_or(false));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn failed_session_close_can_be_retried() {
|
||
let starrocks = connection("sr", "sr", "starrocks", "default_catalog");
|
||
let backend = Arc::new(FakeBackend { connections: vec![starrocks], ..Default::default() });
|
||
*backend.close_failures_remaining.lock().unwrap() = 1;
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
let query = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(result_text(&query), "ok");
|
||
|
||
let failed = server.close_session(Parameters(CloseSessionRequest { session_id: session_id.clone() })).await;
|
||
assert!(result_text(&failed).contains("SESSION_CLOSE_ERROR"));
|
||
assert_eq!(backend.pinned_sessions.lock().unwrap().len(), 1);
|
||
|
||
let retry_query = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sr"),
|
||
database: None,
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(result_text(&retry_query), "ok");
|
||
|
||
let closed = server.close_session(Parameters(CloseSessionRequest { session_id })).await;
|
||
assert!(result_text(&closed).contains("closed"));
|
||
assert!(backend.pinned_sessions.lock().unwrap().is_empty());
|
||
assert_eq!(backend.closed_sessions.lock().unwrap().len(), 1);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn open_session_rejects_non_sql_connections_and_unknown_sessions_fail_closed() {
|
||
let redis = connection("redis", "redis", "redis", "0");
|
||
let pg = connection("pg", "pg", "postgres", "app");
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend { connections: vec![redis, pg], ..Default::default() }),
|
||
McpScope::default(),
|
||
false,
|
||
);
|
||
let rejected = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("redis"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&rejected).contains("SESSION_UNSUPPORTED"));
|
||
|
||
let missing = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("pg"),
|
||
database: None,
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: Some("mcp-session-nope".to_string()),
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&missing).contains("SESSION_NOT_FOUND"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_forwards_options_and_surfaces_results() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: Some("app".to_string()),
|
||
sql: "SELECT 1; SELECT 2".to_string(),
|
||
session_id: None,
|
||
continue_on_error: Some(true),
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
|
||
// Auto-commit mode returns per-statement results; continue_on_error is
|
||
// forwarded to the core.
|
||
assert!(result_text(&result).contains("Statement 1"));
|
||
let ephemeral_session_id = {
|
||
let recorded = backend.recorded_arguments.lock().unwrap();
|
||
let (_, arguments) = recorded.iter().find(|(name, _)| name == "execute_batch").unwrap();
|
||
assert_eq!(arguments["continue_on_error"], true);
|
||
assert!(
|
||
arguments["use_transaction"].is_null(),
|
||
"use_transaction must be forwarded as null, got: {}",
|
||
arguments["use_transaction"]
|
||
);
|
||
arguments["client_session_id"]
|
||
.as_str()
|
||
.expect("auto-commit batch must use an ephemeral session")
|
||
.to_string()
|
||
};
|
||
assert!(ephemeral_session_id.starts_with("mcp-batch-"));
|
||
assert_eq!(backend.closed_sessions.lock().unwrap().as_slice(), [ephemeral_session_id]);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_pins_session_and_forwards_client_session_id() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("pg"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "SELECT 1; SELECT 2".to_string(),
|
||
session_id: Some(session_id.clone()),
|
||
continue_on_error: Some(false),
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("Statement 1"), "got: {}", result_text(&result));
|
||
let recorded = backend.recorded_arguments.lock().unwrap();
|
||
let (_, arguments) = recorded.iter().find(|(name, _)| name == "execute_batch").unwrap();
|
||
assert_eq!(arguments["client_session_id"], format!("mcp:{session_id}"));
|
||
assert!(backend.pinned_sessions.lock().unwrap().contains(&format!("mcp:{session_id}")));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_blocks_redis_and_mongo_connections() {
|
||
for (id, db_type) in [("redis", "redis"), ("mongo", "mongodb")] {
|
||
let backend =
|
||
Arc::new(FakeBackend { connections: vec![connection(id, id, db_type, "db")], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector(id),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "SELECT 1".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("DBX_BATCH_UNSUPPORTED"));
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_forwards_scoped_schema() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
backend.clone(),
|
||
McpScope { schema: Some("REPORTING".to_string()), ..Default::default() },
|
||
false,
|
||
);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "SELECT 1; SELECT 2".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("Statement 1"));
|
||
|
||
let recorded = backend.recorded_arguments.lock().unwrap();
|
||
let (_, arguments) = recorded.iter().find(|(name, _)| name == "execute_batch").unwrap();
|
||
assert_eq!(arguments["schema"], "REPORTING");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_rejects_empty_script() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let server = DbxMcpServer::with_runtime_options(
|
||
Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() }),
|
||
McpScope::default(),
|
||
false,
|
||
);
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: " ".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("SQL_BATCH_EMPTY"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn executed_mcp_query_is_saved_with_source_and_failure_status() {
|
||
let postgres = connection("pg", "Reporting", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let query = |sql: &str| ExecuteQueryRequest {
|
||
selector: selector("pg"),
|
||
database: None,
|
||
sql: sql.to_string(),
|
||
session_id: None,
|
||
max_rows: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
};
|
||
let success = server.execute_query(Parameters(query("SELECT 1"))).await;
|
||
let failure = server.execute_query(Parameters(query("SELECT 1 /* FAIL_MCP_TEST */"))).await;
|
||
assert_ne!(success.is_error, Some(true));
|
||
assert_eq!(failure.is_error, Some(true));
|
||
|
||
let history = backend.history.lock().unwrap();
|
||
assert_eq!(history.len(), 2);
|
||
assert_eq!(history[0].connection_id, "pg");
|
||
assert_eq!(history[0].connection_name, "Reporting");
|
||
assert_eq!(history[0].database, "app");
|
||
assert_eq!(history[0].sql, "SELECT 1");
|
||
assert!(history[0].success);
|
||
assert_eq!(history[0].details_json.as_deref(), Some(r#"{"source":"mcp"}"#));
|
||
assert!(!history[1].success);
|
||
assert!(history[1].error.as_deref().unwrap_or_default().contains("query failed"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn mcp_batch_failure_is_recorded_once_without_claiming_success() {
|
||
let postgres = connection("pg", "Reporting", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let sql = "SELECT 1 /* FAIL_MCP_TEST */; SELECT 2";
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: sql.to_string(),
|
||
session_id: None,
|
||
continue_on_error: Some(true),
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("failed"));
|
||
let history = backend.history.lock().unwrap();
|
||
assert_eq!(history.len(), 1);
|
||
assert_eq!(history[0].sql, sql);
|
||
assert!(!history[0].success);
|
||
assert!(history[0].error.as_deref().unwrap_or_default().contains("statement failed"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn mcp_batch_error_without_message_is_still_recorded_as_failed() {
|
||
let postgres = connection("pg", "Reporting", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "SELECT 1 /* FAIL_MCP_NO_MESSAGE_TEST */".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("failed"));
|
||
let history = backend.history.lock().unwrap();
|
||
assert_eq!(history.len(), 1);
|
||
assert!(!history[0].success);
|
||
assert_eq!(history[0].error.as_deref(), Some("Statement 1 failed"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn preflight_rejection_does_not_enter_execution_history() {
|
||
let postgres = connection("pg", "Reporting", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: " ".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
assert_eq!(result.is_error, Some(true));
|
||
assert!(backend.history.lock().unwrap().is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn mcp_history_metadata_handles_comments_and_mixed_batches() {
|
||
assert_eq!(mcp_sql_operation("-- context\nSELECT 1", DatabaseType::Postgres), "SELECT");
|
||
assert_eq!(
|
||
mcp_sql_activity_kind(
|
||
"UPDATE accounts SET active = true; CREATE INDEX active_idx ON accounts(active)",
|
||
DatabaseType::Postgres
|
||
),
|
||
"schema_change"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn mcp_history_metadata_reads_salesforce_statements_as_one_unit() {
|
||
let database_type = DatabaseType::Salesforce;
|
||
assert_eq!(mcp_sql_activity_kind("SELECT Id FROM Account", database_type), "query");
|
||
assert_eq!(mcp_sql_operation("SELECT Id FROM Account", database_type), "SELECT");
|
||
|
||
let update = "DBX SALESFORCE DML\n{\"op\":\"update\",\"object\":\"Account\",\"id\":\"001x\",\"fields\":{\"Name\":\"Acme\"}}";
|
||
assert_eq!(mcp_sql_activity_kind(update, database_type), "data_change");
|
||
assert_eq!(mcp_sql_operation(update, database_type), "UPDATE");
|
||
|
||
// An unscoped write fails closed to the high-risk tier, which the generic
|
||
// tier-based path would file under "schema_change". It is still a record
|
||
// mutation; only the driver's own parser can say which verb it was.
|
||
let unscoped = "DBX SALESFORCE DML\n{\"op\":\"delete\",\"object\":\"Account\"}";
|
||
assert_eq!(mcp_sql_activity_kind(unscoped, database_type), "data_change");
|
||
assert_eq!(mcp_sql_operation(unscoped, database_type), "DML");
|
||
|
||
// A field value that reads like another statement is data, not a second
|
||
// statement: the label must not change because of what it contains.
|
||
let literal =
|
||
"DBX SALESFORCE DML\n{\"op\":\"insert\",\"object\":\"Lead\",\"fields\":{\"Description\":\"a; CREATE TABLE t (id int)\"}}";
|
||
assert_eq!(mcp_sql_activity_kind(literal, database_type), "data_change");
|
||
assert_eq!(mcp_sql_operation(literal, database_type), "INSERT");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_rejects_transaction_with_session() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("pg"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "SELECT 1; SELECT 2".to_string(),
|
||
session_id: Some(session_id),
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("TRANSACTION_WITH_SESSION_UNSUPPORTED"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_rejects_transaction_with_continue_on_error() {
|
||
// The core transaction path rolls back and stops at the first failure
|
||
// (query.rs:2970), so continue_on_error would be silently ignored.
|
||
// Reject the combination instead of promising continuation that never
|
||
// happens, and make sure neither option reaches the backend.
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1); INSERT INTO t VALUES (2)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: Some(true),
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("TRANSACTION_WITH_CONTINUE_UNSUPPORTED"));
|
||
assert!(backend.recorded_arguments.lock().unwrap().iter().all(|(name, _)| name != "execute_batch"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_rejects_mysql_family_ddl_with_transaction() {
|
||
// MySQL-family engines implicitly commit before DDL, so a DDL batch
|
||
// with use_transaction cannot roll back a DDL that already committed.
|
||
// Reject the combination instead of over-promising atomicity. Plain
|
||
// DML batches and transactional DDL engines (PostgreSQL) still accept
|
||
// use_transaction.
|
||
let mysql = connection("my", "my", "mysql", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![mysql], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let ddl = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("my"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "CREATE TABLE a (id INT); INSERT INTO missing VALUES (1)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&ddl).contains("TRANSACTION_WITH_DDL_UNSUPPORTED"));
|
||
assert!(backend.recorded_arguments.lock().unwrap().iter().all(|(name, _)| name != "execute_batch"));
|
||
|
||
// GoldenDB is a MySQL-compatible Agent driver, so its DDL has the
|
||
// same implicit-commit boundary and must not be advertised as atomic.
|
||
let goldendb = connection("goldendb", "goldendb", "goldendb", "app");
|
||
let goldendb_backend = Arc::new(FakeBackend { connections: vec![goldendb], ..Default::default() });
|
||
let goldendb_server = DbxMcpServer::with_runtime_options(goldendb_backend.clone(), McpScope::default(), false);
|
||
let goldendb_ddl = goldendb_server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("goldendb"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "CREATE TABLE a (id INT); INSERT INTO missing VALUES (1)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&goldendb_ddl).contains("TRANSACTION_WITH_DDL_UNSUPPORTED"));
|
||
assert!(goldendb_backend.recorded_arguments.lock().unwrap().iter().all(|(name, _)| name != "execute_batch"));
|
||
|
||
let dml = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("my"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1); INSERT INTO t VALUES (2)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&dml).contains("Transaction outcome"));
|
||
assert!(backend.recorded_arguments.lock().unwrap().iter().any(|(name, _)| name == "execute_batch"));
|
||
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let postgres_backend = Arc::new(FakeBackend {
|
||
connections: vec![postgres],
|
||
policy: McpGlobalPolicy { read_only: false, allow_dangerous_sql: true, ..Default::default() },
|
||
..Default::default()
|
||
});
|
||
let postgres_server = DbxMcpServer::with_runtime_options(postgres_backend.clone(), McpScope::default(), false);
|
||
let pg_ddl = postgres_server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "CREATE TABLE a (id INT); INSERT INTO t VALUES (1)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&pg_ddl).contains("Transaction outcome"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_rejects_oracle_ddl_with_transaction() {
|
||
// Oracle DDL implicitly commits just like MySQL-family engines, so a DDL
|
||
// batch with use_transaction over-promises atomicity. The rejection must
|
||
// come from the shared capability check, not a MySQL-only engine list —
|
||
// otherwise Oracle would silently run a non-rollbackable "transaction".
|
||
let oracle = connection("ora", "ora", "oracle", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![oracle], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let ddl = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("ora"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "CREATE TABLE a (id NUMBER); INSERT INTO missing VALUES (1)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&ddl).contains("TRANSACTION_WITH_DDL_UNSUPPORTED"));
|
||
assert!(backend.recorded_arguments.lock().unwrap().iter().all(|(name, _)| name != "execute_batch"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_single_statement_allows_transaction_option_combinations() {
|
||
// A single-statement script ignores use_transaction and runs as normal
|
||
// auto-commit, so it never enters transaction mode. Combining it with
|
||
// session_id or continue_on_error is therefore harmless and must not be
|
||
// rejected — the option-validity rejects apply only when the script
|
||
// actually enters transaction mode (statement_count > 1). Contrast with
|
||
// execute_batch_rejects_transaction_with_session / _continue_on_error,
|
||
// which use multi-statement scripts and are still rejected.
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
|
||
let with_continue = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: Some(true),
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(
|
||
!result_text(&with_continue).contains("TRANSACTION_WITH_CONTINUE_UNSUPPORTED"),
|
||
"single-statement use_transaction + continue_on_error must not be rejected"
|
||
);
|
||
assert!(backend.recorded_arguments.lock().unwrap().iter().any(|(name, _)| name == "execute_batch"));
|
||
|
||
// A real session bound to the same connection must likewise reach
|
||
// execution rather than be rejected as a transaction/session conflict.
|
||
let opened = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("pg"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
let session_id = opened_session_id(&opened);
|
||
let with_session = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1)".to_string(),
|
||
session_id: Some(session_id),
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(
|
||
!result_text(&with_session).contains("TRANSACTION_WITH_SESSION_UNSUPPORTED"),
|
||
"single-statement use_transaction + session_id must not be rejected as a transaction/session conflict"
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_returns_structured_content() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "SELECT 1; SELECT 2".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
}))
|
||
.await;
|
||
// The human-readable block stays in content…
|
||
assert!(result_text(&result).contains("Statement 1"));
|
||
// …and structuredContent is a protocol-valid object carrying one result per statement.
|
||
let structured = result.structured_content.as_ref().expect("structured content must be populated");
|
||
assert!(structured.is_object(), "MCP structuredContent must be a JSON object");
|
||
let results = structured["results"].as_array().expect("results must be an array");
|
||
assert_eq!(results.len(), 1);
|
||
assert_eq!(results[0]["statement_index"], 0);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_enforces_confirmed_write_sql_binding() {
|
||
// `confirmed_batch_sql_block_reason` is exercised directly (not through
|
||
// the handler with DBX_MCP_CONFIRMED_WRITE_SQL) because the env var is
|
||
// process-global and would race with `confirmed_sql_binding_cannot_elevate_central_policy`.
|
||
let postgres_db_type = dbx_core::models::connection::DatabaseType::Postgres;
|
||
let confirmed = Some("INSERT INTO t VALUES (1)");
|
||
|
||
// An exact match (modulo surrounding whitespace) passes.
|
||
assert!(confirmed_batch_sql_block_reason(" INSERT INTO t VALUES (1) ", postgres_db_type, confirmed).is_none());
|
||
// A differing write script fails closed.
|
||
let blocked = confirmed_batch_sql_block_reason(
|
||
"INSERT INTO t VALUES (1); INSERT INTO u VALUES (2)",
|
||
postgres_db_type,
|
||
confirmed,
|
||
)
|
||
.expect("differing write script must be blocked");
|
||
assert!(blocked.contains("does not match the user-confirmed SQL"));
|
||
// A read-only script is never subject to the write confirmation.
|
||
assert!(confirmed_batch_sql_block_reason("SELECT 1; SELECT 2", postgres_db_type, confirmed).is_none());
|
||
// No binding never blocks.
|
||
assert!(confirmed_batch_sql_block_reason("INSERT INTO t VALUES (1)", postgres_db_type, None).is_none());
|
||
// Unparseable SQL fails closed (treated as a write).
|
||
assert!(confirmed_batch_sql_block_reason("NOT VALID SQL ;;;", postgres_db_type, confirmed).is_some());
|
||
}
|
||
|
||
#[test]
|
||
fn execute_query_routes_scripts_to_the_dialect_aware_batch_path() {
|
||
assert!(sql_requires_batch_execution("SELECT 1; SELECT 2", DatabaseType::Postgres));
|
||
assert!(sql_requires_batch_execution(
|
||
"DELIMITER $$\nCREATE PROCEDURE p() BEGIN SELECT 1; END$$\nDELIMITER ;",
|
||
DatabaseType::Mysql
|
||
));
|
||
assert!(!sql_requires_batch_execution("SELECT 1;", DatabaseType::Mysql));
|
||
assert!(!sql_requires_batch_execution("SELECT 1", DatabaseType::Mysql));
|
||
}
|
||
|
||
#[test]
|
||
fn solr_rest_requests_stay_on_the_single_request_path() {
|
||
// Solr speaks the DBX REST-console format (`METHOD /path` + optional
|
||
// JSON body), not SQL. A single request must not be routed through the
|
||
// `;`-splitting batch executor.
|
||
assert!(!sql_requires_batch_execution("GET /mycore/select?q=*:*&rows=20", DatabaseType::Solr));
|
||
assert!(!sql_requires_batch_execution(
|
||
"POST /mycore/update\n{\"add\":{\"doc\":{\"id\":\"1\",\"title\":\"x\"}}}",
|
||
DatabaseType::Solr
|
||
));
|
||
// A REST request is never a forbidden database switch.
|
||
assert!(!mcp_sql_has_forbidden_database_switch("GET /mycore/select?q=*:*", DatabaseType::Solr));
|
||
}
|
||
|
||
#[test]
|
||
fn format_batch_results_renders_failed_statement() {
|
||
let results = vec![crate::backend::BatchStatementResult {
|
||
result: dbx_core::db::QueryResult {
|
||
columns: vec![],
|
||
column_types: vec![],
|
||
column_sortables: vec![],
|
||
spatial_columns: vec![],
|
||
spatial_values: vec![],
|
||
rows: vec![],
|
||
affected_rows: 0,
|
||
execution_time_ms: 0,
|
||
server_execute_time_us: None,
|
||
query_timings_ms: None,
|
||
truncated: false,
|
||
session_id: None,
|
||
has_more: false,
|
||
elasticsearch_raw_body: None,
|
||
messages: vec![],
|
||
},
|
||
execution_error: true,
|
||
statement_index: Some(2),
|
||
error_message: Some("syntax error near SELECT".to_string()),
|
||
merged: false,
|
||
transaction_state: None,
|
||
transaction_outcome: None,
|
||
}];
|
||
let output = format_batch_results(&results, QueryCellWindow::default());
|
||
assert!(output.contains("### Statement 3"));
|
||
assert!(output.contains("**Status:** failed"));
|
||
assert!(output.contains("syntax error near SELECT"));
|
||
}
|
||
|
||
#[test]
|
||
fn format_batch_results_renders_transaction_outcome() {
|
||
let results = vec![crate::backend::BatchStatementResult {
|
||
result: dbx_core::db::QueryResult {
|
||
columns: vec![],
|
||
column_types: vec![],
|
||
column_sortables: vec![],
|
||
spatial_columns: vec![],
|
||
spatial_values: vec![],
|
||
rows: vec![],
|
||
affected_rows: 2,
|
||
execution_time_ms: 0,
|
||
server_execute_time_us: None,
|
||
query_timings_ms: None,
|
||
truncated: false,
|
||
session_id: None,
|
||
has_more: false,
|
||
elasticsearch_raw_body: None,
|
||
messages: vec![],
|
||
},
|
||
execution_error: false,
|
||
statement_index: None,
|
||
error_message: None,
|
||
merged: true,
|
||
transaction_state: None,
|
||
transaction_outcome: None,
|
||
}];
|
||
let output = format_batch_results(&results, QueryCellWindow::default());
|
||
assert!(output.contains("### Transaction outcome"));
|
||
assert!(output.contains("2 row(s) affected"));
|
||
assert!(!output.contains("Statement 1"));
|
||
}
|
||
|
||
#[test]
|
||
fn format_batch_results_honors_requested_cell_window() {
|
||
let long_value = "A".repeat(500);
|
||
let batch_result = |value: String| crate::backend::BatchStatementResult {
|
||
result: dbx_core::db::QueryResult {
|
||
columns: vec!["body".to_string()],
|
||
column_types: vec![],
|
||
column_sortables: vec![],
|
||
spatial_columns: vec![],
|
||
spatial_values: vec![],
|
||
rows: vec![vec![serde_json::Value::String(value)]],
|
||
affected_rows: 1,
|
||
execution_time_ms: 0,
|
||
server_execute_time_us: None,
|
||
query_timings_ms: None,
|
||
truncated: false,
|
||
session_id: None,
|
||
has_more: false,
|
||
elasticsearch_raw_body: None,
|
||
messages: vec![],
|
||
},
|
||
execution_error: false,
|
||
statement_index: Some(0),
|
||
error_message: None,
|
||
merged: false,
|
||
transaction_state: None,
|
||
transaction_outcome: None,
|
||
};
|
||
|
||
let capped = format_batch_results(&[batch_result(long_value.clone())], QueryCellWindow::default());
|
||
assert!(capped.contains(&format!("{}... [chars 0..200; next cell_char_offset=200]", "A".repeat(200))));
|
||
|
||
let expanded = format_batch_results(
|
||
&[batch_result(long_value.clone())],
|
||
QueryCellWindow::from_options(Some(0), Some(4000)),
|
||
);
|
||
assert!(expanded.contains(&long_value), "batch cells should honor cell_char_limit: {expanded}");
|
||
assert!(!expanded.contains("next cell_char_offset"), "a 500-character cell fits in the 4000-character window");
|
||
}
|
||
|
||
#[test]
|
||
fn batch_request_deserializes_the_cell_window_arguments() {
|
||
let request: ExecuteBatchQueryRequest = serde_json::from_value(serde_json::json!({
|
||
"connection_name": "mysql",
|
||
"sql": "SELECT body FROM t",
|
||
"cell_char_offset": 0,
|
||
"cell_char_limit": 4000,
|
||
}))
|
||
.expect("batch request should accept the cell window arguments");
|
||
assert_eq!(request.cell_window.cell_char_offset, Some(0));
|
||
assert_eq!(request.cell_window.cell_char_limit, Some(4000));
|
||
assert_eq!(request.cell_window.to_query_window(), QueryCellWindow::from_options(Some(0), Some(4000)));
|
||
|
||
let without_window: ExecuteBatchQueryRequest =
|
||
serde_json::from_value(serde_json::json!({ "connection_name": "mysql", "sql": "SELECT body FROM t" }))
|
||
.expect("batch request should keep the cell window optional");
|
||
assert_eq!(without_window.cell_window.to_query_window(), QueryCellWindow::default());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_transaction_mode_marks_merged_outcome() {
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1); INSERT INTO t VALUES (2)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
// The merged transaction outcome is labelled distinctly and does not
|
||
// pretend to be per-statement.
|
||
assert!(result_text(&result).contains("Transaction outcome"));
|
||
assert!(!result_text(&result).contains("Statement 1"));
|
||
let structured = result.structured_content.as_ref().expect("structured content must be populated");
|
||
assert_eq!(structured["results"][0]["merged"], true);
|
||
assert!(structured["results"][0]["statement_index"].is_null());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_single_statement_with_transaction_is_not_merged() {
|
||
// The core transaction wrapper only applies to scripts with more than
|
||
// one statement (query.rs:2970). A single statement with
|
||
// use_transaction=true runs as a normal auto-commit statement and must
|
||
// not be labelled as a transaction outcome.
|
||
let postgres = connection("pg", "pg", "postgres", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![postgres], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("pg"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("Statement 1"));
|
||
assert!(!result_text(&result).contains("Transaction outcome"));
|
||
let structured = result.structured_content.as_ref().expect("structured content must be populated");
|
||
// merged=false is skipped by serde, so the single statement must not
|
||
// carry a merged marker (null/absent), unlike the transaction outcome.
|
||
assert!(structured["results"][0]["merged"].is_null());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn execute_batch_sqlserver_use_transaction_marks_merged_outcome() {
|
||
// SQL Server enters the core transaction path before its normal batch
|
||
// fast path, so a successful multi-statement request is merged.
|
||
let sqlserver = connection("mssql", "mssql", "sqlserver", "app");
|
||
let backend = Arc::new(FakeBackend { connections: vec![sqlserver], ..Default::default() });
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
|
||
let result = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("mssql"),
|
||
cell_window: CellWindowArgs::default(),
|
||
database: None,
|
||
sql: "INSERT INTO t VALUES (1); INSERT INTO t VALUES (2)".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: Some(true),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&result).contains("Transaction outcome"));
|
||
assert!(!result_text(&result).contains("Statement 1"));
|
||
let structured = result.structured_content.as_ref().expect("structured content must be populated");
|
||
assert_eq!(structured["results"][0]["merged"], true);
|
||
}
|
||
|
||
fn salesforce_connection() -> ConnectionConfig {
|
||
connection("sfdc", "Acme QA org", "salesforce", "")
|
||
}
|
||
|
||
fn salesforce_dml_policy(allow_dml: bool, read_only: bool) -> McpGlobalPolicy {
|
||
McpGlobalPolicy {
|
||
read_only: false,
|
||
allow_dangerous_sql: false,
|
||
connection_policies: vec![dbx_core::storage::McpConnectionPolicy {
|
||
connection_id: "sfdc".to_string(),
|
||
read_only,
|
||
allow_dangerous_sql: false,
|
||
execution_mode_configured: false,
|
||
execution_mode_policy_version: None,
|
||
database_scope: McpDatabaseScope::All,
|
||
allowed_databases: Vec::new(),
|
||
database_policies: Vec::new(),
|
||
allow_salesforce_dml: allow_dml,
|
||
}],
|
||
..Default::default()
|
||
}
|
||
}
|
||
|
||
fn salesforce_identity(is_admin: Option<bool>) -> SalesforceCurrentUser {
|
||
SalesforceCurrentUser {
|
||
user_id: "005000000000000001".to_string(),
|
||
name: "Jane Doe".to_string(),
|
||
email: "jane.doe@example.test".to_string(),
|
||
organization_id: "00D000000000000001".to_string(),
|
||
username: "jane.doe@example.test".to_string(),
|
||
profile_name: Some("System Administrator".to_string()),
|
||
is_admin,
|
||
org_name: "Acme".to_string(),
|
||
}
|
||
}
|
||
|
||
fn salesforce_server(policy: McpGlobalPolicy, identity: Option<SalesforceCurrentUser>) -> Arc<FakeBackend> {
|
||
Arc::new(FakeBackend {
|
||
connections: vec![salesforce_connection()],
|
||
policy,
|
||
salesforce_identity: identity,
|
||
..Default::default()
|
||
})
|
||
}
|
||
|
||
fn prepare_request(
|
||
op: &str,
|
||
object: &str,
|
||
id: Option<&str>,
|
||
fields: Option<serde_json::Value>,
|
||
) -> Parameters<SalesforcePrepareWriteRequest> {
|
||
Parameters(SalesforcePrepareWriteRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
op: op.to_string(),
|
||
object: object.to_string(),
|
||
id: id.map(str::to_string),
|
||
fields,
|
||
})
|
||
}
|
||
|
||
fn confirm_token(result: &CallToolResult) -> String {
|
||
result.structured_content.as_ref().expect("prepare returns structured content")["confirm_token"]
|
||
.as_str()
|
||
.expect("confirm_token")
|
||
.to_string()
|
||
}
|
||
|
||
#[test]
|
||
fn salesforce_dml_builder_accepts_only_single_scoped_records() {
|
||
let update =
|
||
build_salesforce_dml_statement("UPDATE", " Account ", Some(" 001x "), Some(&json!({"Name": "Acme"})))
|
||
.expect("a scoped update is the shape the driver executes");
|
||
assert!(update.starts_with("DBX SALESFORCE DML\n"), "missing pseudo-command header: {update}");
|
||
assert_eq!(
|
||
classify_salesforce_statement_risk(&update),
|
||
SalesforceStatementRisk::ScopedWrite,
|
||
"a prepared write must never land in the read tier"
|
||
);
|
||
let parsed = parse_salesforce_statement(&update).expect("the driver must accept what prepare handed out");
|
||
assert_eq!(parsed.op.as_str(), "update");
|
||
assert_eq!(parsed.object, "Account");
|
||
assert_eq!(parsed.id.as_deref(), Some("001x"));
|
||
assert_eq!(parsed.fields.expect("fields")["Name"], json!("Acme"));
|
||
assert_eq!(salesforce_write_label(&update), "update on Account (Id 001x)");
|
||
|
||
let insert = build_salesforce_dml_statement("insert", "Lead", None, Some(&json!({"Company": "Acme"}))).unwrap();
|
||
assert_eq!(salesforce_write_label(&insert), "insert on Lead");
|
||
let delete = build_salesforce_dml_statement("delete", "Lead", Some("00Qx"), None).unwrap();
|
||
assert_eq!(salesforce_write_label(&delete), "delete on Lead (Id 00Qx)");
|
||
|
||
let rejected: Vec<(&str, Result<String, String>)> = vec![
|
||
("no object", build_salesforce_dml_statement("update", " ", Some("001x"), Some(&json!({"Name": "a"})))),
|
||
("no fields on insert", build_salesforce_dml_statement("insert", "Lead", None, None)),
|
||
("empty fields", build_salesforce_dml_statement("insert", "Lead", None, Some(&json!({})))),
|
||
("fields not an object", build_salesforce_dml_statement("insert", "Lead", None, Some(&json!(["Name"])))),
|
||
(
|
||
"id on insert",
|
||
build_salesforce_dml_statement("insert", "Lead", Some("00Qx"), Some(&json!({"Company": "a"}))),
|
||
),
|
||
("no id on update", build_salesforce_dml_statement("update", "Lead", None, Some(&json!({"Company": "a"})))),
|
||
("no id on delete", build_salesforce_dml_statement("delete", "Lead", None, None)),
|
||
(
|
||
"fields on delete",
|
||
build_salesforce_dml_statement("delete", "Lead", Some("00Qx"), Some(&json!({"Company": "a"}))),
|
||
),
|
||
(
|
||
"Id inside fields",
|
||
build_salesforce_dml_statement("update", "Lead", Some("00Qx"), Some(&json!({"id": "00Qy"}))),
|
||
),
|
||
(
|
||
"empty field name",
|
||
build_salesforce_dml_statement("update", "Lead", Some("00Qx"), Some(&json!({" ": "x"}))),
|
||
),
|
||
("upsert", build_salesforce_dml_statement("upsert", "Lead", Some("00Qx"), Some(&json!({"Company": "a"})))),
|
||
("raw sql", build_salesforce_dml_statement("DELETE FROM Lead", "Lead", None, None)),
|
||
];
|
||
for (label, result) in rejected {
|
||
assert!(result.is_err(), "{label} must be refused, got {:?}", result.ok());
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn pending_salesforce_writes_are_single_use_and_expire() {
|
||
let statement =
|
||
build_salesforce_dml_statement("update", "Account", Some("001x"), Some(&json!({"Name": "Acme"}))).unwrap();
|
||
let pending = || PendingSalesforceWrite {
|
||
connection_id: "sfdc".to_string(),
|
||
database: String::new(),
|
||
statement: statement.clone(),
|
||
created_at: Instant::now(),
|
||
};
|
||
|
||
let live = PendingSalesforceWrites::new(SALESFORCE_WRITE_CONFIRM_TTL);
|
||
live.insert("sfdml-a".to_string(), pending()).await;
|
||
assert!(live.take("sfdml-a").await.is_some(), "a fresh token must apply");
|
||
assert!(live.take("sfdml-a").await.is_none(), "a token is single-use: a replay must not execute twice");
|
||
assert!(live.take(" sfdml-missing ").await.is_none());
|
||
|
||
let expired = PendingSalesforceWrites::new(Duration::ZERO);
|
||
expired.insert("sfdml-b".to_string(), pending()).await;
|
||
assert!(expired.take("sfdml-b").await.is_none(), "an expired token must not execute");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn pending_salesforce_writes_stay_bounded() {
|
||
let store = PendingSalesforceWrites::new(SALESFORCE_WRITE_CONFIRM_TTL);
|
||
for index in 0..(SALESFORCE_WRITE_PENDING_LIMIT + 10) {
|
||
store
|
||
.insert(
|
||
format!("sfdml-{index}"),
|
||
PendingSalesforceWrite {
|
||
connection_id: "sfdc".to_string(),
|
||
database: String::new(),
|
||
statement: "DBX SALESFORCE DML\n{}".to_string(),
|
||
created_at: Instant::now(),
|
||
},
|
||
)
|
||
.await;
|
||
}
|
||
assert_eq!(store.entries.lock().await.len(), SALESFORCE_WRITE_PENDING_LIMIT);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_prepare_write_needs_an_explicit_connection_opt_in() {
|
||
for (label, policy) in [
|
||
("no connection rule", McpGlobalPolicy::default()),
|
||
("opt-in off", salesforce_dml_policy(false, false)),
|
||
("opt-in void on read-only", salesforce_dml_policy(true, true)),
|
||
] {
|
||
let backend = salesforce_server(policy, None);
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let prepared = server
|
||
.salesforce_prepare_write(prepare_request(
|
||
"update",
|
||
"Account",
|
||
Some("001x"),
|
||
Some(json!({"Name": "Acme"})),
|
||
))
|
||
.await;
|
||
assert!(result_text(&prepared).contains("SALESFORCE_DML_DISABLED"), "{label}: {prepared:?}");
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty(), "{label} must not reach the org");
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_prepare_write_summarises_the_write_and_the_identity() {
|
||
let backend = salesforce_server(salesforce_dml_policy(true, false), Some(salesforce_identity(Some(true))));
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let prepared = server
|
||
.salesforce_prepare_write(prepare_request(
|
||
"update",
|
||
"Account",
|
||
Some("001x"),
|
||
Some(json!({"Name": "Acme", "AnnualRevenue": 1200})),
|
||
))
|
||
.await;
|
||
let summary = result_text(&prepared);
|
||
assert_ne!(prepared.is_error, Some(true), "{prepared:?}");
|
||
for expected in [
|
||
"nothing has been sent yet",
|
||
"Operation: update",
|
||
"Object: Account",
|
||
"Record Id: 001x",
|
||
"Name = \"Acme\"",
|
||
"AnnualRevenue = 1200",
|
||
"Jane Doe",
|
||
"\"System Administrator\"",
|
||
"Modify All Data",
|
||
"cannot be rolled back",
|
||
"dbx_salesforce_apply_write",
|
||
] {
|
||
assert!(summary.contains(expected), "summary is missing \"{expected}\":\n{summary}");
|
||
}
|
||
assert!(confirm_token(&prepared).starts_with("sfdml-"));
|
||
assert_eq!(
|
||
prepared.structured_content.as_ref().unwrap()["statement"].as_str().unwrap(),
|
||
build_salesforce_dml_statement(
|
||
"update",
|
||
"Account",
|
||
Some("001x"),
|
||
Some(&json!({"Name": "Acme", "AnnualRevenue": 1200}))
|
||
)
|
||
.unwrap()
|
||
);
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty(), "prepare must not write");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_prepare_write_survives_a_failed_identity_lookup() {
|
||
let backend = salesforce_server(salesforce_dml_policy(true, false), None);
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
let prepared = server.salesforce_prepare_write(prepare_request("delete", "Lead", Some("00Qx"), None)).await;
|
||
assert_ne!(prepared.is_error, Some(true), "{prepared:?}");
|
||
assert!(result_text(&prepared).contains("identity lookup failed"), "{}", result_text(&prepared));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_apply_write_sends_the_prepared_statement_exactly_once() {
|
||
let backend = salesforce_server(salesforce_dml_policy(true, false), Some(salesforce_identity(Some(false))));
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let prepared = server
|
||
.salesforce_prepare_write(prepare_request("update", "Account", Some("001x"), Some(json!({"Name": "Acme"}))))
|
||
.await;
|
||
let token = confirm_token(&prepared);
|
||
let statement = prepared.structured_content.as_ref().unwrap()["statement"].as_str().unwrap().to_string();
|
||
|
||
let applied = server
|
||
.salesforce_apply_write(Parameters(SalesforceApplyWriteRequest { confirm_token: token.clone() }))
|
||
.await;
|
||
assert_ne!(applied.is_error, Some(true), "{applied:?}");
|
||
assert!(
|
||
result_text(&applied).starts_with("Salesforce write applied: update on Account (Id 001x)."),
|
||
"{}",
|
||
result_text(&applied)
|
||
);
|
||
|
||
let recorded = backend.recorded_arguments.lock().unwrap().clone();
|
||
assert_eq!(recorded.len(), 1, "exactly one write reached the backend: {recorded:?}");
|
||
assert_eq!(recorded[0].0, "execute_query");
|
||
assert_eq!(
|
||
recorded[0].1["sql"].as_str(),
|
||
Some(statement.as_str()),
|
||
"the applied statement must be the prepared one"
|
||
);
|
||
assert_eq!(recorded[0].1["limit"], json!(1));
|
||
|
||
let history = backend.history.lock().unwrap().clone();
|
||
assert_eq!(history.len(), 1);
|
||
assert_eq!(history[0].sql, statement);
|
||
assert_eq!(history[0].operation, "UPDATE");
|
||
assert_eq!(history[0].activity_kind, "data_change");
|
||
assert!(history[0].success);
|
||
|
||
let replayed =
|
||
server.salesforce_apply_write(Parameters(SalesforceApplyWriteRequest { confirm_token: token })).await;
|
||
assert!(result_text(&replayed).contains("CONFIRM_TOKEN_INVALID"), "{replayed:?}");
|
||
assert_eq!(backend.recorded_arguments.lock().unwrap().len(), 1, "a replayed token must not write again");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_apply_write_rejects_a_token_it_never_issued() {
|
||
let backend = salesforce_server(salesforce_dml_policy(true, false), None);
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let applied = server
|
||
.salesforce_apply_write(Parameters(SalesforceApplyWriteRequest {
|
||
confirm_token: "sfdml-forged".to_string(),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&applied).contains("CONFIRM_TOKEN_INVALID"), "{applied:?}");
|
||
assert!(result_text(&applied).contains("dbx_salesforce_prepare_write"));
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_prepare_write_honours_read_only_and_production_rules() {
|
||
let read_only = McpGlobalPolicy { read_only: true, ..salesforce_dml_policy(true, false) };
|
||
let backend = salesforce_server(read_only, None);
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let prepared = server
|
||
.salesforce_prepare_write(prepare_request("update", "Account", Some("001x"), Some(json!({"Name": "Acme"}))))
|
||
.await;
|
||
assert!(result_text(&prepared).contains("MCP_READ_ONLY"), "{prepared:?}");
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
|
||
let mut production = salesforce_connection();
|
||
production.is_production = true;
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![production],
|
||
policy: salesforce_dml_policy(true, false),
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let prepared = server
|
||
.salesforce_prepare_write(prepare_request("update", "Account", Some("001x"), Some(json!({"Name": "Acme"}))))
|
||
.await;
|
||
assert!(result_text(&prepared).contains("PRODUCTION_WRITE_BLOCKED"), "{prepared:?}");
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_write_pseudo_commands_cannot_sneak_through_execute_query() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![salesforce_connection()],
|
||
policy: McpGlobalPolicy { read_only: false, allow_dangerous_sql: true, ..Default::default() },
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let statement = build_salesforce_dml_statement("delete", "Account", Some("001x"), None).unwrap();
|
||
let blocked = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
sql: statement,
|
||
session_id: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&blocked).contains("SALESFORCE_DML_REQUIRES_CONFIRMATION"), "{blocked:?}");
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty(), "the write must not reach the org");
|
||
|
||
// SOQL stays readable even when a literal or a custom field name looks
|
||
// like a write verb to a keyword scan.
|
||
for soql in ["SELECT Id FROM Case WHERE Subject = 'Delete request'", "SELECT Id, Update__c FROM Lead LIMIT 5"] {
|
||
let queried = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
sql: soql.to_string(),
|
||
session_id: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_ne!(queried.is_error, Some(true), "{soql}: {queried:?}");
|
||
}
|
||
let recorded = backend.recorded_arguments.lock().unwrap().clone();
|
||
assert_eq!(recorded.len(), 2, "{recorded:?}");
|
||
assert_eq!(recorded[0].1["sql"], json!("SELECT Id FROM Case WHERE Subject = 'Delete request'"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_database_discovery_probe_is_not_read_as_a_write() {
|
||
// `SHOW DATABASES` is not SOQL, so the Salesforce classifier calls it an
|
||
// opaque write. Answering it with "writes need confirmation" would send an
|
||
// agent looking for a schema into the DML flow; the discovery path already
|
||
// has the right answer.
|
||
let backend = salesforce_server(McpGlobalPolicy::default(), None);
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
for probe in ["SHOW DATABASES", " show schemas; "] {
|
||
let probed = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
sql: probe.to_string(),
|
||
session_id: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert_ne!(probed.is_error, Some(true), "{probe}: {probed:?}");
|
||
assert!(result_text(&probed).contains("Salesforce has no databases"), "{probe}: {probed:?}");
|
||
}
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty(), "a discovery probe must not reach the org");
|
||
|
||
// The exemption is exact-match, so a pseudo-command still cannot use it as
|
||
// a way past the confirmation guard.
|
||
let smuggled = server
|
||
.execute_query(Parameters(ExecuteQueryRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
sql: "show databases; DBX SALESFORCE DML\n{\"op\":\"delete\",\"object\":\"Account\",\"id\":\"001x\"}"
|
||
.to_string(),
|
||
session_id: None,
|
||
cell_char_offset: None,
|
||
cell_char_limit: None,
|
||
max_rows: None,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&smuggled).contains("SALESFORCE_DML_REQUIRES_CONFIRMATION"), "{smuggled:?}");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_has_no_batch_and_no_session() {
|
||
let backend = salesforce_server(McpGlobalPolicy::default(), None);
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let batch = server
|
||
.execute_batch(Parameters(ExecuteBatchQueryRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
sql: "SELECT Id FROM Account".to_string(),
|
||
session_id: None,
|
||
continue_on_error: None,
|
||
use_transaction: None,
|
||
cell_window: CellWindowArgs::default(),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&batch).contains("DBX_BATCH_UNSUPPORTED"), "{batch:?}");
|
||
let session = server
|
||
.open_session(Parameters(OpenSessionRequest {
|
||
selector: selector("sfdc"),
|
||
database: None,
|
||
enable_transactions: false,
|
||
}))
|
||
.await;
|
||
assert!(result_text(&session).contains("SESSION_UNSUPPORTED"), "{session:?}");
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_list_databases_points_at_objects_and_soql() {
|
||
let backend = salesforce_server(McpGlobalPolicy::default(), None);
|
||
let server = DbxMcpServer::with_runtime_options(backend, McpScope::default(), false);
|
||
let listed = server.list_databases(Parameters(ListDatabasesRequest { selector: selector("sfdc") })).await;
|
||
assert_ne!(listed.is_error, Some(true), "{listed:?}");
|
||
let text = result_text(&listed);
|
||
assert!(text.contains("Salesforce has no databases"), "{text}");
|
||
assert!(text.contains("dbx_list_tables"), "{text}");
|
||
assert!(text.contains("SELECT Id, Name FROM Account LIMIT 10"), "{text}");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_current_user_names_the_profile_rights() {
|
||
for (is_admin, expected) in [
|
||
(Some(true), "bypasses field-level security"),
|
||
(Some(false), "field-level security and record sharing apply"),
|
||
(None, "could not be determined"),
|
||
] {
|
||
let backend = salesforce_server(McpGlobalPolicy::default(), Some(salesforce_identity(is_admin)));
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let identity = server
|
||
.salesforce_current_user(Parameters(SalesforceIdentityRequest { selector: selector("sfdc") }))
|
||
.await;
|
||
assert_ne!(identity.is_error, Some(true), "{identity:?}");
|
||
let text = result_text(&identity);
|
||
assert!(text.contains("Jane Doe"), "{text}");
|
||
assert!(text.contains(expected), "{text}");
|
||
assert_eq!(identity.structured_content.as_ref().unwrap()["is_admin"], json!(is_admin));
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty(), "identity must not run a query");
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn salesforce_tools_refuse_other_database_types() {
|
||
let backend = Arc::new(FakeBackend {
|
||
connections: vec![connection("pg", "pg", "postgres", "app")],
|
||
..Default::default()
|
||
});
|
||
let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
|
||
let postgres_selector = || ConnectionSelector { connection_id: Some("pg".to_string()), connection_name: None };
|
||
let identity = server
|
||
.salesforce_current_user(Parameters(SalesforceIdentityRequest { selector: postgres_selector() }))
|
||
.await;
|
||
assert!(result_text(&identity).contains("NOT_SALESFORCE_CONNECTION"), "{identity:?}");
|
||
let prepared = server
|
||
.salesforce_prepare_write(Parameters(SalesforcePrepareWriteRequest {
|
||
selector: postgres_selector(),
|
||
database: None,
|
||
op: "update".to_string(),
|
||
object: "Account".to_string(),
|
||
id: Some("001x".to_string()),
|
||
fields: Some(json!({"Name": "Acme"})),
|
||
}))
|
||
.await;
|
||
assert!(result_text(&prepared).contains("NOT_SALESFORCE_CONNECTION"), "{prepared:?}");
|
||
assert!(backend.recorded_arguments.lock().unwrap().is_empty());
|
||
}
|
||
}
|