Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

feat(mcp): prompt in desktop before high-risk SQL

ccq7407f12d0747
diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 2b97dfac73..7dbe631710 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -18,6 +18,7 @@ import AppSidebar from "@/components/layout/AppSidebar.vue";
import SqlEditorWorkspace from "@/components/layout/SqlEditorWorkspace.vue";
import { EDITOR_TOOLBAR_ACTIONS } from "@/components/layout/editorToolbarActions";
import AppDialogs from "@/components/layout/AppDialogs.vue";
+import McpSqlApprovalDialog from "@/components/mcp/McpSqlApprovalDialog.vue";
import DetachedTabHeader from "@/components/layout/DetachedTabHeader.vue";
import WelcomeScreen from "@/components/layout/WelcomeScreen.vue";
import type { ConfigTab } from "@/components/connection/ConnectionDialog.vue";
@@ -5389,6 +5390,7 @@ onUnmounted(() => {
:database-type="queryEditorDdlDatabaseType"
:dialect="queryEditorDdlDialect"
/>
+ <McpSqlApprovalDialog v-if="isDesktop && !isDetachedWindowContext" />
<QueryEditorObjectSourceDialog
v-if="queryEditorObjectSourceTarget"
v-model:open="showQueryEditorObjectSourceDialog"
diff --git a/apps/desktop/src/components/editor/EditorSettingsDialog.vue b/apps/desktop/src/components/editor/EditorSettingsDialog.vue
index 31bdc3884c..078b253f8c 100644
--- a/apps/desktop/src/components/editor/EditorSettingsDialog.vue
+++ b/apps/desktop/src/components/editor/EditorSettingsDialog.vue
@@ -3846,6 +3846,7 @@ async function commitMcpPolicyDraft(): Promise<void> {
await settingsStore.updateMcpGlobalPolicy({
readOnly: snapshot.readOnly,
allowDangerousSql: snapshot.allowDangerousSql,
+ promptHighRiskSql: snapshot.promptHighRiskSql,
allowedConnectionIds: snapshot.allowedConnectionIds,
allowedGroupIds: snapshot.allowedGroupIds,
allowedToolNames: snapshot.allowedToolNames,
@@ -3864,7 +3865,7 @@ function onMcpExecutionModeChange(mode: McpExecutionMode) {
if (mode === "high_risk_write" && !window.confirm(t("settings.mcpExecutionModeHighRiskConfirm"))) {
return;
}
- stageMcpPolicy(mcpPolicyFieldsForExecutionMode(mode));
+ stageMcpPolicy({ ...mcpPolicyFieldsForExecutionMode(mode), promptHighRiskSql: mode === "safe_write" && mcpPolicyDraft.value.promptHighRiskSql });
}
function onMcpExecutionModeKeydown(event: KeyboardEvent, mode: McpExecutionMode) {
@@ -11245,6 +11246,10 @@ LIMIT 100;</pre
</Button>
</div>
<p class="text-[11px] text-muted-foreground">{{ t("settings.mcpPermissionGlobalDefaultHint") }}</p>
+ <label class="flex items-center gap-2 text-xs">
+ <input type="checkbox" :checked="mcpPolicyDraft.promptHighRiskSql" :disabled="mcpPolicyControlsDisabled || mcpExecutionMode !== 'safe_write'" @change="stageMcpPolicy({ promptHighRiskSql: ($event.target as HTMLInputElement).checked })" />
+ {{ t("settings.mcpPromptHighRiskSql") }}
+ </label>
<div class="space-y-2 border-t border-border/60 pt-3">
<div>
<p class="text-xs font-medium">{{ t("settings.mcpCapabilityTitle") }}</p>
diff --git a/apps/desktop/src/components/mcp/McpSqlApprovalDialog.vue b/apps/desktop/src/components/mcp/McpSqlApprovalDialog.vue
new file mode 100644
index 0000000000..1536ab9ece
--- /dev/null
+++ b/apps/desktop/src/components/mcp/McpSqlApprovalDialog.vue
@@ -0,0 +1,76 @@
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { invoke } from "@tauri-apps/api/core";
+import { listen, type UnlistenFn } from "@tauri-apps/api/event";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+
+interface Approval {
+ id: string;
+ connection_name: string;
+ database: string;
+ sql: string;
+}
+
+const { t } = useI18n();
+const pending = ref<Approval[]>([]);
+const current = computed(() => pending.value[0]);
+const expirationTimers = new Map<string, ReturnType<typeof setTimeout>>();
+let unlisten: UnlistenFn | undefined;
+
+onMounted(async () => {
+ unlisten = await listen<Approval>("mcp-sql-approval", (event) => {
+ if (pending.value.some((approval) => approval.id === event.payload.id)) return;
+ pending.value.push(event.payload);
+ expirationTimers.set(
+ event.payload.id,
+ setTimeout(() => {
+ pending.value = pending.value.filter((approval) => approval.id !== event.payload.id);
+ expirationTimers.delete(event.payload.id);
+ }, 90_000),
+ );
+ void getCurrentWindow().setFocus();
+ });
+});
+
+onUnmounted(() => {
+ unlisten?.();
+ for (const timer of expirationTimers.values()) clearTimeout(timer);
+ expirationTimers.clear();
+});
+
+async function decide(decision: "once" | "hour" | "day" | "deny") {
+ const approval = current.value;
+ if (!approval) return;
+ pending.value.shift();
+ clearTimeout(expirationTimers.get(approval.id));
+ expirationTimers.delete(approval.id);
+ try {
+ await invoke("respond_mcp_sql_approval", { id: approval.id, decision });
+ } catch (error) {
+ console.error("[DBX] MCP SQL approval expired:", error);
+ }
+}
+</script>
+
+<template>
+ <Dialog :open="!!current" @update:open="(open) => !open && decide('deny')">
+ <DialogContent class="sm:max-w-[640px]">
+ <DialogHeader
+ ><DialogTitle>{{ t("settings.mcpSqlApprovalTitle") }}</DialogTitle></DialogHeader
+ >
+ <div v-if="current" class="min-w-0 space-y-3">
+ <p class="text-sm">{{ t("settings.mcpSqlApprovalScope", { connection: current.connection_name, database: current.database }) }}</p>
+ <pre class="max-h-64 overflow-auto rounded border bg-muted/40 p-3 text-xs whitespace-pre-wrap break-all">{{ current.sql }}</pre>
+ </div>
+ <DialogFooter class="flex-wrap gap-2">
+ <Button variant="outline" @click="decide('deny')">{{ t("settings.mcpSqlApprovalDeny") }}</Button>
+ <Button variant="outline" @click="decide('once')">{{ t("settings.mcpSqlApprovalOnce") }}</Button>
+ <Button variant="outline" @click="decide('hour')">{{ t("settings.mcpSqlApprovalHour") }}</Button>
+ <Button variant="destructive" @click="decide('day')">{{ t("settings.mcpSqlApprovalDay") }}</Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+</template>
diff --git a/apps/desktop/src/components/mcp/__tests__/McpSqlApprovalDialog.spec.ts b/apps/desktop/src/components/mcp/__tests__/McpSqlApprovalDialog.spec.ts
new file mode 100644
index 0000000000..af36e21931
--- /dev/null
+++ b/apps/desktop/src/components/mcp/__tests__/McpSqlApprovalDialog.spec.ts
@@ -0,0 +1,96 @@
+// @vitest-environment happy-dom
+import { createApp, nextTick } from "vue";
+import { createI18n } from "vue-i18n";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+
+const bridge = vi.hoisted(() => ({
+ handler: null as null | ((event: { payload: { id: string; connection_name: string; database: string; sql: string } }) => void),
+ invoke: vi.fn(async () => undefined),
+ focus: vi.fn(async () => undefined),
+ unlisten: vi.fn(),
+}));
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: bridge.invoke }));
+vi.mock("@tauri-apps/api/event", () => ({
+ listen: vi.fn(async (_name: string, handler: typeof bridge.handler) => {
+ bridge.handler = handler;
+ return bridge.unlisten;
+ }),
+}));
+vi.mock("@tauri-apps/api/window", () => ({ getCurrentWindow: () => ({ setFocus: bridge.focus }) }));
+vi.mock("@/components/ui/button", () => ({ Button: { template: "<button><slot /></button>" } }));
+vi.mock("@/components/ui/dialog", () => ({
+ Dialog: { props: ["open"], template: '<div v-if="open"><slot /></div>' },
+ DialogContent: { template: "<div><slot /></div>" },
+ DialogFooter: { template: "<div><slot /></div>" },
+ DialogHeader: { template: "<div><slot /></div>" },
+ DialogTitle: { template: "<div><slot /></div>" },
+}));
+
+import McpSqlApprovalDialog from "../McpSqlApprovalDialog.vue";
+
+let host: HTMLDivElement;
+let app: ReturnType<typeof createApp>;
+
+beforeEach(async () => {
+ vi.useFakeTimers();
+ bridge.handler = null;
+ bridge.invoke.mockClear();
+ bridge.focus.mockClear();
+ bridge.unlisten.mockClear();
+ host = document.createElement("div");
+ document.body.appendChild(host);
+ app = createApp(McpSqlApprovalDialog);
+ app.use(
+ createI18n({
+ legacy: false,
+ locale: "en",
+ messages: {
+ en: {
+ settings: {
+ mcpSqlApprovalTitle: "Approve SQL",
+ mcpSqlApprovalScope: "Connection: {connection} / {database}",
+ mcpSqlApprovalOnce: "Once",
+ mcpSqlApprovalHour: "One hour",
+ mcpSqlApprovalDay: "One day",
+ mcpSqlApprovalDeny: "Deny",
+ },
+ },
+ },
+ }),
+ );
+ app.mount(host);
+ await Promise.resolve();
+});
+
+afterEach(() => {
+ app.unmount();
+ host.remove();
+ vi.useRealTimers();
+});
+
+function request(id: string) {
+ bridge.handler?.({ payload: { id, connection_name: "Local", database: "app", sql: "DROP TABLE important;" } });
+}
+
+it("shows the exact SQL and sends a one-time decision for its request ID", async () => {
+ request("approval-1");
+ await nextTick();
+ expect(host.textContent).toContain("DROP TABLE important;");
+ expect(host.textContent).toContain("Local / app");
+ expect(bridge.focus).toHaveBeenCalledOnce();
+ const once = Array.from(host.querySelectorAll("button")).find((button) => button.textContent === "Once");
+ once?.click();
+ await nextTick();
+ expect(bridge.invoke).toHaveBeenCalledWith("respond_mcp_sql_approval", { id: "approval-1", decision: "once" });
+ expect(host.textContent).not.toContain("DROP TABLE important;");
+});
+
+it("removes an unanswered request when the desktop approval times out", async () => {
+ request("approval-2");
+ await nextTick();
+ vi.advanceTimersByTime(90_000);
+ await nextTick();
+ expect(host.textContent).not.toContain("DROP TABLE important;");
+ expect(bridge.invoke).not.toHaveBeenCalled();
+});
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 56fd79155a..b66433ea9f 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -9219,6 +9219,13 @@ export default {
mcpExecutionModeSafeWriteDescription: "Allows regular INSERT, filtered UPDATE/DELETE, verifiably scoped MongoDB changes, and ordinary Redis writes or explicit-key deletion; blocks table-wide and structural changes.",
mcpExecutionModeHighRiskWriteDescription: "In addition to data read/write, allows table-wide changes, DDL, TRUNCATE, database clearing, and other high-risk operations. Production and connection read-only protections still apply.",
mcpExecutionModeHighRiskConfirm: "Full access allows table-wide changes, DDL, TRUNCATE, database clearing, and other high-risk operations. Enable it?",
+ mcpPromptHighRiskSql: "Ask before high-risk SQL (desktop only; read-only and production safeguards remain)",
+ mcpSqlApprovalTitle: "MCP high-risk SQL approval",
+ mcpSqlApprovalScope: "Connection: {connection} · Database: {database}",
+ mcpSqlApprovalOnce: "This request only",
+ mcpSqlApprovalHour: "Allow on this database for 1 hour",
+ mcpSqlApprovalDay: "Allow on this database for 1 day",
+ mcpSqlApprovalDeny: "Deny",
mcpCapabilityTitle: "Capability comparison",
mcpCapabilityDescription: "These are representative operations; requests DBX cannot classify reliably require full access.",
mcpCapabilityOperation: "Capability",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index 5e716b0ab9..e1f45bad54 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -8457,6 +8457,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "Permite INSERT normales, UPDATE/DELETE con filtros efectivos, cambios MongoDB de alcance verificable y escrituras Redis normales o borrado de claves explícitas; bloquea cambios globales y estructurales.",
mcpExecutionModeHighRiskWriteDescription: "Además de leer y escribir datos, permite cambios de tablas completas, DDL, TRUNCATE, vaciado de bases de datos y otras operaciones de alto riesgo. Las protecciones de producción y solo lectura siguen activas.",
mcpExecutionModeHighRiskConfirm: "El acceso completo permite cambios de tablas completas, DDL, TRUNCATE, vaciado de bases de datos y otras operaciones de alto riesgo. ¿Quieres activarlo?",
+ mcpPromptHighRiskSql: "Solicitar confirmación para SQL de alto riesgo (solo escritorio; se mantienen las protecciones de solo lectura y producción)",
+ mcpSqlApprovalTitle: "Aprobación de SQL de alto riesgo de MCP",
+ mcpSqlApprovalScope: "Conexión: {connection} · Base de datos: {database}",
+ mcpSqlApprovalOnce: "Solo esta solicitud",
+ mcpSqlApprovalHour: "Permitir en esta base de datos durante 1 hora",
+ mcpSqlApprovalDay: "Permitir en esta base de datos durante 1 día",
+ mcpSqlApprovalDeny: "Denegar",
mcpCapabilityTitle: "Comparación de capacidades",
mcpCapabilityDescription: "Estas son operaciones representativas; las solicitudes que DBX no puede clasificar de forma fiable requieren acceso completo.",
mcpCapabilityOperation: "Capacidad",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 6248dc97ec..8c7e923913 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -8206,6 +8206,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "Consente INSERT normali, UPDATE/DELETE con filtri effettivi, modifiche MongoDB con ambito verificabile e normali scritture Redis o eliminazione di chiavi esplicite; blocca modifiche globali e strutturali.",
mcpExecutionModeHighRiskWriteDescription: "Oltre alla lettura e scrittura dati, consente modifiche a intere tabelle, DDL, TRUNCATE, svuotamento del database e altre operazioni ad alto rischio. Le protezioni di produzione e sola lettura restano attive.",
mcpExecutionModeHighRiskConfirm: "L'accesso completo consente modifiche a intere tabelle, DDL, TRUNCATE, svuotamento del database e altre operazioni ad alto rischio. Abilitarlo?",
+ mcpPromptHighRiskSql: "Chiedi conferma per SQL ad alto rischio (solo desktop; restano attive le protezioni di sola lettura e produzione)",
+ mcpSqlApprovalTitle: "Approvazione SQL ad alto rischio MCP",
+ mcpSqlApprovalScope: "Connessione: {connection} · Database: {database}",
+ mcpSqlApprovalOnce: "Solo questa richiesta",
+ mcpSqlApprovalHour: "Consenti su questo database per 1 ora",
+ mcpSqlApprovalDay: "Consenti su questo database per 1 giorno",
+ mcpSqlApprovalDeny: "Rifiuta",
mcpCapabilityTitle: "Confronto delle capacità",
mcpCapabilityDescription: "Queste sono operazioni rappresentative; le richieste che DBX non può classificare in modo affidabile richiedono l'accesso completo.",
mcpCapabilityOperation: "Capacità",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index ef07b4de3b..38fc4cdcb0 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -8198,6 +8198,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "通常のINSERT、有効な条件付きUPDATE/DELETE、範囲を検証できるMongoDB変更、通常のRedis書き込みや明示キー削除を許可し、テーブル全体や構造の変更を拒否します。",
mcpExecutionModeHighRiskWriteDescription: "データ読み書きに加えて、テーブル全体の変更、DDL、TRUNCATE、データベース消去などの高リスク操作を許可します。本番環境と接続の読み取り専用保護は引き続き適用されます。",
mcpExecutionModeHighRiskConfirm: "フルアクセスでは、テーブル全体の変更、DDL、TRUNCATE、データベース消去などの高リスク操作を実行できます。有効にしますか?",
+ mcpPromptHighRiskSql: "高リスク SQL の実行前に確認する(デスクトップ版のみ。読み取り専用・本番環境の保護は維持)",
+ mcpSqlApprovalTitle: "MCP 高リスク SQL の承認",
+ mcpSqlApprovalScope: "接続: {connection} · データベース: {database}",
+ mcpSqlApprovalOnce: "今回のリクエストのみ",
+ mcpSqlApprovalHour: "このデータベースで 1 時間許可",
+ mcpSqlApprovalDay: "このデータベースで 1 日許可",
+ mcpSqlApprovalDeny: "拒否",
mcpCapabilityTitle: "権限と機能の比較",
mcpCapabilityDescription: "代表的な操作を示しています。DBXが確実に分類できないリクエストにはフルアクセスが必要です。",
mcpCapabilityOperation: "機能",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index e0fd3b4059..f08e3f0a6d 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -8053,6 +8053,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "일반 INSERT, 필터링된 UPDATE/DELETE, 범위가 확인된 MongoDB 변경 및 일반 Redis 쓰기나 명시적 키 삭제를 허용하며 테이블 전체 및 구조 변경을 차단합니다.",
mcpExecutionModeHighRiskWriteDescription: "데이터 읽기/쓰기 외에 테이블 전체 변경, DDL, TRUNCATE, 데이터베이스 비우기 및 기타 고위험 작업을 허용합니다. 프로덕션 및 연결 읽기 전용 보호는 여전히 적용됩니다.",
mcpExecutionModeHighRiskConfirm: "전체 접근은 테이블 전체 변경, DDL, TRUNCATE, 데이터베이스 비우기 및 기타 고위험 작업을 허용합니다. 활성화하시겠습니까?",
+ mcpPromptHighRiskSql: "고위험 SQL 실행 전 확인 요청(데스크톱 전용; 읽기 전용 및 운영 환경 보호 유지)",
+ mcpSqlApprovalTitle: "MCP 고위험 SQL 승인",
+ mcpSqlApprovalScope: "연결: {connection} · 데이터베이스: {database}",
+ mcpSqlApprovalOnce: "이번 요청에만 허용",
+ mcpSqlApprovalHour: "이 데이터베이스에서 1시간 허용",
+ mcpSqlApprovalDay: "이 데이터베이스에서 1일 허용",
+ mcpSqlApprovalDeny: "거부",
mcpCapabilityTitle: "기능 비교",
mcpCapabilityDescription: "대표적인 작업입니다. DBX가 안정적으로 분류할 수 없는 요청은 전체 접근이 필요합니다.",
mcpCapabilityOperation: "기능",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index dc1d102c9f..3077523d86 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -8205,6 +8205,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "Permite INSERT normal, UPDATE/DELETE com filtros efetivos, alterações MongoDB de escopo verificável e gravações Redis comuns ou exclusão de chaves explícitas; bloqueia alterações globais e estruturais.",
mcpExecutionModeHighRiskWriteDescription: "Além da leitura e gravação de dados, permite alterações na tabela inteira, DDL, TRUNCATE, limpeza do banco e outras operações de alto risco. As proteções de produção e somente leitura continuam ativas.",
mcpExecutionModeHighRiskConfirm: "O acesso completo permite alterações na tabela inteira, DDL, TRUNCATE, limpeza do banco e outras operações de alto risco. Deseja ativá-lo?",
+ mcpPromptHighRiskSql: "Pedir confirmação para SQL de alto risco (apenas desktop; proteções de somente leitura e produção permanecem)",
+ mcpSqlApprovalTitle: "Aprovação de SQL de alto risco do MCP",
+ mcpSqlApprovalScope: "Conexão: {connection} · Banco de dados: {database}",
+ mcpSqlApprovalOnce: "Somente esta solicitação",
+ mcpSqlApprovalHour: "Permitir neste banco de dados por 1 hora",
+ mcpSqlApprovalDay: "Permitir neste banco de dados por 1 dia",
+ mcpSqlApprovalDeny: "Negar",
mcpCapabilityTitle: "Comparação de recursos",
mcpCapabilityDescription: "Estas são operações representativas; solicitações que o DBX não consegue classificar com segurança exigem acesso completo.",
mcpCapabilityOperation: "Recurso",
diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts
index c17a1351f3..3e8d60b538 100644
--- a/apps/desktop/src/i18n/locales/ru.ts
+++ b/apps/desktop/src/i18n/locales/ru.ts
@@ -9504,6 +9504,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "Разрешает обычные INSERT, UPDATE/DELETE с фильтром, проверяемо ограниченные изменения MongoDB и обычные записи Redis или удаление по явному ключу; блокирует изменения всей таблицы и структурные изменения.",
mcpExecutionModeHighRiskWriteDescription: "Помимо чтения/записи данных разрешает изменения всей таблицы, DDL, TRUNCATE, очистку базы данных и другие операции высокого риска. Защита продакшена и подключений только для чтения по-прежнему действует.",
mcpExecutionModeHighRiskConfirm: "Полный доступ разрешает изменения всей таблицы, DDL, TRUNCATE, очистку базы данных и другие операции высокого риска. Включить его?",
+ mcpPromptHighRiskSql: "Запрашивать подтверждение для SQL высокого риска (только настольная версия; защита от записи и для рабочих баз сохраняется)",
+ mcpSqlApprovalTitle: "Подтверждение SQL высокого риска для MCP",
+ mcpSqlApprovalScope: "Подключение: {connection} · База данных: {database}",
+ mcpSqlApprovalOnce: "Только этот запрос",
+ mcpSqlApprovalHour: "Разрешить для этой базы на 1 час",
+ mcpSqlApprovalDay: "Разрешить для этой базы на 1 день",
+ mcpSqlApprovalDeny: "Отклонить",
mcpCapabilityTitle: "Сравнение возможностей",
mcpCapabilityDescription: "Это типовые операции; запросы, которые DBX не может надёжно классифицировать, требуют полного доступа.",
mcpCapabilityOperation: "Возможность",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 7fe23d9152..7160293c3c 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -9206,6 +9206,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "允许普通 INSERT、带有效条件的 UPDATE/DELETE、MongoDB 范围可验证的变更,以及 Redis 普通写入和明确键删除;阻止全表修改和结构变更。",
mcpExecutionModeHighRiskWriteDescription: "在数据读写基础上允许全表修改、DDL、TRUNCATE、清库及其他高风险操作;生产库和连接只读保护仍然生效。",
mcpExecutionModeHighRiskConfirm: "完全访问允许全表修改、DDL、TRUNCATE、清库及其他高风险操作。确定要启用吗?",
+ mcpPromptHighRiskSql: "高风险 SQL 请求人工确认(仅桌面端;只读和生产库保护不变)",
+ mcpSqlApprovalTitle: "MCP 高风险 SQL 授权",
+ mcpSqlApprovalScope: "连接:{connection} · 数据库:{database}",
+ mcpSqlApprovalOnce: "仅本次",
+ mcpSqlApprovalHour: "允许此库 1 小时",
+ mcpSqlApprovalDay: "允许此库 1 天",
+ mcpSqlApprovalDeny: "拒绝",
mcpCapabilityTitle: "权限能力对照",
mcpCapabilityDescription: "以下为典型操作;无法可靠分类的请求需要完全访问。",
mcpCapabilityOperation: "能力",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index a472906757..e9e71f07b5 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -7592,6 +7592,13 @@ export default withEnglishFallback({
mcpExecutionModeSafeWriteDescription: "允許一般 INSERT、帶有效條件的 UPDATE/DELETE、MongoDB 可驗證範圍的變更,以及 Redis 一般寫入和明確鍵刪除;阻止全表修改與結構變更。",
mcpExecutionModeHighRiskWriteDescription: "在資料讀寫基礎上允許全表修改、DDL、TRUNCATE、清空資料庫及其他高風險操作;生產庫與連線唯讀保護仍然生效。",
mcpExecutionModeHighRiskConfirm: "完整存取允許全表修改、DDL、TRUNCATE、清空資料庫及其他高風險操作。確定要啟用嗎?",
+ mcpPromptHighRiskSql: "高風險 SQL 請求人工確認(僅桌面版;唯讀與正式環境保護維持不變)",
+ mcpSqlApprovalTitle: "MCP 高風險 SQL 核准",
+ mcpSqlApprovalScope: "連線:{connection} · 資料庫:{database}",
+ mcpSqlApprovalOnce: "僅本次請求",
+ mcpSqlApprovalHour: "允許此資料庫 1 小時",
+ mcpSqlApprovalDay: "允許此資料庫 1 天",
+ mcpSqlApprovalDeny: "拒絕",
mcpCapabilityTitle: "權限能力對照",
mcpCapabilityDescription: "以下為典型操作;無法可靠分類的請求需要完整存取。",
mcpCapabilityOperation: "能力",
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 09cd646d5a..e9281581a3 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -332,6 +332,7 @@ export interface DesktopSettings {
export interface McpGlobalPolicy {
readOnly: boolean;
allowDangerousSql: boolean;
+ promptHighRiskSql: boolean;
allowedConnectionIds: string[] | null;
allowedGroupIds: string[];
allowedToolNames: string[] | null;
diff --git a/apps/desktop/src/stores/__tests__/settingsStore.spec.ts b/apps/desktop/src/stores/__tests__/settingsStore.spec.ts
index 2f967c9ea7..d4a9b50a01 100644
--- a/apps/desktop/src/stores/__tests__/settingsStore.spec.ts
+++ b/apps/desktop/src/stores/__tests__/settingsStore.spec.ts
@@ -878,6 +878,7 @@ describe("normalizeMcpGlobalPolicy", () => {
expect(normalizeMcpGlobalPolicy(undefined)).toEqual({
readOnly: false,
allowDangerousSql: false,
+ promptHighRiskSql: false,
allowedConnectionIds: null,
allowedGroupIds: [],
allowedToolNames: null,
@@ -899,6 +900,7 @@ describe("normalizeMcpGlobalPolicy", () => {
).toEqual({
readOnly: true,
allowDangerousSql: true,
+ promptHighRiskSql: false,
allowedConnectionIds: ["connection-1", "connection-2"],
allowedGroupIds: [],
allowedToolNames: null,
@@ -913,6 +915,11 @@ describe("normalizeMcpGlobalPolicy", () => {
expect(normalizeMcpGlobalPolicy({ allowedConnectionIds: [] }).allowedConnectionIds).toEqual([]);
});
+ it("enables high-risk SQL prompts only when explicitly configured", () => {
+ expect(normalizeMcpGlobalPolicy({ promptHighRiskSql: true }).promptHighRiskSql).toBe(true);
+ expect(normalizeMcpGlobalPolicy({ promptHighRiskSql: "true" } as any).promptHighRiskSql).toBe(false);
+ });
+
it("keeps only selected-database execution policies and normalizes their names", () => {
const policy = normalizeMcpGlobalPolicy({
connectionPolicies: [
@@ -1386,6 +1393,7 @@ describe("settingsStore MCP policy persistence", () => {
const previous = {
readOnly: true,
allowDangerousSql: false,
+ promptHighRiskSql: false,
allowedConnectionIds: ["connection-1"],
allowedGroupIds: [],
allowedToolNames: null,
@@ -1403,6 +1411,7 @@ describe("settingsStore MCP policy persistence", () => {
expect(store.mcpGlobalPolicy).toEqual({
readOnly: false,
allowDangerousSql: false,
+ promptHighRiskSql: false,
allowedConnectionIds: [],
allowedGroupIds: [],
allowedToolNames: null,
diff --git a/apps/desktop/src/stores/settingsStore.ts b/apps/desktop/src/stores/settingsStore.ts
index 2669dcf3d5..3729f69cd1 100644
--- a/apps/desktop/src/stores/settingsStore.ts
+++ b/apps/desktop/src/stores/settingsStore.ts
@@ -88,6 +88,7 @@ export interface DesktopSettings {
export interface McpGlobalPolicy {
readOnly: boolean;
allowDangerousSql: boolean;
+ promptHighRiskSql: boolean;
allowedConnectionIds: string[] | null;
allowedGroupIds: string[];
allowedToolNames: string[] | null;
@@ -169,6 +170,7 @@ export const DEFAULT_DESKTOP_SETTINGS: DesktopSettings = {
export const DEFAULT_MCP_GLOBAL_POLICY: McpGlobalPolicy = {
readOnly: false,
allowDangerousSql: false,
+ promptHighRiskSql: false,
allowedConnectionIds: null,
allowedGroupIds: [],
allowedToolNames: null,
@@ -240,6 +242,7 @@ export function normalizeMcpGlobalPolicy(policy: Partial<McpGlobalPolicy> | null
return {
readOnly: policy?.readOnly === true,
allowDangerousSql: policy?.allowDangerousSql === true,
+ promptHighRiskSql: policy?.promptHighRiskSql === true,
allowedConnectionIds,
allowedGroupIds,
allowedToolNames,
@@ -2429,6 +2432,7 @@ export const useSettingsStore = defineStore("settings", () => {
await api.saveMcpGlobalPolicy({
readOnly: next.readOnly,
allowDangerousSql: next.allowDangerousSql,
+ promptHighRiskSql: next.promptHighRiskSql,
allowedConnectionIds: next.allowedConnectionIds,
allowedGroupIds: next.allowedGroupIds,
allowedToolNames: next.allowedToolNames,
diff --git a/crates/dbx-core/src/persistence/storage.rs b/crates/dbx-core/src/persistence/storage.rs
index e838508907..363c86ddaa 100644
--- a/crates/dbx-core/src/persistence/storage.rs
+++ b/crates/dbx-core/src/persistence/storage.rs
@@ -512,6 +512,10 @@ pub struct McpGlobalPolicy {
pub read_only: bool,
#[serde(default)]
pub allow_dangerous_sql: bool,
+ /// Ask the desktop user before high-risk SQL when the effective mode is safe-write.
+ /// This never relaxes read-only, connection, database-scope or production protections.
+ #[serde(default)]
+ pub prompt_high_risk_sql: bool,
pub allowed_connection_ids: Option<Vec<String>>,
/// Stable sidebar group ids whose current descendant connections are
/// exposed when an explicit connection scope is configured.
@@ -687,6 +691,8 @@ pub struct McpGlobalPolicyState {
pub configured: bool,
pub read_only: bool,
pub allow_dangerous_sql: bool,
+ #[serde(default)]
+ pub prompt_high_risk_sql: bool,
pub allowed_connection_ids: Option<Vec<String>>,
#[serde(default)]
pub allowed_group_ids: Vec<String>,
@@ -705,6 +711,7 @@ impl McpGlobalPolicyState {
McpGlobalPolicy {
read_only: self.read_only,
allow_dangerous_sql: self.allow_dangerous_sql,
+ prompt_high_risk_sql: self.prompt_high_risk_sql,
allowed_connection_ids: self.allowed_connection_ids.clone(),
allowed_group_ids: self.allowed_group_ids.clone(),
allowed_tool_names: self.allowed_tool_names.clone(),
@@ -846,6 +853,7 @@ impl McpGlobalPolicy {
Self {
read_only: self.read_only,
allow_dangerous_sql: !self.read_only && self.allow_dangerous_sql,
+ prompt_high_risk_sql: !self.read_only && self.prompt_high_risk_sql,
allowed_connection_ids,
allowed_group_ids,
allowed_tool_names,
@@ -5042,6 +5050,7 @@ impl Storage {
configured: false,
read_only: policy.read_only,
allow_dangerous_sql: policy.allow_dangerous_sql,
+ prompt_high_risk_sql: policy.prompt_high_risk_sql,
allowed_connection_ids: policy.allowed_connection_ids,
allowed_group_ids: policy.allowed_group_ids,
allowed_tool_names: policy.allowed_tool_names,
@@ -5058,6 +5067,7 @@ impl Storage {
configured: false,
read_only: policy.read_only,
allow_dangerous_sql: policy.allow_dangerous_sql,
+ prompt_high_risk_sql: policy.prompt_high_risk_sql,
allowed_connection_ids: policy.allowed_connection_ids,
allowed_group_ids: policy.allowed_group_ids,
allowed_tool_names: policy.allowed_tool_names,
@@ -5073,6 +5083,7 @@ impl Storage {
configured: true,
read_only: policy.read_only,
allow_dangerous_sql: policy.allow_dangerous_sql,
+ prompt_high_risk_sql: policy.prompt_high_risk_sql,
allowed_connection_ids: policy.allowed_connection_ids,
allowed_group_ids: policy.allowed_group_ids,
allowed_tool_names: policy.allowed_tool_names,
@@ -12469,6 +12480,7 @@ mod tests {
configured: false,
read_only: false,
allow_dangerous_sql: false,
+ prompt_high_risk_sql: false,
allowed_connection_ids: None,
allowed_group_ids: Vec::new(),
allowed_tool_names: None,
@@ -12496,6 +12508,7 @@ mod tests {
configured: true,
read_only: true,
allow_dangerous_sql: false,
+ prompt_high_risk_sql: false,
allowed_connection_ids: Some(vec!["conn-1".to_string(), "conn-2".to_string()]),
allowed_group_ids: Vec::new(),
allowed_tool_names: None,
@@ -12516,6 +12529,15 @@ mod tests {
assert!(storage.load_mcp_global_policy().await.unwrap().read_only);
}
+ #[test]
+ fn legacy_mcp_policy_does_not_enable_high_risk_prompts() {
+ let policy: McpGlobalPolicy =
+ serde_json::from_str(r#"{"readOnly":false,"allowDangerousSql":false,"allowedConnectionIds":null}"#)
+ .unwrap();
+ assert!(!policy.prompt_high_risk_sql);
+ assert!(!policy.normalized().prompt_high_risk_sql);
+ }
+
#[tokio::test]
async fn mcp_global_policy_fails_closed_on_malformed_settings() {
let path = temp_db_path("mcp-global-policy-malformed");
diff --git a/crates/dbx-mcp/src/backend.rs b/crates/dbx-mcp/src/backend.rs
index 37a2fb2676..0eeb8cf5bb 100644
--- a/crates/dbx-mcp/src/backend.rs
+++ b/crates/dbx-mcp/src/backend.rs
@@ -479,6 +479,20 @@ pub trait DbxBackend: Send + Sync {
let _ = (path, body);
Err("DBX is not running. Please start DBX first.".to_string())
}
+ async fn approve_high_risk_sql(&self, connection_id: &str, database: &str, sql: &str) -> Result<String, String> {
+ let _ = (connection_id, database, sql);
+ Err("SQL_BLOCKED: Desktop approval is unavailable for this MCP backend.".to_string())
+ }
+ async fn consume_high_risk_sql_approval(
+ &self,
+ token: &str,
+ connection_id: &str,
+ database: &str,
+ sql: &str,
+ ) -> Result<(), String> {
+ let _ = (token, connection_id, database, sql);
+ Err("SQL_BLOCKED: Desktop approval is unavailable for this MCP backend.".to_string())
+ }
async fn collect_docs_snapshot(
&self,
connection: &ConnectionConfig,
@@ -1080,6 +1094,55 @@ fn local_agent_dir(settings: &DesktopSettings, data_dir: &Path) -> PathBuf {
#[async_trait]
impl DbxBackend for LocalBackend {
+ async fn approve_high_risk_sql(&self, connection_id: &str, database: &str, sql: &str) -> Result<String, String> {
+ let port = tokio::fs::read_to_string(self.data_dir.join("mcp-bridge-port"))
+ .await
+ .map_err(|_| "SQL_BLOCKED: DBX desktop is not running.".to_string())?;
+ let response = reqwest::Client::builder()
+ .timeout(std::time::Duration::from_secs(100))
+ .build()
+ .map_err(|error| error.to_string())?
+ .post(format!("http://127.0.0.1:{}/approve-high-risk-sql", port.trim()))
+ .json(&json!({ "connection_id": connection_id, "database": database, "sql": sql }))
+ .send()
+ .await
+ .map_err(|error| format!("SQL_BLOCKED: Desktop approval unavailable: {error}"))?;
+ if !response.status().is_success() {
+ return Err(response.text().await.unwrap_or_else(|_| "SQL_BLOCKED: Approval failed".to_string()));
+ }
+ response
+ .json::<Value>()
+ .await
+ .map_err(|error| error.to_string())?
+ .get("token")
+ .and_then(Value::as_str)
+ .map(ToOwned::to_owned)
+ .ok_or_else(|| "SQL_BLOCKED: Invalid desktop approval response".to_string())
+ }
+ async fn consume_high_risk_sql_approval(
+ &self,
+ token: &str,
+ connection_id: &str,
+ database: &str,
+ sql: &str,
+ ) -> Result<(), String> {
+ let port = tokio::fs::read_to_string(self.data_dir.join("mcp-bridge-port"))
+ .await
+ .map_err(|_| "SQL_BLOCKED: DBX desktop is not running.".to_string())?;
+ let response = reqwest::Client::builder()
+ .timeout(std::time::Duration::from_secs(10))
+ .build()
+ .map_err(|error| error.to_string())?
+ .post(format!("http://127.0.0.1:{}/consume-high-risk-sql-approval", port.trim()))
+ .json(&json!({ "token": token, "connection_id": connection_id, "database": database, "sql": sql }))
+ .send()
+ .await
+ .map_err(|error| format!("SQL_BLOCKED: Desktop approval unavailable: {error}"))?;
+ if !response.status().is_success() {
+ return Err(response.text().await.unwrap_or_else(|_| "SQL_BLOCKED: Approval expired".to_string()));
+ }
+ Ok(())
+ }
async fn load_mcp_global_policy(&self) -> Result<McpGlobalPolicy, String> {
self.state.storage.load_mcp_global_policy().await.map(effective_mcp_policy)
}
@@ -3075,6 +3138,7 @@ mod tests {
configured,
read_only,
allow_dangerous_sql: false,
+ prompt_high_risk_sql: false,
allowed_connection_ids: None,
allowed_group_ids: Vec::new(),
allowed_tool_names: None,
diff --git a/crates/dbx-mcp/src/server.rs b/crates/dbx-mcp/src/server.rs
index 4d3b70fc55..ac1a14f310 100644
--- a/crates/dbx-mcp/src/server.rs
+++ b/crates/dbx-mcp/src/server.rs
@@ -787,6 +787,60 @@ impl McpScope {
}
impl DbxMcpServer {
+ /// A desktop confirmation can lift only the high-risk SQL tier for one
+ /// already-scoped operation. All other policy checks run before the prompt.
+ async fn approved_sql_policy(
+ &self,
+ connection: &ConnectionConfig,
+ policy: &McpGlobalPolicy,
+ database: &str,
+ sql: &str,
+ allow_database_switch: bool,
+ bridge_execution: bool,
+ ) -> Result<(McpGlobalPolicy, Option<String>), CallToolResult> {
+ let high_risk = classify_sql_risk_for_database(sql, connection.db_type).is_ok_and(|risk| risk == SqlRisk::Ddl)
+ || is_dangerous_sql_for_database(sql, connection.db_type);
+ if policy.allow_dangerous_sql || !policy.prompt_high_risk_sql || !high_risk {
+ return Ok((policy.clone(), None));
+ }
+ let mut approved = policy.clone();
+ approved.allow_dangerous_sql = true;
+ validate_sql_policy(connection, &approved, database, sql, allow_database_switch)?;
+ let token = self
+ .backend
+ .approve_high_risk_sql(&connection.id, database, sql)
+ .await
+ .map_err(|error| tool_error("SQL_BLOCKED", error))?;
+ // A user may change the scope, connection, or permissions while the dialog
+ // is open. The approval is valid only for the original target and SQL.
+ let refreshed = self
+ .resolve_connection(&ConnectionSelector {
+ connection_id: Some(connection.id.clone()),
+ connection_name: None,
+ })
+ .await?;
+ if refreshed.connection != *connection {
+ return Err(tool_error("SQL_BLOCKED", "Connection changed while awaiting approval."));
+ }
+ self.resolve_database(Some(database.to_string()), &refreshed)?;
+ ensure_sql_database_scope(&refreshed.database_scope, connection, database, sql)?;
+ ensure_sql_database_execution_scope(&refreshed.policy, connection, database, sql)?;
+ let mut current =
+ effective_policy_for_database_with_groups(&refreshed.policy, &refreshed.group_ids, connection, database);
+ if !current.prompt_high_risk_sql || current.read_only {
+ return Err(tool_error("SQL_BLOCKED", "High-risk SQL approval was revoked."));
+ }
+ current.allow_dangerous_sql = true;
+ validate_sql_policy(connection, &current, database, sql, allow_database_switch)?;
+ if !bridge_execution {
+ self.backend
+ .consume_high_risk_sql_approval(&token, &connection.id, database, sql)
+ .await
+ .map_err(|error| tool_error("SQL_BLOCKED", error))?;
+ }
+ Ok((current, Some(token)))
+ }
+
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())
}
@@ -1504,6 +1558,13 @@ impl DbxMcpServer {
return error;
}
}
+ let (policy, approval_token) = match self
+ .approved_sql_policy(connection, &policy, &database, &request.sql, allow_database_switch, false)
+ .await
+ {
+ Ok(approval) => approval,
+ Err(error) => return error,
+ };
let permissions = match validate_sql_policy(connection, &policy, &database, &request.sql, allow_database_switch)
{
Ok(permissions) => permissions,
@@ -1564,12 +1625,15 @@ impl DbxMcpServer {
) {
return error;
}
- let refreshed_policy = effective_policy_for_database_with_groups(
+ let mut refreshed_policy = effective_policy_for_database_with_groups(
&refreshed.policy,
&refreshed.group_ids,
&refreshed.connection,
&session.database,
);
+ if approval_token.is_some() && refreshed_policy.prompt_high_risk_sql && !refreshed_policy.read_only {
+ refreshed_policy.allow_dangerous_sql = true;
+ }
let refreshed_permissions = match validate_sql_policy(
&refreshed.connection,
&refreshed_policy,
@@ -1818,6 +1882,11 @@ impl DbxMcpServer {
// 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 (policy, approval_token) =
+ match self.approved_sql_policy(connection, &policy, &database, sql, allow_database_switch, false).await {
+ Ok(approval) => approval,
+ Err(error) => return error,
+ };
let permissions = match validate_sql_policy(connection, &policy, &database, sql, allow_database_switch) {
Ok(permissions) => permissions,
Err(error) => return error,
@@ -1876,12 +1945,15 @@ impl DbxMcpServer {
{
return error;
}
- let refreshed_policy = effective_policy_for_database_with_groups(
+ let mut refreshed_policy = effective_policy_for_database_with_groups(
&refreshed.policy,
&refreshed.group_ids,
&refreshed.connection,
&session.database,
);
+ if approval_token.is_some() && refreshed_policy.prompt_high_risk_sql && !refreshed_policy.read_only {
+ refreshed_policy.allow_dangerous_sql = true;
+ }
let refreshed_permissions =
match validate_sql_policy(&refreshed.connection, &refreshed_policy, &session.database, sql, false) {
Ok(permissions) => permissions,
@@ -2827,6 +2899,14 @@ impl DbxMcpServer {
return error;
}
}
+ let (policy, approval_token) = if connection.db_type == DatabaseType::MongoDb {
+ (policy, None)
+ } else {
+ match self.approved_sql_policy(connection, &policy, &database, &request.sql, false, true).await {
+ Ok(approval) => approval,
+ Err(error) => return error,
+ }
+ };
let permissions = if connection.db_type == DatabaseType::MongoDb {
mcp_permissions(connection, &policy)
} else {
@@ -2856,6 +2936,7 @@ impl DbxMcpServer {
"connection_name": connection.name,
"sql": request.sql,
"database": database,
+ "approval_token": approval_token,
"allow_writes": permissions.allow_writes,
"allow_dangerous": permissions.allow_dangerous,
}),
@@ -5297,6 +5378,9 @@ mod tests {
transaction_open_error: Option<String>,
policy_override: std::sync::Mutex<Option<McpGlobalPolicy>>,
salesforce_identity: Option<SalesforceCurrentUser>,
+ approved_sql: std::sync::Mutex<Vec<String>>,
+ consumed_sql: std::sync::Mutex<Vec<String>>,
+ revoke_on_approval: bool,
plugin_providers: Vec<crate::plugin_tools::PluginToolProvider>,
plugin_tool_calls: RecordedPluginToolCalls,
}
@@ -5321,6 +5405,9 @@ mod tests {
transaction_open_error: None,
policy_override: std::sync::Mutex::new(None),
salesforce_identity: None,
+ approved_sql: std::sync::Mutex::new(Vec::new()),
+ consumed_sql: std::sync::Mutex::new(Vec::new()),
+ revoke_on_approval: false,
plugin_providers: Vec::new(),
plugin_tool_calls: std::sync::Mutex::new(Vec::new()),
}
@@ -5342,6 +5429,86 @@ mod tests {
.unwrap()
}
+ #[tokio::test]
+ async fn high_risk_sql_approval_is_bound_to_one_execution_and_rechecked() {
+ let sql = "CREATE TABLE approved_test (id INT)";
+ let policy = McpGlobalPolicy { prompt_high_risk_sql: true, ..Default::default() };
+ let conn = connection("mysql", "MySQL", "mysql", "app");
+ let backend =
+ Arc::new(FakeBackend { connections: vec![conn.clone()], policy: policy.clone(), ..Default::default() });
+ let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
+ let (approved, token) = server.approved_sql_policy(&conn, &policy, "app", sql, false, false).await.unwrap();
+ assert!(approved.allow_dangerous_sql);
+ assert_eq!(token.as_deref(), Some("test-approval-token"));
+ assert_eq!(backend.consumed_sql.lock().unwrap().as_slice(), [sql]);
+
+ let replay = server.approved_sql_policy(&conn, &policy, "app", sql, false, false).await.unwrap_err();
+ assert!(result_text(&replay).contains("replayed"));
+
+ let revoked = Arc::new(FakeBackend {
+ connections: vec![conn.clone()],
+ policy: policy.clone(),
+ revoke_on_approval: true,
+ ..Default::default()
+ });
+ let server = DbxMcpServer::with_runtime_options(revoked.clone(), McpScope::default(), false);
+ let error = server.approved_sql_policy(&conn, &policy, "app", sql, false, false).await.unwrap_err();
+ assert!(result_text(&error).contains("revoked"));
+ assert!(revoked.consumed_sql.lock().unwrap().is_empty());
+
+ let read_only = McpGlobalPolicy { read_only: true, ..policy.clone() };
+ let error = server.approved_sql_policy(&conn, &read_only, "app", sql, false, false).await.unwrap_err();
+ assert!(result_text(&error).contains("MCP_READ_ONLY"));
+
+ let mut production = conn.clone();
+ production.is_production = true;
+ let error = server.approved_sql_policy(&production, &policy, "app", sql, false, false).await.unwrap_err();
+ assert!(result_text(&error).contains("PRODUCTION_WRITE_BLOCKED"));
+ }
+
+ #[tokio::test]
+ async fn high_risk_sql_tools_require_and_consume_desktop_approval() {
+ let query_sql = "CREATE TABLE approved_query (id INT)";
+ let batch_sql = "CREATE TABLE approved_batch (id INT); INSERT INTO approved_batch VALUES (1)";
+ let backend = Arc::new(FakeBackend {
+ connections: vec![connection("mysql", "MySQL", "mysql", "app")],
+ policy: McpGlobalPolicy { prompt_high_risk_sql: true, ..Default::default() },
+ ..Default::default()
+ });
+ let server = DbxMcpServer::with_runtime_options(backend.clone(), McpScope::default(), false);
+ let query = || ExecuteQueryRequest {
+ selector: selector("mysql"),
+ database: None,
+ sql: query_sql.to_string(),
+ session_id: None,
+ cell_char_offset: None,
+ cell_char_limit: None,
+ max_rows: None,
+ };
+
+ assert_eq!(result_text(&server.execute_query(Parameters(query())).await), "ok");
+ let replay = server.execute_query(Parameters(query())).await;
+ assert!(result_text(&replay).contains("replayed"));
+
+ let batch = server
+ .execute_batch(Parameters(ExecuteBatchQueryRequest {
+ selector: selector("mysql"),
+ cell_window: CellWindowArgs::default(),
+ database: None,
+ sql: batch_sql.to_string(),
+ session_id: None,
+ continue_on_error: None,
+ use_transaction: None,
+ }))
+ .await;
+ assert!(!batch.is_error.unwrap_or(false), "{}", result_text(&batch));
+ assert_eq!(backend.approved_sql.lock().unwrap().as_slice(), [query_sql, query_sql, batch_sql]);
+ assert_eq!(backend.consumed_sql.lock().unwrap().as_slice(), [query_sql, batch_sql]);
+ let recorded = backend.recorded_arguments.lock().unwrap();
+ assert_eq!(recorded.iter().filter(|(name, _)| name == "execute_query").count(), 1);
+ assert_eq!(recorded.iter().filter(|(name, _)| name == "execute_batch").count(), 1);
+ }
+
fn resolved_connection_for_test(connection: ConnectionConfig) -> ResolvedConnection {
ResolvedConnection {
connection,
@@ -5365,6 +5532,34 @@ mod tests {
#[async_trait]
impl DbxBackend for FakeBackend {
+ async fn approve_high_risk_sql(
+ &self,
+ _connection_id: &str,
+ _database: &str,
+ sql: &str,
+ ) -> Result<String, String> {
+ self.approved_sql.lock().unwrap().push(sql.to_string());
+ if self.revoke_on_approval {
+ *self.policy_override.lock().unwrap() =
+ Some(McpGlobalPolicy { read_only: true, ..self.policy.clone() });
+ }
+ Ok("test-approval-token".to_string())
+ }
+
+ async fn consume_high_risk_sql_approval(
+ &self,
+ token: &str,
+ _connection_id: &str,
+ _database: &str,
+ sql: &str,
+ ) -> Result<(), String> {
+ if token != "test-approval-token" || self.consumed_sql.lock().unwrap().contains(&sql.to_string()) {
+ return Err("SQL_BLOCKED: Invalid or replayed approval".to_string());
+ }
+ self.consumed_sql.lock().unwrap().push(sql.to_string());
+ Ok(())
+ }
+
async fn save_history_entry(&self, entry: &dbx_core::history::HistoryEntry) -> Result<(), String> {
self.history.lock().unwrap().push(entry.clone());
Ok(())
diff --git a/src-tauri/src/commands/app_settings.rs b/src-tauri/src/commands/app_settings.rs
index 8083e969c4..f605b09aeb 100644
--- a/src-tauri/src/commands/app_settings.rs
+++ b/src-tauri/src/commands/app_settings.rs
@@ -212,7 +212,9 @@ pub async fn load_mcp_global_policy(state: State<'_, Arc<AppState>>) -> Result<M
#[tauri::command]
pub async fn save_mcp_global_policy(state: State<'_, Arc<AppState>>, policy: McpGlobalPolicy) -> Result<(), String> {
- state.storage.save_mcp_global_policy(&policy).await
+ state.storage.save_mcp_global_policy(&policy).await?;
+ super::mcp_bridge::clear_mcp_sql_approvals();
+ Ok(())
}
#[tauri::command]
diff --git a/src-tauri/src/commands/mcp_bridge.rs b/src-tauri/src/commands/mcp_bridge.rs
index 8866b1e3af..e49e0eca68 100644
--- a/src-tauri/src/commands/mcp_bridge.rs
+++ b/src-tauri/src/commands/mcp_bridge.rs
@@ -1,10 +1,12 @@
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::{Duration, Instant};
use tauri::{AppHandle, Emitter};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
+use tokio::sync::oneshot;
use super::connection::AppState;
@@ -32,6 +34,115 @@ struct ExecuteQueryRequest {
database: Option<String>,
sql: String,
schema: Option<String>,
+ approval_token: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct SqlApprovalRequest {
+ connection_id: String,
+ database: String,
+ sql: String,
+}
+
+#[derive(Deserialize)]
+struct ConsumeSqlApprovalRequest {
+ token: String,
+ connection_id: String,
+ database: String,
+ sql: String,
+}
+
+#[derive(Clone, Serialize)]
+struct SqlApprovalEvent {
+ id: String,
+ connection_name: String,
+ database: String,
+ sql: String,
+}
+
+#[derive(Clone, Copy)]
+enum SqlApprovalDecision {
+ Once,
+ Hour,
+ Day,
+ Deny,
+}
+
+struct SqlApprovalGrant {
+ connection: crate::models::connection::ConnectionConfig,
+ database: String,
+ sql: String,
+ expires_at: Instant,
+}
+
+struct TimedSqlApproval {
+ connection: crate::models::connection::ConnectionConfig,
+ expires_at: Instant,
+}
+
+impl TimedSqlApproval {
+ fn valid_for(&self, connection: &crate::models::connection::ConnectionConfig, now: Instant) -> bool {
+ self.expires_at > now && self.connection == *connection
+ }
+}
+
+#[derive(Default)]
+struct SqlApprovals {
+ generation: u64,
+ pending: HashMap<String, oneshot::Sender<SqlApprovalDecision>>,
+ tokens: HashMap<String, SqlApprovalGrant>,
+ timed: HashMap<(String, String), TimedSqlApproval>,
+}
+
+static SQL_APPROVALS: OnceLock<Mutex<SqlApprovals>> = OnceLock::new();
+
+fn sql_approvals() -> &'static Mutex<SqlApprovals> {
+ SQL_APPROVALS.get_or_init(|| Mutex::new(SqlApprovals::default()))
+}
+
+pub(crate) fn clear_mcp_sql_approvals() {
+ if let Ok(mut approvals) = sql_approvals().lock() {
+ approvals.generation = approvals.generation.wrapping_add(1);
+ approvals.timed.clear();
+ approvals.tokens.clear();
+ approvals.pending.clear();
+ }
+}
+
+#[tauri::command]
+pub fn respond_mcp_sql_approval(window: tauri::Window, id: String, decision: String) -> Result<(), String> {
+ if window.label() != "main" {
+ return Err("Only the main DBX window can approve MCP SQL.".to_string());
+ }
+ let decision = match decision.as_str() {
+ "once" => SqlApprovalDecision::Once,
+ "hour" => SqlApprovalDecision::Hour,
+ "day" => SqlApprovalDecision::Day,
+ "deny" => SqlApprovalDecision::Deny,
+ _ => return Err("Invalid MCP SQL approval decision.".to_string()),
+ };
+ let sender = sql_approvals()
+ .lock()
+ .map_err(|_| "MCP approval state unavailable")?
+ .pending
+ .remove(&id)
+ .ok_or_else(|| "MCP approval request expired.".to_string())?;
+ sender.send(decision).map_err(|_| "MCP approval request expired.".to_string())
+}
+
+fn take_sql_approval(
+ token: Option<&str>,
+ connection: &crate::models::connection::ConnectionConfig,
+ database: &str,
+ sql: &str,
+) -> bool {
+ let Some(token) = token else { return false };
+ let Ok(mut state) = sql_approvals().lock() else { return false };
+ let Some(grant) = state.tokens.remove(token) else { return false };
+ grant.expires_at > Instant::now()
+ && grant.connection == *connection
+ && grant.database == database
+ && grant.sql == sql
}
#[derive(Deserialize)]
@@ -276,6 +387,10 @@ pub fn start(app_handle: AppHandle, state: Arc<AppState>, data_dir: PathBuf) {
handle_redis_execute_command_data(&st, body, &mut stream).await;
} else if first_line.starts_with("POST /data/execute-query") {
handle_execute_query_data(&st, body, &mut stream).await;
+ } else if first_line.starts_with("POST /approve-high-risk-sql") {
+ handle_sql_approval(&app, &st, body, &mut stream).await;
+ } else if first_line.starts_with("POST /consume-high-risk-sql-approval") {
+ handle_consume_sql_approval(&st, body, &mut stream).await;
} else if first_line.starts_with("POST /execute-query") {
handle_execute_query(&app, &st, body, &mut stream).await;
} else if first_line.starts_with("POST /reload-connections") {
@@ -415,17 +530,65 @@ fn find_config_by_name<'a>(
#[cfg(test)]
mod tests {
use super::{
- bridge_request_is_local_client, effective_database_execution_policy, ensure_connection_in_mcp_scope,
- ensure_mcp_connection_sql_write_allowed, ensure_mcp_execute_and_show_supported,
+ bridge_request_is_local_client, clear_mcp_sql_approvals, effective_database_execution_policy,
+ ensure_connection_in_mcp_scope, ensure_mcp_connection_sql_write_allowed, ensure_mcp_execute_and_show_supported,
ensure_mcp_mongo_pipeline_target_allowed_by_id, ensure_mcp_sql_database_switch_allowed,
is_terminal_routed_exec, mongo_filter_is_effectively_unbounded, mongo_pipeline_has_write_stage,
parse_content_length, plugin_connection_summaries, plugin_connection_summary, read_bridge_request,
resolve_call_plugin_target, resolve_connection, resolve_mongo_database, resolve_mongo_target_values,
- write_port_file, AppState,
+ sql_approvals, take_sql_approval, write_port_file, AppState, SqlApprovalGrant, TimedSqlApproval,
};
use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
use dbx_core::storage::{McpConnectionPolicy, McpDatabasePolicy, McpDatabaseScope, McpGlobalPolicy};
use std::sync::Arc;
+ use std::time::{Duration, Instant};
+
+ #[test]
+ fn sql_approval_token_is_single_use_and_bound_to_target_and_text() {
+ let token = uuid::Uuid::new_v4().to_string();
+ let mut config = mysql_config(false);
+ config.id = "mysql".to_string();
+ let insert = |expires_at| {
+ sql_approvals().lock().unwrap().tokens.insert(
+ token.clone(),
+ SqlApprovalGrant {
+ connection: config.clone(),
+ database: "app".to_string(),
+ sql: "DROP TABLE t".to_string(),
+ expires_at,
+ },
+ );
+ };
+ insert(Instant::now() + Duration::from_secs(60));
+ assert!(!take_sql_approval(Some(&token), &config, "other", "DROP TABLE t"));
+ assert!(!take_sql_approval(Some(&token), &config, "app", "DROP TABLE t"));
+ insert(Instant::now() - Duration::from_secs(1));
+ assert!(!take_sql_approval(Some(&token), &config, "app", "DROP TABLE t"));
+ insert(Instant::now() + Duration::from_secs(60));
+ let mut changed = config.clone();
+ changed.host = "other-host".to_string();
+ assert!(!take_sql_approval(Some(&token), &changed, "app", "DROP TABLE t"));
+ insert(Instant::now() + Duration::from_secs(60));
+ assert!(take_sql_approval(Some(&token), &config, "app", "DROP TABLE t"));
+ assert!(!take_sql_approval(Some(&token), &config, "app", "DROP TABLE t"));
+ insert(Instant::now() + Duration::from_secs(60));
+ let generation = sql_approvals().lock().unwrap().generation;
+ clear_mcp_sql_approvals();
+ assert_ne!(sql_approvals().lock().unwrap().generation, generation);
+ assert!(!take_sql_approval(Some(&token), &config, "app", "DROP TABLE t"));
+ }
+
+ #[test]
+ fn timed_sql_approval_does_not_follow_a_connection_edit() {
+ let config = mysql_config(false);
+ let grant =
+ TimedSqlApproval { connection: config.clone(), expires_at: Instant::now() + Duration::from_secs(60) };
+ assert!(grant.valid_for(&config, Instant::now()));
+ let mut changed = config.clone();
+ changed.host = "other-host".to_string();
+ assert!(!grant.valid_for(&changed, Instant::now()));
+ assert!(!grant.valid_for(&config, grant.expires_at));
+ }
fn mysql_config(read_only: bool) -> ConnectionConfig {
serde_json::from_value(serde_json::json!({
@@ -1459,6 +1622,16 @@ async fn ensure_mcp_sql_allowed(
config: &crate::models::connection::ConnectionConfig,
database: &str,
sql: &str,
+) -> Result<(), String> {
+ ensure_mcp_sql_allowed_with_approval(state, config, database, sql, false).await
+}
+
+async fn ensure_mcp_sql_allowed_with_approval(
+ state: &Arc<AppState>,
+ config: &crate::models::connection::ConnectionConfig,
+ database: &str,
+ sql: &str,
+ approved: bool,
) -> Result<(), String> {
let (policy, group_paths) = load_mcp_policy_context(state).await?;
let group_path = group_paths.get(&config.id);
@@ -1480,7 +1653,10 @@ async fn ensure_mcp_sql_allowed(
}
}
ensure_mcp_sql_database_switch_allowed(config.db_type, sql)?;
- let is_write = dbx_core::query_execution_sql::is_write_sql_for_database(sql, config.db_type);
+ let risk = dbx_core::sql_risk::classify_sql_risk_for_database(sql, config.db_type)
+ .map_err(|error| format!("SQL_BLOCKED: {error}"))?;
+ let is_write = risk != dbx_core::sql_risk::SqlRisk::ReadOnly
+ || dbx_core::query_execution_sql::is_write_sql_for_database(sql, config.db_type);
dbx_core::mcp_policy::ensure_sql_database_execution_scope(&policy, config, database, sql)?;
let group_ids = group_path.map(|path| path.ids.as_slice()).unwrap_or_default();
let (read_only, allow_dangerous_sql) =
@@ -1490,7 +1666,11 @@ async fn ensure_mcp_sql_allowed(
"MCP_READ_ONLY: MCP execution permission for database '{database}' is read-only. SQL write blocked."
));
}
- if !allow_dangerous_sql && dbx_core::sql_risk::is_dangerous_sql_for_database(sql, config.db_type) {
+ if !allow_dangerous_sql
+ && (risk == dbx_core::sql_risk::SqlRisk::Ddl
+ || dbx_core::sql_risk::is_dangerous_sql_for_database(sql, config.db_type))
+ && !(approved && policy.prompt_high_risk_sql && !read_only)
+ {
return Err("SQL_BLOCKED: High-risk SQL is disabled in DBX MCP settings.".to_string());
}
ensure_mcp_connection_sql_write_allowed(config, is_write)?;
@@ -1500,6 +1680,184 @@ async fn ensure_mcp_sql_allowed(
Ok(())
}
+async fn handle_sql_approval(app: &AppHandle, state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+ let req: SqlApprovalRequest = match serde_json::from_str(body) {
+ Ok(req) => req,
+ Err(_) => {
+ respond_error(stream, "400 Bad Request", "Invalid approval request").await;
+ return;
+ }
+ };
+ let config = match resolve_connection(state, Some(&req.connection_id), "").await {
+ Ok(config) => config,
+ Err(error) => {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ };
+ // A prompt must not be offered for an operation that cannot be executed
+ // even with high-risk permission (scope, read-only, or production).
+ let (policy, group_paths) = match load_mcp_policy_context(state).await {
+ Ok(context) => context,
+ Err(error) => {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ };
+ let group_ids = group_paths.get(&config.id).map(|path| path.ids.as_slice()).unwrap_or_default();
+ let (read_only, allow_dangerous) =
+ effective_database_execution_policy_with_groups(&policy, group_ids, &config.id, &req.database);
+ if !policy.prompt_high_risk_sql
+ || read_only
+ || allow_dangerous
+ || !(dbx_core::sql_risk::classify_sql_risk_for_database(&req.sql, config.db_type)
+ .is_ok_and(|risk| risk == dbx_core::sql_risk::SqlRisk::Ddl)
+ || dbx_core::sql_risk::is_dangerous_sql_for_database(&req.sql, config.db_type))
+ {
+ respond_error(stream, "403 Forbidden", "SQL_BLOCKED: High-risk SQL approval is unavailable.").await;
+ return;
+ }
+ if let Err(error) = ensure_mcp_sql_allowed_with_approval(state, &config, &req.database, &req.sql, true).await {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ let key = (config.id.clone(), req.database.clone());
+ let now = Instant::now();
+ let existing = (|| {
+ let mut approvals = sql_approvals().lock().map_err(|_| ())?;
+ approvals
+ .timed
+ .retain(|grant_key, grant| grant.expires_at > now && (grant_key != &key || grant.valid_for(&config, now)));
+ Ok::<_, ()>((approvals.timed.contains_key(&key).then_some(SqlApprovalDecision::Hour), approvals.generation))
+ })();
+ let (decision, generation) = match existing {
+ Ok(existing) => existing,
+ Err(()) => {
+ respond_error(stream, "500 Internal Server Error", "MCP approval state unavailable").await;
+ return;
+ }
+ };
+ let decision = if let Some(decision) = decision {
+ decision
+ } else {
+ let id = uuid::Uuid::new_v4().to_string();
+ let (sender, receiver) = oneshot::channel();
+ let queued = (|| {
+ let mut approvals =
+ sql_approvals().lock().map_err(|_| ("500 Internal Server Error", "MCP approval state unavailable"))?;
+ if approvals.pending.len() >= 16 {
+ return Err(("429 Too Many Requests", "Too many pending MCP approvals"));
+ }
+ approvals.pending.insert(id.clone(), sender);
+ Ok::<_, (&str, &str)>(())
+ })();
+ if let Err((status, message)) = queued {
+ respond_error(stream, status, message).await;
+ return;
+ }
+ let event = SqlApprovalEvent {
+ id: id.clone(),
+ connection_name: config.name.clone(),
+ database: req.database.clone(),
+ sql: req.sql.clone(),
+ };
+ if app.emit_to("main", "mcp-sql-approval", event).is_err() {
+ sql_approvals().lock().ok().map(|mut approvals| approvals.pending.remove(&id));
+ respond_error(stream, "503 Service Unavailable", "DBX approval window unavailable").await;
+ return;
+ }
+ let answer = tokio::time::timeout(Duration::from_secs(90), receiver).await;
+ sql_approvals().lock().ok().map(|mut approvals| approvals.pending.remove(&id));
+ match answer {
+ Ok(Ok(decision)) => decision,
+ _ => {
+ respond_error(stream, "403 Forbidden", "SQL_BLOCKED: MCP approval timed out.").await;
+ return;
+ }
+ }
+ };
+ if matches!(decision, SqlApprovalDecision::Deny) {
+ respond_error(stream, "403 Forbidden", "SQL_BLOCKED: MCP approval denied.").await;
+ return;
+ }
+ // Re-read mutable policy after the person responds. Revocation wins.
+ let current = match resolve_connection(state, Some(&config.id), "").await {
+ Ok(current) => current,
+ Err(error) => {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ };
+ if current != config {
+ respond_error(stream, "403 Forbidden", "SQL_BLOCKED: Connection changed while awaiting approval.").await;
+ return;
+ }
+ if let Err(error) = ensure_mcp_sql_allowed_with_approval(state, &current, &req.database, &req.sql, true).await {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ let token = uuid::Uuid::new_v4().to_string();
+ let grant_result = (|| -> Result<(), &'static str> {
+ let mut approvals = sql_approvals().lock().map_err(|_| "MCP approval state unavailable")?;
+ if approvals.generation != generation {
+ return Err("SQL_BLOCKED: Approval revoked by policy change.");
+ }
+ if let Some(duration) = match decision {
+ SqlApprovalDecision::Hour => Some(Duration::from_secs(3600)),
+ SqlApprovalDecision::Day => Some(Duration::from_secs(86400)),
+ _ => None,
+ } {
+ // Do not renew an existing grant on use.
+ approvals.timed.entry(key).or_insert_with(|| TimedSqlApproval {
+ connection: config.clone(),
+ expires_at: Instant::now() + duration,
+ });
+ }
+ approvals.tokens.retain(|_, grant| grant.expires_at > Instant::now());
+ approvals.tokens.insert(
+ token.clone(),
+ SqlApprovalGrant {
+ connection: config,
+ database: req.database,
+ sql: req.sql,
+ expires_at: Instant::now() + Duration::from_secs(90),
+ },
+ );
+ Ok(())
+ })();
+ if let Err(error) = grant_result {
+ respond_error(stream, "403 Forbidden", error).await;
+ return;
+ }
+ respond_json(stream, &serde_json::json!({ "token": token })).await;
+}
+
+async fn handle_consume_sql_approval(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+ let req: ConsumeSqlApprovalRequest = match serde_json::from_str(body) {
+ Ok(req) => req,
+ Err(_) => {
+ respond_error(stream, "400 Bad Request", "Invalid approval request").await;
+ return;
+ }
+ };
+ let config = match resolve_connection(state, Some(&req.connection_id), "").await {
+ Ok(config) => config,
+ Err(error) => {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ };
+ if !take_sql_approval(Some(&req.token), &config, &req.database, &req.sql) {
+ respond_error(stream, "403 Forbidden", "SQL_BLOCKED: Approval expired or does not match this request.").await;
+ return;
+ }
+ if let Err(error) = ensure_mcp_sql_allowed_with_approval(state, &config, &req.database, &req.sql, true).await {
+ respond_error(stream, "403 Forbidden", &error).await;
+ return;
+ }
+ respond_json(stream, &serde_json::json!({ "ok": true })).await;
+}
+
fn ensure_mcp_sql_database_switch_allowed(
database_type: crate::models::connection::DatabaseType,
sql: &str,
@@ -1831,7 +2189,8 @@ async fn handle_execute_query(app: &AppHandle, state: &Arc<AppState>, body: &str
// Check the complete batch first so a session-changing statement cannot
// hide a later production write, then recheck every statement immediately
// before it reaches the database.
- if let Err(e) = ensure_mcp_sql_allowed(state, &config, &database, &req.sql).await {
+ let approved = take_sql_approval(req.approval_token.as_deref(), &config, &database, &req.sql);
+ if let Err(e) = ensure_mcp_sql_allowed_with_approval(state, &config, &database, &req.sql, approved).await {
respond(stream, "403 Forbidden", &e).await;
return;
}
@@ -1850,7 +2209,7 @@ async fn handle_execute_query(app: &AppHandle, state: &Arc<AppState>, body: &str
return;
}
};
- if let Err(e) = ensure_mcp_sql_allowed(state, &current, &database, &statement).await {
+ if let Err(e) = ensure_mcp_sql_allowed_with_approval(state, &current, &database, &statement, approved).await {
respond(stream, "403 Forbidden", &e).await;
return;
}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 24e84eef3d..96c8b1d070 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1914,6 +1914,7 @@ pub fn run() {
commands::app_settings::save_pinned_tree_node_ids,
commands::app_settings::load_mcp_global_policy,
commands::app_settings::save_mcp_global_policy,
+ commands::mcp_bridge::respond_mcp_sql_approval,
commands::background_image::save_background_image,
commands::background_image::clear_background_image,
commands::background_image::read_background_image,