From 6e0f4e1dc3862edf78f5e128fa8463f2c6881123 Mon Sep 17 00:00:00 2001
From: t8y2 <1156263951@qq.com>
Date: Tue, 26 May 2026 01:23:26 +0800
Subject: [PATCH] feat: enable driver management on web version

- Extract JDBC driver/plugin logic from Tauri commands to dbx-core::jdbc
- Add web API routes for JDBC drivers, JDBC plugin, Agent JAR import, system fonts
- Upgrade zip crate from v2 to v4 in dbx-core
- Replace http.ts stubs with real HTTP calls (support File and string paths)
- Remove isWeb restrictions in DriverStoreDialog, add browser file picker support
- Fix Mac traffic light inset incorrectly applied on web version
- Show driver management toolbar button on web version
---
 Cargo.lock                                    |  20 +-
 .../components/config/DriverStoreDialog.vue   |  84 ++++-
 .../src/components/layout/AppToolbar.vue      |   3 +-
 .../src/composables/useWindowControls.ts      |   4 +-
 apps/desktop/src/lib/http.ts                  |  74 ++--
 crates/dbx-core/Cargo.toml                    |   3 +-
 crates/dbx-core/src/jdbc.rs                   | 341 ++++++++++++++++++
 crates/dbx-core/src/lib.rs                    |   1 +
 crates/dbx-web/src/error.rs                   |  10 +
 crates/dbx-web/src/main.rs                    |  10 +
 crates/dbx-web/src/routes/agents.rs           |  34 ++
 crates/dbx-web/src/routes/jdbc.rs             | 100 +++++
 crates/dbx-web/src/routes/mod.rs              |   1 +
 src-tauri/src/commands/plugins.rs             | 290 +--------------
 src-tauri/src/commands/system_fonts.rs        |  34 +-
 15 files changed, 635 insertions(+), 374 deletions(-)
 create mode 100644 crates/dbx-core/src/jdbc.rs
 create mode 100644 crates/dbx-web/src/routes/jdbc.rs

diff --git a/Cargo.lock b/Cargo.lock
index e30cd95543..9a6228fe80 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1842,6 +1842,7 @@ dependencies = [
  "csv",
  "deadpool-postgres",
  "duckdb",
+ "font-kit",
  "futures",
  "iana-time-zone",
  "log",
@@ -1866,7 +1867,7 @@ dependencies = [
  "tokio-util",
  "uuid",
  "webpki-roots 0.26.11",
- "zip 2.4.2",
+ "zip 4.6.1",
 ]
 
 [[package]]
@@ -10137,23 +10138,6 @@ dependencies = [
  "syn 2.0.117",
 ]
 
-[[package]]
-name = "zip"
-version = "2.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
-dependencies = [
- "arbitrary",
- "crc32fast",
- "crossbeam-utils",
- "displaydoc",
- "flate2",
- "indexmap 2.14.0",
- "memchr",
- "thiserror 2.0.18",
- "zopfli",
-]
-
 [[package]]
 name = "zip"
 version = "4.6.1"
diff --git a/apps/desktop/src/components/config/DriverStoreDialog.vue b/apps/desktop/src/components/config/DriverStoreDialog.vue
index f466813a07..9977334eda 100644
--- a/apps/desktop/src/components/config/DriverStoreDialog.vue
+++ b/apps/desktop/src/components/config/DriverStoreDialog.vue
@@ -273,6 +273,34 @@ function chooseWebOfflineZip(): Promise<File | null> {
   });
 }
 
+function chooseWebFiles(accept: string, multiple: boolean): Promise<File[] | null> {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = accept;
+    input.multiple = multiple;
+    input.onchange = () => {
+      const files = input.files;
+      if (!files || files.length === 0) {
+        resolve(null);
+        return;
+      }
+      resolve(Array.from(files));
+    };
+    input.click();
+  });
+}
+
+function chooseWebFile(accept: string): Promise<File | null> {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = accept;
+    input.onchange = () => resolve(input.files?.[0] ?? null);
+    input.click();
+  });
+}
+
 async function importOfflineZip() {
   if (importingZip.value) return;
   let selected: string | File | null = null;
@@ -303,7 +331,19 @@ async function importOfflineZip() {
 }
 
 async function importDriverJar(dbType: string) {
-  if (isWeb) return;
+  const label = drivers.value.find((d) => d.db_type === dbType)?.label ?? dbType;
+  if (isWeb) {
+    const file = await chooseWebFile(".jar");
+    if (!file) return;
+    try {
+      await api.importAgentJar(dbType, file);
+      await refreshAgents();
+      toast(`${label} 驱动导入成功`);
+    } catch (e: any) {
+      toast(`${label} 驱动导入失败: ${e}`);
+    }
+    return;
+  }
   const { open } = await import("@tauri-apps/plugin-dialog");
   const selected = await open({
     title: "选择驱动 JAR 文件",
@@ -311,7 +351,6 @@ async function importDriverJar(dbType: string) {
     filters: [{ name: "JAR", extensions: ["jar"] }],
   });
   if (typeof selected !== "string") return;
-  const label = drivers.value.find((d) => d.db_type === dbType)?.label ?? dbType;
   try {
     await api.importAgentJar(dbType, selected);
     await refreshAgents();
@@ -373,7 +412,6 @@ function jreUsageLabel(key: string) {
 }
 
 async function loadJdbcDrivers() {
-  if (isWeb) return;
   isLoadingJdbcDrivers.value = true;
   try {
     jdbcDrivers.value = await api.listJdbcDrivers();
@@ -394,7 +432,6 @@ async function loadDriverStoreUsage() {
 }
 
 async function loadJdbcPluginStatus() {
-  if (isWeb) return;
   try {
     jdbcPluginStatus.value = await api.jdbcPluginStatus();
     emitDriverUpdateCount();
@@ -404,7 +441,7 @@ async function loadJdbcPluginStatus() {
 }
 
 async function installJdbcPlugin() {
-  if (isWeb || isInstallingJdbcPlugin.value) return;
+  if (isInstallingJdbcPlugin.value) return;
   isInstallingJdbcPlugin.value = true;
   try {
     jdbcPluginStatus.value = await api.installJdbcPlugin();
@@ -419,14 +456,20 @@ async function installJdbcPlugin() {
 }
 
 async function installJdbcPluginLocal() {
-  if (isWeb || isInstallingJdbcPlugin.value) return;
-  const { open } = await import("@tauri-apps/plugin-dialog");
-  const selected = await open({
-    title: "选择 JDBC 插件 zip 文件",
-    multiple: false,
-    filters: [{ name: "ZIP", extensions: ["zip"] }],
-  });
-  if (typeof selected !== "string") return;
+  if (isInstallingJdbcPlugin.value) return;
+  let selected: string | File | null = null;
+  if (isWeb) {
+    selected = await chooseWebFile(".zip");
+  } else {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const result = await open({
+      title: "选择 JDBC 插件 zip 文件",
+      multiple: false,
+      filters: [{ name: "ZIP", extensions: ["zip"] }],
+    });
+    selected = typeof result === "string" ? result : null;
+  }
+  if (!selected) return;
   isInstallingJdbcPlugin.value = true;
   try {
     jdbcPluginStatus.value = await api.installJdbcPluginLocal(selected);
@@ -441,7 +484,7 @@ async function installJdbcPluginLocal() {
 }
 
 async function uninstallJdbcPlugin() {
-  if (isWeb || isUninstallingJdbcPlugin.value) return;
+  if (isUninstallingJdbcPlugin.value) return;
   isUninstallingJdbcPlugin.value = true;
   try {
     jdbcPluginStatus.value = await api.uninstallJdbcPlugin();
@@ -468,7 +511,18 @@ async function importJdbcDriverPaths(paths: string[]) {
 }
 
 async function importJdbcDrivers() {
-  if (isWeb) return;
+  if (isWeb) {
+    const files = await chooseWebFiles(".jar", true);
+    if (!files || !files.length) return;
+    try {
+      jdbcDrivers.value = await api.importJdbcDrivers(files);
+      void loadDriverStoreUsage();
+      toast(t("settings.jdbcImportSuccess", { count: files.length }));
+    } catch (e: any) {
+      toast(String(e?.message || e), 5000);
+    }
+    return;
+  }
   const { open } = await import("@tauri-apps/plugin-dialog");
   const selected = await open({
     title: t("settings.jdbcImport"),
diff --git a/apps/desktop/src/components/layout/AppToolbar.vue b/apps/desktop/src/components/layout/AppToolbar.vue
index 77b066c3f6..8fe3f926bf 100644
--- a/apps/desktop/src/components/layout/AppToolbar.vue
+++ b/apps/desktop/src/components/layout/AppToolbar.vue
@@ -82,7 +82,7 @@ function onToolbarDblClick(e: MouseEvent) {
 <template>
   <div
     class="h-10 flex items-center gap-1 px-2 border-b bg-muted/30 shrink-0"
-    :class="{ 'pl-17.5': shouldReserveMacTrafficLightInset(isMac, isFullscreen) }"
+    :class="{ 'pl-17.5': shouldReserveMacTrafficLightInset(isMac, isFullscreen, isDesktop) }"
     data-tauri-drag-region
     @dblclick="onToolbarDblClick"
   >
@@ -147,7 +147,6 @@ function onToolbarDblClick(e: MouseEvent) {
     </Button>
 
     <Button
-      v-if="isDesktop"
       variant="ghost"
       size="sm"
       class="h-8 px-2 text-xs gap-1"
diff --git a/apps/desktop/src/composables/useWindowControls.ts b/apps/desktop/src/composables/useWindowControls.ts
index f9b84d72e6..aa1d6cd05b 100644
--- a/apps/desktop/src/composables/useWindowControls.ts
+++ b/apps/desktop/src/composables/useWindowControls.ts
@@ -2,8 +2,8 @@ import { ref, onMounted, onUnmounted } from "vue";
 import { isTauriRuntime } from "@/lib/tauriRuntime";
 import { isMacOS } from "@/lib/platform";
 
-export function shouldReserveMacTrafficLightInset(isMac: boolean, isFullscreen: boolean): boolean {
-  return isMac && !isFullscreen;
+export function shouldReserveMacTrafficLightInset(isMac: boolean, isFullscreen: boolean, isDesktop: boolean): boolean {
+  return isDesktop && isMac && !isFullscreen;
 }
 
 export function useWindowControls() {
diff --git a/apps/desktop/src/lib/http.ts b/apps/desktop/src/lib/http.ts
index a05b6c0279..f86f978830 100644
--- a/apps/desktop/src/lib/http.ts
+++ b/apps/desktop/src/lib/http.ts
@@ -151,7 +151,7 @@ export async function loadConnections(): Promise<ConnectionConfig[]> {
 }
 
 export async function listSystemFonts(): Promise<string[]> {
-  return [];
+  return get("/api/system/fonts");
 }
 
 export async function listPlugins(): Promise<InstalledPlugin[]> {
@@ -159,40 +159,57 @@ export async function listPlugins(): Promise<InstalledPlugin[]> {
 }
 
 export async function listJdbcDrivers(): Promise<JdbcDriverInfo[]> {
-  return [];
+  return get("/api/jdbc/drivers");
 }
 
-export async function importJdbcDrivers(_paths: string[]): Promise<JdbcDriverInfo[]> {
-  return [];
+export async function importJdbcDrivers(pathsOrFiles: (string | File)[]): Promise<JdbcDriverInfo[]> {
+  const formData = new FormData();
+  for (const item of pathsOrFiles) {
+    if (item instanceof File) {
+      formData.append("files", item, item.name);
+    } else {
+      const fileName = item.split("/").pop() || "driver.jar";
+      const blob = await (await fetch(item)).blob();
+      formData.append("files", blob, fileName);
+    }
+  }
+  const res = await fetch("/api/jdbc/drivers", { method: "POST", body: formData });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
 }
 
-export async function deleteJdbcDriver(_path: string): Promise<JdbcDriverInfo[]> {
-  return [];
+export async function deleteJdbcDriver(path: string): Promise<JdbcDriverInfo[]> {
+  const fileName = path.split("/").pop() || path;
+  return del(`/api/jdbc/drivers/${encodeURIComponent(fileName)}`);
 }
 
 export async function jdbcPluginStatus(): Promise<JdbcPluginStatus> {
-  return {
-    installed: false,
-    version: null,
-    protocol_version: null,
-    compatible: true,
-    latest_version: null,
-    latest_protocol_version: null,
-    update_available: false,
-    path: "",
-  };
+  return get("/api/jdbc/plugin/status");
 }
 
 export async function installJdbcPlugin(): Promise<JdbcPluginStatus> {
-  return jdbcPluginStatus();
+  return post("/api/jdbc/plugin/install", {});
 }
 
-export async function installJdbcPluginLocal(_path: string): Promise<JdbcPluginStatus> {
-  return jdbcPluginStatus();
+export async function installJdbcPluginLocal(pathOrFile: string | File): Promise<JdbcPluginStatus> {
+  let blob: Blob;
+  let fileName: string;
+  if (pathOrFile instanceof File) {
+    blob = pathOrFile;
+    fileName = pathOrFile.name;
+  } else {
+    fileName = pathOrFile.split("/").pop() || "plugin.zip";
+    blob = await (await fetch(pathOrFile)).blob();
+  }
+  const formData = new FormData();
+  formData.append("file", blob, fileName);
+  const uploadRes = await fetch("/api/jdbc/plugin/install-local", { method: "POST", body: formData });
+  if (!uploadRes.ok) throw new Error(await uploadRes.text());
+  return uploadRes.json();
 }
 
 export async function uninstallJdbcPlugin(): Promise<JdbcPluginStatus> {
-  return jdbcPluginStatus();
+  return post("/api/jdbc/plugin/uninstall", {});
 }
 
 export async function listInstalledAgentsLocal(): Promise<AgentDriverInfo[]> {
@@ -244,8 +261,21 @@ export async function importAgentsFromZip(fileOrPath: string | File): Promise<nu
   return result.count;
 }
 
-export async function importAgentJar(_dbType: string, _path: string): Promise<void> {
-  throw new Error("Local JAR import is only available in the desktop app");
+export async function importAgentJar(dbType: string, pathOrFile: string | File): Promise<void> {
+  let blob: Blob;
+  let fileName: string;
+  if (pathOrFile instanceof File) {
+    blob = pathOrFile;
+    fileName = pathOrFile.name;
+  } else {
+    fileName = pathOrFile.split("/").pop() || "driver.jar";
+    blob = await (await fetch(pathOrFile)).blob();
+  }
+  const formData = new FormData();
+  formData.append("dbType", dbType);
+  formData.append("file", blob, fileName);
+  const uploadRes = await fetch("/api/agents/import-jar", { method: "POST", body: formData });
+  if (!uploadRes.ok) throw new Error(await uploadRes.text());
 }
 
 export async function reinstallJre(jreKey?: string): Promise<void> {
diff --git a/crates/dbx-core/Cargo.toml b/crates/dbx-core/Cargo.toml
index 28a7fad2ea..1ec64841a0 100644
--- a/crates/dbx-core/Cargo.toml
+++ b/crates/dbx-core/Cargo.toml
@@ -41,4 +41,5 @@ calamine = "0.30.1"
 base64 = "0.22"
 async-trait = "0.1"
 bytes = "1"
-zip = { version = "2", default-features = false, features = ["deflate"] }
+font-kit = "0.14.3"
+zip = { version = "4", default-features = false, features = ["deflate"] }
diff --git a/crates/dbx-core/src/jdbc.rs b/crates/dbx-core/src/jdbc.rs
new file mode 100644
index 0000000000..b73d50d9c2
--- /dev/null
+++ b/crates/dbx-core/src/jdbc.rs
@@ -0,0 +1,341 @@
+use crate::plugins::{PluginManifest, SUPPORTED_PLUGIN_PROTOCOL_VERSION};
+use crate::update::{fetch_latest_release, is_newer_version, JdbcPluginLatest};
+use serde::Serialize;
+use std::path::{Path, PathBuf};
+
+const JDBC_PLUGIN_DOWNLOAD_URL: &str =
+    "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip";
+const JDBC_PLUGIN_R2_PATH: &str = "releases/latest/dbx-jdbc-plugin-latest.zip";
+
+#[derive(Debug, Clone, Serialize)]
+pub struct JdbcDriverInfo {
+    pub name: String,
+    pub path: String,
+    pub size: u64,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct JdbcPluginStatus {
+    pub installed: bool,
+    pub version: Option<String>,
+    pub protocol_version: Option<u32>,
+    pub compatible: bool,
+    pub latest_version: Option<String>,
+    pub latest_protocol_version: Option<u32>,
+    pub update_available: bool,
+    pub path: String,
+}
+
+// ---- JDBC Drivers ----
+
+pub fn list_jdbc_drivers(plugins_root: &Path) -> Result<Vec<JdbcDriverInfo>, String> {
+    list_jdbc_drivers_from_dir(&jdbc_drivers_dir(plugins_root))
+}
+
+pub fn import_jdbc_drivers(plugins_root: &Path, paths: &[String]) -> Result<Vec<JdbcDriverInfo>, String> {
+    let drivers_dir = jdbc_drivers_dir(plugins_root);
+    std::fs::create_dir_all(&drivers_dir).map_err(|err| err.to_string())?;
+
+    for path in paths {
+        let source = PathBuf::from(path);
+        if !source.exists() {
+            return Err(format!("Driver JAR does not exist: {}", source.display()));
+        }
+        if source.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
+            return Err(format!("Only .jar files can be imported: {}", source.display()));
+        }
+        let file_name = source
+            .file_name()
+            .and_then(|name| name.to_str())
+            .ok_or_else(|| format!("Invalid driver file path: {}", source.display()))?;
+        let target = unique_target_path(&drivers_dir, file_name);
+        if source == target {
+            continue;
+        }
+        std::fs::copy(&source, &target)
+            .map_err(|err| format!("Failed to import {} to {}: {err}", source.display(), target.display()))?;
+    }
+
+    list_jdbc_drivers_from_dir(&drivers_dir)
+}
+
+pub fn delete_jdbc_driver(plugins_root: &Path, path: &str) -> Result<Vec<JdbcDriverInfo>, String> {
+    let drivers_dir = jdbc_drivers_dir(plugins_root);
+    let drivers_dir = drivers_dir.canonicalize().map_err(|err| err.to_string())?;
+    let target = PathBuf::from(path).canonicalize().map_err(|err| err.to_string())?;
+    if !target.starts_with(&drivers_dir) {
+        return Err("Driver file is outside the JDBC drivers directory".to_string());
+    }
+    std::fs::remove_file(&target).map_err(|err| err.to_string())?;
+    list_jdbc_drivers_from_dir(&drivers_dir)
+}
+
+// ---- JDBC Plugin ----
+
+pub async fn get_jdbc_plugin_status(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
+    jdbc_plugin_status_from_dir(&plugins_root.join("jdbc")).await
+}
+
+pub async fn install_jdbc_plugin(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
+    let bytes = download_jdbc_plugin_zip().await?;
+    let plugin_dir = plugins_root.join("jdbc");
+    install_jdbc_plugin_zip(&bytes, &plugin_dir)?;
+    jdbc_plugin_status_from_dir(&plugin_dir).await
+}
+
+pub async fn install_jdbc_plugin_from_file(plugins_root: &Path, file_path: &str) -> Result<JdbcPluginStatus, String> {
+    let bytes = std::fs::read(file_path).map_err(|e| format!("Failed to read file: {e}"))?;
+    let plugin_dir = plugins_root.join("jdbc");
+    install_jdbc_plugin_zip(&bytes, &plugin_dir)?;
+    jdbc_plugin_status_from_dir(&plugin_dir).await
+}
+
+pub fn uninstall_jdbc_plugin(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
+    let plugin_dir = plugins_root.join("jdbc");
+    for entry in ["manifest.json", "bin", "lib"] {
+        let path = plugin_dir.join(entry);
+        if !path.exists() {
+            continue;
+        }
+        if path.is_dir() {
+            std::fs::remove_dir_all(path).map_err(|err| err.to_string())?;
+        } else {
+            std::fs::remove_file(path).map_err(|err| err.to_string())?;
+        }
+    }
+    // synchronous version: check local manifest only, no network call
+    let manifest_path = plugin_dir.join("manifest.json");
+    let manifest = match std::fs::read_to_string(&manifest_path) {
+        Ok(raw) => Some(serde_json::from_str::<PluginManifest>(&raw).map_err(|err| err.to_string())?),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
+        Err(err) => return Err(err.to_string()),
+    };
+    Ok(build_plugin_status(&manifest, None, &plugin_dir))
+}
+
+// ---- System Fonts ----
+
+pub fn list_system_fonts() -> Vec<String> {
+    let source = font_kit::source::SystemSource::new();
+    match source.all_families() {
+        Ok(families) => {
+            use std::collections::BTreeSet;
+            families
+                .into_iter()
+                .map(|family| family.trim().to_string())
+                .filter(|family| !family.is_empty())
+                .collect::<BTreeSet<_>>()
+                .into_iter()
+                .collect()
+        }
+        Err(_) => vec![],
+    }
+}
+
+// ---- Internal helpers ----
+
+fn jdbc_drivers_dir(plugins_root: &Path) -> PathBuf {
+    plugins_root.join("jdbc").join("drivers")
+}
+
+async fn jdbc_plugin_status_from_dir(plugin_dir: &Path) -> Result<JdbcPluginStatus, String> {
+    let manifest_path = plugin_dir.join("manifest.json");
+    let manifest = match std::fs::read_to_string(&manifest_path) {
+        Ok(raw) => Some(serde_json::from_str::<PluginManifest>(&raw).map_err(|err| err.to_string())?),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
+        Err(err) => return Err(err.to_string()),
+    };
+    let latest = latest_jdbc_plugin().await;
+    Ok(build_plugin_status(&manifest, latest.as_ref(), plugin_dir))
+}
+
+fn build_plugin_status(
+    manifest: &Option<PluginManifest>,
+    latest: Option<&JdbcPluginLatest>,
+    plugin_dir: &Path,
+) -> JdbcPluginStatus {
+    let version = manifest.as_ref().and_then(|m| (!m.version.is_empty()).then_some(m.version.clone()));
+    let protocol_version = manifest.as_ref().map(|m| m.protocol_version);
+    let compatible = match manifest.as_ref() {
+        Some(m) => m.protocol_version == SUPPORTED_PLUGIN_PROTOCOL_VERSION,
+        None => true,
+    };
+    let latest_version = latest.map(|plugin| plugin.version.clone());
+    let latest_protocol_version = latest.map(|plugin| plugin.protocol_version);
+    let update_available = match (version.as_deref(), latest) {
+        (Some(current), Some(latest)) if manifest.is_some() => is_newer_version(&latest.version, current),
+        (None, Some(_)) if manifest.is_some() => true,
+        _ => false,
+    };
+    JdbcPluginStatus {
+        installed: manifest.is_some(),
+        version,
+        protocol_version,
+        compatible,
+        latest_version,
+        latest_protocol_version,
+        update_available,
+        path: plugin_dir.to_string_lossy().to_string(),
+    }
+}
+
+async fn latest_jdbc_plugin() -> Option<JdbcPluginLatest> {
+    fetch_latest_release().await.ok().and_then(|release| release.jdbc_plugin)
+}
+
+async fn download_jdbc_plugin_zip() -> Result<Vec<u8>, String> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(60))
+        .build()
+        .map_err(|err| err.to_string())?;
+
+    let resp =
+        crate::race_download(&client, JDBC_PLUGIN_DOWNLOAD_URL, JDBC_PLUGIN_R2_PATH, "dbx-jdbc-plugin-installer")
+            .await
+            .map_err(|err| format!("Failed to download JDBC plugin: {err}"))?;
+
+    let bytes = resp.bytes().await.map_err(|err| err.to_string())?;
+    Ok(bytes.to_vec())
+}
+
+fn install_jdbc_plugin_zip(bytes: &[u8], plugin_dir: &Path) -> Result<(), String> {
+    let cursor = std::io::Cursor::new(bytes);
+    let mut archive = zip::ZipArchive::new(cursor).map_err(|err| err.to_string())?;
+    let temp_dir = plugin_dir.with_extension("tmp");
+    if temp_dir.exists() {
+        std::fs::remove_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::create_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+
+    for index in 0..archive.len() {
+        let mut file = archive.by_index(index).map_err(|err| err.to_string())?;
+        if file.is_dir() {
+            continue;
+        }
+        let Some(enclosed) = file.enclosed_name().map(|path| path.to_path_buf()) else {
+            continue;
+        };
+        let relative = strip_zip_root(&enclosed);
+        if relative.as_os_str().is_empty() {
+            continue;
+        }
+        let output = temp_dir.join(relative);
+        if let Some(parent) = output.parent() {
+            std::fs::create_dir_all(parent).map_err(|err| err.to_string())?;
+        }
+        let mut target = std::fs::File::create(&output).map_err(|err| err.to_string())?;
+        std::io::copy(&mut file, &mut target).map_err(|err| err.to_string())?;
+    }
+
+    if !temp_dir.join("manifest.json").exists() {
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Err("Downloaded JDBC plugin package is missing manifest.json".to_string());
+    }
+    let manifest_path = temp_dir.join("manifest.json");
+    let manifest = std::fs::read_to_string(&manifest_path)
+        .map_err(|err| format!("Failed to read downloaded JDBC plugin manifest: {err}"))?;
+    let manifest: PluginManifest = serde_json::from_str(&manifest)
+        .map_err(|err| format!("Failed to parse downloaded JDBC plugin manifest: {err}"))?;
+    if manifest.id != "jdbc" {
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Err(format!("Downloaded plugin has unexpected id '{}'", manifest.id));
+    }
+    if manifest.protocol_version != SUPPORTED_PLUGIN_PROTOCOL_VERSION {
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Err(format!(
+            "Downloaded JDBC plugin uses protocol version {}, but this DBX build supports protocol version {}",
+            manifest.protocol_version, SUPPORTED_PLUGIN_PROTOCOL_VERSION
+        ));
+    }
+
+    let drivers_dir = plugin_dir.join("drivers");
+    let temp_drivers_dir = temp_dir.join("drivers");
+    if drivers_dir.exists() && !temp_drivers_dir.exists() {
+        copy_dir_all(&drivers_dir, &temp_drivers_dir)?;
+    }
+    if plugin_dir.exists() {
+        std::fs::remove_dir_all(plugin_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::rename(&temp_dir, plugin_dir).map_err(|err| err.to_string())?;
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let executable = plugin_dir.join("bin").join("dbx-jdbc-plugin");
+        if executable.exists() {
+            let mut permissions = std::fs::metadata(&executable).map_err(|err| err.to_string())?.permissions();
+            permissions.set_mode(0o755);
+            std::fs::set_permissions(executable, permissions).map_err(|err| err.to_string())?;
+        }
+    }
+
+    Ok(())
+}
+
+fn strip_zip_root(path: &Path) -> PathBuf {
+    let mut components = path.components();
+    let first = components.next();
+    if let (Some(std::path::Component::Normal(_)), Some(_)) = (first, components.clone().next()) {
+        components.collect()
+    } else {
+        path.to_path_buf()
+    }
+}
+
+fn copy_dir_all(source: &Path, target: &Path) -> Result<(), String> {
+    std::fs::create_dir_all(target).map_err(|err| err.to_string())?;
+    for entry in std::fs::read_dir(source).map_err(|err| err.to_string())? {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let file_type = entry.file_type().map_err(|err| err.to_string())?;
+        let dest = target.join(entry.file_name());
+        if file_type.is_dir() {
+            copy_dir_all(&entry.path(), &dest)?;
+        } else {
+            std::fs::copy(entry.path(), dest).map_err(|err| err.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+fn list_jdbc_drivers_from_dir(drivers_dir: &Path) -> Result<Vec<JdbcDriverInfo>, String> {
+    let entries = match std::fs::read_dir(drivers_dir) {
+        Ok(entries) => entries,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
+        Err(err) => return Err(err.to_string()),
+    };
+
+    let mut drivers = Vec::new();
+    for entry in entries {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let path = entry.path();
+        if path.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
+            continue;
+        }
+        let metadata = entry.metadata().map_err(|err| err.to_string())?;
+        drivers.push(JdbcDriverInfo {
+            name: path.file_name().and_then(|name| name.to_str()).unwrap_or("driver.jar").to_string(),
+            path: path.to_string_lossy().to_string(),
+            size: metadata.len(),
+        });
+    }
+    drivers.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(drivers)
+}
+
+pub fn unique_target_path(dir: &Path, file_name: &str) -> PathBuf {
+    let target = dir.join(file_name);
+    if !target.exists() {
+        return target;
+    }
+
+    let path = Path::new(file_name);
+    let stem = path.file_stem().and_then(|value| value.to_str()).unwrap_or("driver");
+    let ext = path.extension().and_then(|value| value.to_str()).unwrap_or("jar");
+    for index in 1.. {
+        let candidate = dir.join(format!("{stem}-{index}.{ext}"));
+        if !candidate.exists() {
+            return candidate;
+        }
+    }
+    unreachable!()
+}
diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rs
index 0db29e249f..4e3e2a3e83 100644
--- a/crates/dbx-core/src/lib.rs
+++ b/crates/dbx-core/src/lib.rs
@@ -13,6 +13,7 @@ pub mod db;
 pub mod db_admin_sql;
 pub mod external;
 pub mod history;
+pub mod jdbc;
 pub mod models;
 pub mod mongo_ops;
 pub mod object_source_sql;
diff --git a/crates/dbx-web/src/error.rs b/crates/dbx-web/src/error.rs
index 7f18b8ecbf..d123e22fb8 100644
--- a/crates/dbx-web/src/error.rs
+++ b/crates/dbx-web/src/error.rs
@@ -3,6 +3,16 @@ use axum::response::{IntoResponse, Response};
 
 pub struct AppError(pub String);
 
+impl AppError {
+    pub fn internal(msg: impl Into<String>) -> Self {
+        AppError(msg.into())
+    }
+
+    pub fn bad_request(msg: impl Into<String>) -> Self {
+        AppError(msg.into())
+    }
+}
+
 impl IntoResponse for AppError {
     fn into_response(self) -> Response {
         (StatusCode::INTERNAL_SERVER_ERROR, self.0).into_response()
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index b04552ec2e..d84f3b9682 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -86,6 +86,15 @@ async fn main() {
         .route("/connection/save", post(routes::connection::save_connections))
         .route("/connection/list", get(routes::connection::load_connections))
         .route("/plugins", get(routes::plugins::list_plugins))
+        // JDBC
+        .route("/jdbc/drivers", get(routes::jdbc::list_jdbc_drivers).post(routes::jdbc::import_jdbc_drivers))
+        .route("/jdbc/drivers/{name}", delete(routes::jdbc::delete_jdbc_driver))
+        .route("/jdbc/plugin/status", get(routes::jdbc::get_jdbc_plugin_status))
+        .route("/jdbc/plugin/install", post(routes::jdbc::install_jdbc_plugin))
+        .route("/jdbc/plugin/install-local", post(routes::jdbc::install_jdbc_plugin_local))
+        .route("/jdbc/plugin/uninstall", post(routes::jdbc::uninstall_jdbc_plugin))
+        // System
+        .route("/system/fonts", get(routes::jdbc::list_system_fonts))
         // Agent drivers
         .route("/agents/installed-local", get(routes::agents::list_installed_agents_local))
         .route("/agents/installed", get(routes::agents::list_installed_agents))
@@ -94,6 +103,7 @@ async fn main() {
         .route("/agents/upgrade-all", post(routes::agents::upgrade_all_agents))
         .route("/agents/uninstall", post(routes::agents::uninstall_agent))
         .route("/agents/import-offline", post(routes::agents::import_agents_from_zip))
+        .route("/agents/import-jar", post(routes::agents::import_agent_jar))
         .route(
             "/agents/java-runtime",
             get(routes::agents::get_agent_java_runtime_config).post(routes::agents::set_agent_java_runtime_config),
diff --git a/crates/dbx-web/src/routes/agents.rs b/crates/dbx-web/src/routes/agents.rs
index e6bb4e8ee4..91ff5205e3 100644
--- a/crates/dbx-web/src/routes/agents.rs
+++ b/crates/dbx-web/src/routes/agents.rs
@@ -174,6 +174,40 @@ pub async fn import_agents_from_zip(
     Err(AppError("No file uploaded".to_string()))
 }
 
+pub async fn import_agent_jar(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let mut db_type: Option<String> = None;
+    let mut jar_data: Option<Vec<u8>> = None;
+    let mut jar_name = String::new();
+
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let name = field.name().unwrap_or("").to_string();
+        if name == "dbType" {
+            db_type = Some(field.text().await.map_err(|e| AppError(e.to_string()))?);
+        } else if name == "file" {
+            jar_name = field.file_name().unwrap_or("driver.jar").to_string();
+            if !jar_name.to_lowercase().ends_with(".jar") {
+                return Err(AppError("Only .jar files can be imported".to_string()));
+            }
+            jar_data = Some(field.bytes().await.map_err(|e| AppError(e.to_string()))?.to_vec());
+        }
+    }
+
+    let db_type = db_type.ok_or_else(|| AppError("Missing dbType field".to_string()))?;
+    let data = jar_data.ok_or_else(|| AppError("No file uploaded".to_string()))?;
+
+    let temp_dir = state.app.plugins.root_dir().join("jar_upload_tmp");
+    std::fs::create_dir_all(&temp_dir).map_err(|e| AppError(e.to_string()))?;
+    let tmp_path = temp_dir.join(&jar_name);
+    std::fs::write(&tmp_path, &data).map_err(|e| AppError(e.to_string()))?;
+
+    dbx_core::agent_service::import_agent_jar(&state.app.agent_manager, &db_type, &tmp_path).map_err(AppError::from)?;
+    let _ = std::fs::remove_file(&tmp_path);
+    Ok(Json(serde_json::json!({ "success": true })))
+}
+
 pub async fn reinstall_jre(
     State(state): State<Arc<WebState>>,
     Json(req): Json<JreRequest>,
diff --git a/crates/dbx-web/src/routes/jdbc.rs b/crates/dbx-web/src/routes/jdbc.rs
new file mode 100644
index 0000000000..db05c299f9
--- /dev/null
+++ b/crates/dbx-web/src/routes/jdbc.rs
@@ -0,0 +1,100 @@
+use std::sync::Arc;
+
+use axum::extract::{Multipart, Path, State};
+use axum::Json;
+use dbx_core::jdbc::{self, JdbcDriverInfo, JdbcPluginStatus};
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+// ---- JDBC Drivers ----
+
+pub async fn list_jdbc_drivers(State(state): State<Arc<WebState>>) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::list_jdbc_drivers(&root).map_err(AppError::internal)?))
+}
+
+pub async fn import_jdbc_drivers(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    let drivers_dir = root.join("jdbc").join("drivers");
+    std::fs::create_dir_all(&drivers_dir).map_err(|e| AppError::internal(e.to_string()))?;
+
+    let mut imported = Vec::new();
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let file_name = field.file_name().unwrap_or("driver.jar").to_string();
+        if !file_name.to_lowercase().ends_with(".jar") {
+            return Err(AppError::bad_request("Only .jar files can be imported"));
+        }
+        let data = field.bytes().await.map_err(|e| AppError::internal(e.to_string()))?;
+        let target = jdbc::unique_target_path(&drivers_dir, &file_name);
+        std::fs::write(&target, &data).map_err(|e| AppError::internal(e.to_string()))?;
+        imported.push(target);
+    }
+
+    jdbc::list_jdbc_drivers(&root).map(Json).map_err(|e| AppError::internal(e))
+}
+
+pub async fn delete_jdbc_driver(
+    State(state): State<Arc<WebState>>,
+    Path(name): Path<String>,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    if name.contains("..") || name.contains('/') || name.contains('\\') {
+        return Err(AppError::bad_request("Invalid driver name"));
+    }
+    let root = state.app.plugins.root_dir();
+    let driver_path = root.join("jdbc").join("drivers").join(&name);
+    let path_str = driver_path.to_string_lossy().to_string();
+    Ok(Json(jdbc::delete_jdbc_driver(&root, &path_str).map_err(AppError::internal)?))
+}
+
+// ---- JDBC Plugin ----
+
+pub async fn get_jdbc_plugin_status(State(state): State<Arc<WebState>>) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::get_jdbc_plugin_status(&root).await.map_err(AppError::internal)?))
+}
+
+pub async fn install_jdbc_plugin(State(state): State<Arc<WebState>>) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::install_jdbc_plugin(&root).await.map_err(AppError::internal)?))
+}
+
+pub async fn install_jdbc_plugin_local(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    let temp_dir = root.join("jdbc").with_extension("upload_tmp");
+    std::fs::create_dir_all(&temp_dir).map_err(|e| AppError::internal(e.to_string()))?;
+
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let file_name = field.file_name().unwrap_or("plugin.zip").to_string();
+        if !file_name.to_lowercase().ends_with(".zip") {
+            return Err(AppError::bad_request("Only .zip files can be imported for JDBC plugin"));
+        }
+        let data = field.bytes().await.map_err(|e| AppError::internal(e.to_string()))?;
+        let tmp_path = temp_dir.join(&file_name);
+        std::fs::write(&tmp_path, &data).map_err(|e| AppError::internal(e.to_string()))?;
+        let result = jdbc::install_jdbc_plugin_from_file(&root, &tmp_path.to_string_lossy())
+            .await
+            .map_err(AppError::internal)?;
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Ok(Json(result));
+    }
+
+    Err(AppError::bad_request("No file uploaded"))
+}
+
+pub async fn uninstall_jdbc_plugin(State(state): State<Arc<WebState>>) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::uninstall_jdbc_plugin(&root).map_err(AppError::internal)?))
+}
+
+// ---- System Fonts ----
+
+pub async fn list_system_fonts() -> Result<Json<Vec<String>>, AppError> {
+    Ok(Json(jdbc::list_system_fonts()))
+}
diff --git a/crates/dbx-web/src/routes/mod.rs b/crates/dbx-web/src/routes/mod.rs
index e0d98208d7..ea3fa0f0e1 100644
--- a/crates/dbx-web/src/routes/mod.rs
+++ b/crates/dbx-web/src/routes/mod.rs
@@ -5,6 +5,7 @@ pub mod connection;
 pub mod data_compare;
 pub mod database_export;
 pub mod history;
+pub mod jdbc;
 pub mod layout;
 pub mod mongo;
 pub mod plugins;
diff --git a/src-tauri/src/commands/plugins.rs b/src-tauri/src/commands/plugins.rs
index 1a1fa6dbd1..f22f72994b 100644
--- a/src-tauri/src/commands/plugins.rs
+++ b/src-tauri/src/commands/plugins.rs
@@ -1,51 +1,24 @@
 use std::sync::Arc;
 use tauri::State;
 
-use dbx_core::plugins::{InstalledPlugin, PluginManifest, SUPPORTED_PLUGIN_PROTOCOL_VERSION};
-use dbx_core::update::{fetch_latest_release, is_newer_version, JdbcPluginLatest};
-use serde::Serialize;
+use dbx_core::jdbc::{self, JdbcDriverInfo, JdbcPluginStatus};
+use dbx_core::plugins::InstalledPlugin;
 
 use super::connection::AppState;
 
-const JDBC_PLUGIN_DOWNLOAD_URL: &str =
-    "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip";
-const JDBC_PLUGIN_R2_PATH: &str = "releases/latest/dbx-jdbc-plugin-latest.zip";
-
 #[tauri::command]
 pub async fn list_plugins(state: State<'_, Arc<AppState>>) -> Result<Vec<InstalledPlugin>, String> {
     state.plugins.list_installed()
 }
 
-#[derive(Debug, Clone, Serialize)]
-pub struct JdbcDriverInfo {
-    pub name: String,
-    pub path: String,
-    pub size: u64,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct JdbcPluginStatus {
-    pub installed: bool,
-    pub version: Option<String>,
-    pub protocol_version: Option<u32>,
-    pub compatible: bool,
-    pub latest_version: Option<String>,
-    pub latest_protocol_version: Option<u32>,
-    pub update_available: bool,
-    pub path: String,
-}
-
 #[tauri::command]
 pub async fn jdbc_plugin_status(state: State<'_, Arc<AppState>>) -> Result<JdbcPluginStatus, String> {
-    jdbc_plugin_status_from_state(&state).await
+    jdbc::get_jdbc_plugin_status(&state.plugins.root_dir()).await
 }
 
 #[tauri::command]
 pub async fn install_jdbc_plugin(state: State<'_, Arc<AppState>>) -> Result<JdbcPluginStatus, String> {
-    let bytes = download_jdbc_plugin_zip().await?;
-    let plugin_dir = state.plugins.root_dir().join("jdbc");
-    install_jdbc_plugin_zip(&bytes, &plugin_dir)?;
-    jdbc_plugin_status_from_state(&state).await
+    jdbc::install_jdbc_plugin(&state.plugins.root_dir()).await
 }
 
 #[tauri::command]
@@ -53,32 +26,17 @@ pub async fn install_jdbc_plugin_local(
     state: State<'_, Arc<AppState>>,
     path: String,
 ) -> Result<JdbcPluginStatus, String> {
-    let bytes = std::fs::read(&path).map_err(|e| format!("Failed to read file: {e}"))?;
-    let plugin_dir = state.plugins.root_dir().join("jdbc");
-    install_jdbc_plugin_zip(&bytes, &plugin_dir)?;
-    jdbc_plugin_status_from_state(&state).await
+    jdbc::install_jdbc_plugin_from_file(&state.plugins.root_dir(), &path).await
 }
 
 #[tauri::command]
 pub async fn uninstall_jdbc_plugin(state: State<'_, Arc<AppState>>) -> Result<JdbcPluginStatus, String> {
-    let plugin_dir = state.plugins.root_dir().join("jdbc");
-    for entry in ["manifest.json", "bin", "lib"] {
-        let path = plugin_dir.join(entry);
-        if !path.exists() {
-            continue;
-        }
-        if path.is_dir() {
-            std::fs::remove_dir_all(path).map_err(|err| err.to_string())?;
-        } else {
-            std::fs::remove_file(path).map_err(|err| err.to_string())?;
-        }
-    }
-    jdbc_plugin_status_from_state(&state).await
+    jdbc::uninstall_jdbc_plugin(&state.plugins.root_dir())
 }
 
 #[tauri::command]
 pub async fn list_jdbc_drivers(state: State<'_, Arc<AppState>>) -> Result<Vec<JdbcDriverInfo>, String> {
-    list_jdbc_drivers_from_dir(&jdbc_drivers_dir(&state))
+    jdbc::list_jdbc_drivers(&state.plugins.root_dir())
 }
 
 #[tauri::command]
@@ -86,240 +44,10 @@ pub async fn import_jdbc_drivers(
     state: State<'_, Arc<AppState>>,
     paths: Vec<String>,
 ) -> Result<Vec<JdbcDriverInfo>, String> {
-    let drivers_dir = jdbc_drivers_dir(&state);
-    std::fs::create_dir_all(&drivers_dir).map_err(|err| err.to_string())?;
-
-    for path in paths {
-        let source = std::path::PathBuf::from(path);
-        if !source.exists() {
-            return Err(format!("Driver JAR does not exist: {}", source.display()));
-        }
-        if source.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
-            return Err(format!("Only .jar files can be imported: {}", source.display()));
-        }
-        let file_name = source
-            .file_name()
-            .and_then(|name| name.to_str())
-            .ok_or_else(|| format!("Invalid driver file path: {}", source.display()))?;
-        let target = unique_target_path(&drivers_dir, file_name);
-        if source == target {
-            continue;
-        }
-        std::fs::copy(&source, &target)
-            .map_err(|err| format!("Failed to import {} to {}: {err}", source.display(), target.display()))?;
-    }
-
-    list_jdbc_drivers_from_dir(&drivers_dir)
+    jdbc::import_jdbc_drivers(&state.plugins.root_dir(), &paths)
 }
 
 #[tauri::command]
 pub async fn delete_jdbc_driver(state: State<'_, Arc<AppState>>, path: String) -> Result<Vec<JdbcDriverInfo>, String> {
-    let drivers_dir = jdbc_drivers_dir(&state);
-    let drivers_dir = drivers_dir.canonicalize().map_err(|err| err.to_string())?;
-    let target = std::path::PathBuf::from(path).canonicalize().map_err(|err| err.to_string())?;
-    if !target.starts_with(&drivers_dir) {
-        return Err("Driver file is outside the JDBC drivers directory".to_string());
-    }
-    std::fs::remove_file(&target).map_err(|err| err.to_string())?;
-    list_jdbc_drivers_from_dir(&drivers_dir)
-}
-
-fn jdbc_drivers_dir(state: &AppState) -> std::path::PathBuf {
-    state.plugins.root_dir().join("jdbc").join("drivers")
-}
-
-async fn jdbc_plugin_status_from_state(state: &AppState) -> Result<JdbcPluginStatus, String> {
-    let plugin_dir = state.plugins.root_dir().join("jdbc");
-    let manifest_path = plugin_dir.join("manifest.json");
-    let manifest = match std::fs::read_to_string(&manifest_path) {
-        Ok(raw) => Some(serde_json::from_str::<PluginManifest>(&raw).map_err(|err| err.to_string())?),
-        Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
-        Err(err) => return Err(err.to_string()),
-    };
-    let version =
-        manifest.as_ref().and_then(|manifest| (!manifest.version.is_empty()).then_some(manifest.version.clone()));
-    let protocol_version = manifest.as_ref().map(|manifest| manifest.protocol_version);
-    let compatible = match manifest.as_ref() {
-        Some(manifest) => manifest.protocol_version == SUPPORTED_PLUGIN_PROTOCOL_VERSION,
-        None => true,
-    };
-    let latest = latest_jdbc_plugin().await;
-    let latest_version = latest.as_ref().map(|plugin| plugin.version.clone());
-    let latest_protocol_version = latest.as_ref().map(|plugin| plugin.protocol_version);
-    let update_available = match (version.as_deref(), latest.as_ref()) {
-        (Some(current), Some(latest)) if manifest.is_some() => is_newer_version(&latest.version, current),
-        (None, Some(_)) if manifest.is_some() => true,
-        _ => false,
-    };
-    Ok(JdbcPluginStatus {
-        installed: manifest.is_some(),
-        version,
-        protocol_version,
-        compatible,
-        latest_version,
-        latest_protocol_version,
-        update_available,
-        path: plugin_dir.to_string_lossy().to_string(),
-    })
-}
-
-async fn latest_jdbc_plugin() -> Option<JdbcPluginLatest> {
-    fetch_latest_release().await.ok().and_then(|release| release.jdbc_plugin)
-}
-
-async fn download_jdbc_plugin_zip() -> Result<Vec<u8>, String> {
-    let client = reqwest::Client::builder()
-        .timeout(std::time::Duration::from_secs(60))
-        .build()
-        .map_err(|err| err.to_string())?;
-
-    let resp =
-        dbx_core::race_download(&client, JDBC_PLUGIN_DOWNLOAD_URL, JDBC_PLUGIN_R2_PATH, "dbx-jdbc-plugin-installer")
-            .await
-            .map_err(|err| format!("Failed to download JDBC plugin: {err}"))?;
-
-    let bytes = resp.bytes().await.map_err(|err| err.to_string())?;
-    Ok(bytes.to_vec())
-}
-
-fn install_jdbc_plugin_zip(bytes: &[u8], plugin_dir: &std::path::Path) -> Result<(), String> {
-    let cursor = std::io::Cursor::new(bytes);
-    let mut archive = zip::ZipArchive::new(cursor).map_err(|err| err.to_string())?;
-    let temp_dir = plugin_dir.with_extension("tmp");
-    if temp_dir.exists() {
-        std::fs::remove_dir_all(&temp_dir).map_err(|err| err.to_string())?;
-    }
-    std::fs::create_dir_all(&temp_dir).map_err(|err| err.to_string())?;
-
-    for index in 0..archive.len() {
-        let mut file = archive.by_index(index).map_err(|err| err.to_string())?;
-        if file.is_dir() {
-            continue;
-        }
-        let Some(enclosed) = file.enclosed_name().map(|path| path.to_path_buf()) else {
-            continue;
-        };
-        let relative = strip_zip_root(&enclosed);
-        if relative.as_os_str().is_empty() {
-            continue;
-        }
-        let output = temp_dir.join(relative);
-        if let Some(parent) = output.parent() {
-            std::fs::create_dir_all(parent).map_err(|err| err.to_string())?;
-        }
-        let mut target = std::fs::File::create(&output).map_err(|err| err.to_string())?;
-        std::io::copy(&mut file, &mut target).map_err(|err| err.to_string())?;
-    }
-
-    if !temp_dir.join("manifest.json").exists() {
-        let _ = std::fs::remove_dir_all(&temp_dir);
-        return Err("Downloaded JDBC plugin package is missing manifest.json".to_string());
-    }
-    let manifest_path = temp_dir.join("manifest.json");
-    let manifest = std::fs::read_to_string(&manifest_path)
-        .map_err(|err| format!("Failed to read downloaded JDBC plugin manifest: {err}"))?;
-    let manifest: PluginManifest = serde_json::from_str(&manifest)
-        .map_err(|err| format!("Failed to parse downloaded JDBC plugin manifest: {err}"))?;
-    if manifest.id != "jdbc" {
-        let _ = std::fs::remove_dir_all(&temp_dir);
-        return Err(format!("Downloaded plugin has unexpected id '{}'", manifest.id));
-    }
-    if manifest.protocol_version != SUPPORTED_PLUGIN_PROTOCOL_VERSION {
-        let _ = std::fs::remove_dir_all(&temp_dir);
-        return Err(format!(
-            "Downloaded JDBC plugin uses protocol version {}, but this DBX build supports protocol version {}",
-            manifest.protocol_version, SUPPORTED_PLUGIN_PROTOCOL_VERSION
-        ));
-    }
-
-    let drivers_dir = plugin_dir.join("drivers");
-    let temp_drivers_dir = temp_dir.join("drivers");
-    if drivers_dir.exists() && !temp_drivers_dir.exists() {
-        copy_dir_all(&drivers_dir, &temp_drivers_dir)?;
-    }
-    if plugin_dir.exists() {
-        std::fs::remove_dir_all(plugin_dir).map_err(|err| err.to_string())?;
-    }
-    std::fs::rename(&temp_dir, plugin_dir).map_err(|err| err.to_string())?;
-
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        let executable = plugin_dir.join("bin").join("dbx-jdbc-plugin");
-        if executable.exists() {
-            let mut permissions = std::fs::metadata(&executable).map_err(|err| err.to_string())?.permissions();
-            permissions.set_mode(0o755);
-            std::fs::set_permissions(executable, permissions).map_err(|err| err.to_string())?;
-        }
-    }
-
-    Ok(())
-}
-
-fn strip_zip_root(path: &std::path::Path) -> std::path::PathBuf {
-    let mut components = path.components();
-    let first = components.next();
-    if let (Some(std::path::Component::Normal(_)), Some(_)) = (first, components.clone().next()) {
-        components.collect()
-    } else {
-        path.to_path_buf()
-    }
-}
-
-fn copy_dir_all(source: &std::path::Path, target: &std::path::Path) -> Result<(), String> {
-    std::fs::create_dir_all(target).map_err(|err| err.to_string())?;
-    for entry in std::fs::read_dir(source).map_err(|err| err.to_string())? {
-        let entry = entry.map_err(|err| err.to_string())?;
-        let file_type = entry.file_type().map_err(|err| err.to_string())?;
-        let dest = target.join(entry.file_name());
-        if file_type.is_dir() {
-            copy_dir_all(&entry.path(), &dest)?;
-        } else {
-            std::fs::copy(entry.path(), dest).map_err(|err| err.to_string())?;
-        }
-    }
-    Ok(())
-}
-
-fn list_jdbc_drivers_from_dir(drivers_dir: &std::path::Path) -> Result<Vec<JdbcDriverInfo>, String> {
-    let entries = match std::fs::read_dir(drivers_dir) {
-        Ok(entries) => entries,
-        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
-        Err(err) => return Err(err.to_string()),
-    };
-
-    let mut drivers = Vec::new();
-    for entry in entries {
-        let entry = entry.map_err(|err| err.to_string())?;
-        let path = entry.path();
-        if path.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
-            continue;
-        }
-        let metadata = entry.metadata().map_err(|err| err.to_string())?;
-        drivers.push(JdbcDriverInfo {
-            name: path.file_name().and_then(|name| name.to_str()).unwrap_or("driver.jar").to_string(),
-            path: path.to_string_lossy().to_string(),
-            size: metadata.len(),
-        });
-    }
-    drivers.sort_by(|a, b| a.name.cmp(&b.name));
-    Ok(drivers)
-}
-
-fn unique_target_path(dir: &std::path::Path, file_name: &str) -> std::path::PathBuf {
-    let target = dir.join(file_name);
-    if !target.exists() {
-        return target;
-    }
-
-    let path = std::path::Path::new(file_name);
-    let stem = path.file_stem().and_then(|value| value.to_str()).unwrap_or("driver");
-    let ext = path.extension().and_then(|value| value.to_str()).unwrap_or("jar");
-    for index in 1.. {
-        let candidate = dir.join(format!("{stem}-{index}.{ext}"));
-        if !candidate.exists() {
-            return candidate;
-        }
-    }
-    unreachable!()
+    jdbc::delete_jdbc_driver(&state.plugins.root_dir(), &path)
 }
diff --git a/src-tauri/src/commands/system_fonts.rs b/src-tauri/src/commands/system_fonts.rs
index ae4420be12..3b09678831 100644
--- a/src-tauri/src/commands/system_fonts.rs
+++ b/src-tauri/src/commands/system_fonts.rs
@@ -1,36 +1,4 @@
-use std::collections::BTreeSet;
-
-use font_kit::source::SystemSource;
-
-pub fn normalize_font_families(families: Vec<String>) -> Vec<String> {
-    families
-        .into_iter()
-        .map(|family| family.trim().to_string())
-        .filter(|family| !family.is_empty())
-        .collect::<BTreeSet<_>>()
-        .into_iter()
-        .collect()
-}
-
 #[tauri::command]
 pub fn list_system_fonts() -> Result<Vec<String>, String> {
-    SystemSource::new().all_families().map(normalize_font_families).map_err(|err| err.to_string())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::normalize_font_families;
-
-    #[test]
-    fn normalizes_and_sorts_font_family_names() {
-        assert_eq!(
-            normalize_font_families(vec![
-                "Maple Mono NF CN".to_string(),
-                " ".to_string(),
-                "Arial".to_string(),
-                "Maple Mono NF CN".to_string(),
-            ]),
-            vec!["Arial".to_string(), "Maple Mono NF CN".to_string()],
-        );
-    }
+    Ok(dbx_core::jdbc::list_system_fonts())
 }