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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(mcp): prompt in desktop before high-risk SQL
ccq7407f12d0747
diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vueindex 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" /><QueryEditorObjectSourceDialogv-if="queryEditorObjectSourceTarget"v-model:open="showQueryEditorObjectSourceDialog"diff --git a/apps/desktop/src/components/editor/EditorSettingsDialog.vue b/apps/desktop/src/components/editor/EditorSettingsDialog.vueindex 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.vuenew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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> | nullreturn {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.rsindex 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.rsindex 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.rsindex 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, ¤t, 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.rsindex 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.rsindex 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, ¤t, &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: &strreturn;}};- if let Err(e) = ensure_mcp_sql_allowed(state, ¤t, &database, &statement).await {+ if let Err(e) = ensure_mcp_sql_allowed_with_approval(state, ¤t, &database, &statement, approved).await {respond(stream, "403 Forbidden", &e).await;return;}diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 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,