feat: 按安装目录隔离存储应用数据，实现多实例独立运行

新增 StoragePaths 模块，将数据库、设置、frp 版本等业务数据统一保存在应用实际安装位置，避免不同实例或版本间数据混淆。新增 Preferences 模块管理安装目录内的持久化设置，重构数据库初始化逻辑，修改 Frpc 运行目录、frp 版本存储路径，新增数据目录锁机制防止多进程冲突，同时更新文档说明数据目录规则与平台差异。

src-tauri/Cargo.toml

@@ -22,7 +22,7 @@ tauri-build = { version = "2", features = [] }
 tauri-helper = "0.2.1"
 
 [dependencies]
-tauri = { version = "2", features = ["tray-icon"] }
+tauri = { version = "2.12.3", features = ["tray-icon"] }
 tauri-plugin-opener = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

src-tauri/src/commands/frp.rs

@@ -12,6 +12,7 @@ use tokio::io::AsyncWriteExt;
 use crate::models::{
     ApiResponse, FrpDownload, FrpDownloadPayload, FrpDownloadProgress, FrpRelease,
 };
+use crate::services::storage::StoragePaths;
 
 /// GitHub 镜像加速前缀（国内访问 GitHub 不稳定，拉取版本与下载统一走镜像）
 const GITHUB_MIRROR: &str = "https://gh-proxy.com/";
@@ -133,14 +134,31 @@ async fn fetch_releases(client: &reqwest::Client) -> Result<Vec<Value>, String>
     Err(format!("获取 Frp 版本列表失败：{last_err}"))
 }
 
-/// 应用数据目录下的 frp 版本存储根目录
+/// 安装目录下的 frp 版本存储根目录
 fn versions_dir(app: &AppHandle) -> Result<PathBuf, String> {
-    Ok(app
-        .path()
-        .app_data_dir()
-        .map_err(|e| e.to_string())?
-        .join("frp")
-        .join("versions"))
+    Ok(app.state::<StoragePaths>().versions())
+}
+
+fn version_directory(version: &str) -> String {
+    if version != "."
+        && version != ".."
+        && !version.is_empty()
+        && version
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'))
+    {
+        version.to_string()
+    } else {
+        // 将任意 Unicode 文件名编码为十六进制，保证导入目录名称唯一。
+        format!(
+            "import-{}",
+            version
+                .as_bytes()
+                .iter()
+                .map(|b| format!("{b:02x}"))
+                .collect::<String>()
+        )
+    }
 }
 
 /// 发送下载进度事件
@@ -153,7 +171,9 @@ fn emit_progress(
     message: Option<&str>,
 ) {
     let percent = if total > 0 {
-        ((downloaded as f64 / total as f64) * 100.0).clamp(0.0, 100.0).round() as u8
+        ((downloaded as f64 / total as f64) * 100.0)
+            .clamp(0.0, 100.0)
+            .round() as u8
     } else {
         0
     };
@@ -219,7 +239,10 @@ pub async fn get_frp_releases(
         };
 
         for asset in assets {
-            let name = asset.get("name").and_then(Value::as_str).unwrap_or_default();
+            let name = asset
+                .get("name")
+                .and_then(Value::as_str)
+                .unwrap_or_default();
             let Some((_v, os, arch)) = parse_asset(name) else {
                 continue;
             };
@@ -510,7 +533,9 @@ fn find_binary(dir: &Path, stem: &str) -> Option<PathBuf> {
                 stack.push(path);
                 continue;
             }
-            let Some(name) = path.file_name().map(|s| s.to_string_lossy().to_ascii_lowercase())
+            let Some(name) = path
+                .file_name()
+                .map(|s| s.to_string_lossy().to_ascii_lowercase())
             else {
                 continue;
             };
@@ -558,10 +583,12 @@ pub async fn delete_frp(
     };
 
     if let Ok(base) = versions_dir(&app) {
-        let ver_dir = base.join(&row.version);
+        let ver_dir = base.join(version_directory(&row.version));
         let _ = tokio::fs::remove_dir_all(ver_dir.join(&row.platform)).await;
         if let Some(archive) = &row.archive_path {
-            let _ = tokio::fs::remove_file(archive).await;
+            if Path::new(archive).starts_with(&base) {
+                let _ = tokio::fs::remove_file(archive).await;
+            }
         }
         // 版本目录已空则一并删除
         if let Ok(mut entries) = tokio::fs::read_dir(&ver_dir).await {
@@ -570,7 +597,6 @@ pub async fn delete_frp(
             }
         }
     }
-
     match sqlx::query("DELETE FROM frp_downloads WHERE id = ?")
         .bind(id)
         .execute(&*state)
@@ -581,7 +607,7 @@ pub async fn delete_frp(
     }
 }
 
-/// 导入本地已下载的 frpc / frps（记录可执行文件路径，不复制文件）
+/// 导入本地 frpc / frps，将副本保存到安装目录，原始文件保持不变。
 #[tauri::command]
 #[auto_collect_command]
 pub async fn import_frp(
@@ -612,11 +638,33 @@ pub async fn import_frp(
             .file_name()
             .map(|s| s.to_string_lossy().to_string())
             .unwrap_or_default();
-        let size = std::fs::metadata(&path).map(|m| m.len() as i64).unwrap_or(0);
+        let size = std::fs::metadata(&path)
+            .map(|m| m.len() as i64)
+            .unwrap_or(0);
         let lower = file_name.to_ascii_lowercase();
         let is_frps = lower.contains("frps");
         let version = parse_version(&file_name).unwrap_or_else(|| file_name.clone());
-        let full = path.to_string_lossy().to_string();
+        let binary_name = if is_frps { "frps" } else { "frpc" };
+        // 对用户选择的文件名进行编码后再构造存储目录。
+        let import_dir = versions_dir(&app)?
+            .join(version_directory(&version))
+            .join(&platform)
+            .join("import");
+        std::fs::create_dir_all(&import_dir).map_err(|e| e.to_string())?;
+        let destination = import_dir.join(if cfg!(windows) {
+            format!("{binary_name}.exe")
+        } else {
+            binary_name.to_string()
+        });
+        let same_file = match (std::fs::canonicalize(&destination), std::fs::canonicalize(&path)) {
+            (Ok(destination), Ok(source)) => destination == source,
+            _ => false,
+        };
+        if !same_file {
+            std::fs::copy(&path, &destination).map_err(|e| format!("导入 Frp 失败：{e}"))?;
+        }
+        make_executable(&destination);
+        let full = destination.to_string_lossy().to_string();
         let (frpc_path, frps_path) = if is_frps {
             (None, Some(full))
         } else {
@@ -683,7 +731,10 @@ mod tests {
 
     #[test]
     fn parse_version_extracts_semver() {
-        assert_eq!(parse_version("frpc_0.71.0_windows_amd64.exe"), Some("v0.71.0".into()));
+        assert_eq!(
+            parse_version("frpc_0.71.0_windows_amd64.exe"),
+            Some("v0.71.0".into())
+        );
         assert_eq!(parse_version("frps-v0.60.0"), Some("v0.60.0".into()));
         assert_eq!(parse_version("frpc.exe"), None);
         assert_eq!(parse_version("frpc_0.71.exe"), None);

src-tauri/src/commands/mod.rs

@@ -1,5 +1,6 @@
 pub mod frp;
 pub mod runner;
 pub mod server;
+pub mod storage;
 pub mod system;
 pub mod tunnel;

src-tauri/src/commands/runner.rs

@@ -12,6 +12,7 @@ use tauri_helper::auto_collect_command;
 use crate::models::{ApiResponse, FrpDownload, FrpcStatus, Server, Tunnel};
 use crate::services::config::generate_frpc_config;
 use crate::services::runner::FrpcRunner;
+use crate::services::storage::StoragePaths;
 
 // 统一查询字段，使用 concat! 保证结果为 'static str（sqlx 0.9 要求）
 macro_rules! server_fields {
@@ -32,14 +33,9 @@ macro_rules! download_fields {
     };
 }
 
-/// 本次运行生成的 frpc.toml 路径（应用数据目录/frp/run/frpc.toml）
+/// 本次运行生成的 frpc.toml 路径（安装目录/run/frpc.toml）
 fn config_file_path(app: &AppHandle) -> Result<PathBuf, String> {
-    let dir = app
-        .path()
-        .app_data_dir()
-        .map_err(|e| e.to_string())?
-        .join("frp")
-        .join("run");
+    let dir = app.state::<StoragePaths>().run();
     std::fs::create_dir_all(&dir).map_err(|e| format!("创建配置目录失败：{e}"))?;
     Ok(dir.join("frpc.toml"))
 }
@@ -77,7 +73,12 @@ pub async fn start_frpc(
     .await
     {
         Ok(Some(row)) => row,
-        Ok(None) => return Ok(ApiResponse::error(404, "所选 Frpc 版本不存在，请刷新后重试")),
+        Ok(None) => {
+            return Ok(ApiResponse::error(
+                404,
+                "所选 Frpc 版本不存在，请刷新后重试",
+            ));
+        }
         Err(e) => return Ok(ApiResponse::error(500, &e.to_string())),
     };
 

src-tauri/src/commands/storage.rs

@@ -0,0 +1,45 @@
+use std::collections::BTreeMap;
+use std::sync::Mutex;
+
+use tauri::State;
+use tauri_helper::auto_collect_command;
+
+use crate::services::storage::{StoragePaths, write_json};
+
+#[derive(Default)]
+pub struct PreferencesLock(pub Mutex<()>);
+
+#[tauri::command]
+#[auto_collect_command]
+pub fn get_preferences(
+    paths: State<'_, StoragePaths>,
+    lock: State<'_, PreferencesLock>,
+) -> Result<Option<BTreeMap<String, String>>, String> {
+    let _guard = lock.0.lock().map_err(|e| e.to_string())?;
+    let path = paths.data().join("preferences.json");
+    match std::fs::read(path) {
+        Ok(bytes) => serde_json::from_slice(&bytes)
+            .map(Some)
+            .map_err(|e| e.to_string()),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(e.to_string()),
+    }
+}
+
+#[tauri::command]
+#[auto_collect_command]
+pub fn set_preferences(
+    paths: State<'_, StoragePaths>,
+    lock: State<'_, PreferencesLock>,
+    preferences: BTreeMap<String, String>,
+) -> Result<(), String> {
+    if preferences
+        .iter()
+        .any(|(key, value)| !key.starts_with("frpcpilot:") || key.len() + value.len() > 65536)
+        || preferences.len() > 100
+    {
+        return Err("设置数据无效或过大".into());
+    }
+    let _guard = lock.0.lock().map_err(|e| e.to_string())?;
+    write_json(&paths.data().join("preferences.json"), &preferences)
+}

src-tauri/src/lib.rs

@@ -13,25 +13,44 @@ use crate::commands::server::{
     create_server, delete_server, get_server_list, set_server_enabled, set_server_pinned,
     update_server,
 };
+use crate::commands::storage::{PreferencesLock, get_preferences, set_preferences};
 use crate::commands::system::{get_system_details, get_system_info, is_autostart_supported};
 use crate::commands::tunnel::{
     create_tunnel, delete_tunnel, get_tunnel_list, set_tunnel_enabled, set_tunnel_pinned,
     update_tunnel,
 };
-use crate::services::db::init_pool;
 use crate::services::runner::FrpcRunner;
+use crate::services::storage::{self, StoragePaths};
 use crate::services::system::SystemStats;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    let paths = StoragePaths::discover().expect("无法确定软件安装目录");
+    // 此入口在启动 Tauri、Tokio 或任何工作线程之前调用。
+    // 将更新、解压及子进程继承的临时文件目录统一指向安装目录。
+    if std::fs::create_dir_all(paths.root.join("tmp")).is_ok() {
+        unsafe {
+            std::env::set_var("TEMP", paths.root.join("tmp"));
+            std::env::set_var("TMP", paths.root.join("tmp"));
+            std::env::set_var("TMPDIR", paths.root.join("tmp"));
+        }
+    }
+    let mut context = tauri::generate_context!();
+    context.config_mut().app.app_directories_override = Some(paths.overrides());
+    // 在打开 WebView 前初始化数据目录，同时保留各平台的窗口配置。
+    for window in &mut context.config_mut().app.windows {
+        window.create = false;
+    }
     let mut builder = tauri::Builder::default()
+        .manage(paths)
+        .manage(PreferencesLock::default())
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_dialog::init()) // 对话框插件
         .plugin(tauri_plugin_updater::Builder::new().build()) // 更新插件
         .plugin(tauri_plugin_process::init()) // 进程插件（更新后重启）
         .plugin(tauri_plugin_prevent_default::Builder::new().build());
 
-    // Development executables require Vite; debug builds also open a Windows console.
+    // 开发版依赖 Vite，调试构建在 Windows 上还会打开控制台窗口。
     if is_autostart_supported() {
         builder = builder.plugin(tauri_plugin_autostart::init(
             tauri_plugin_autostart::MacosLauncher::LaunchAgent,
@@ -41,8 +60,26 @@ pub fn run() {
 
     let app = builder
         .setup(|app| {
-            // The plugin resolves the running executable dynamically. Refresh enabled
-            // entries after reinstalling or moving the app, preserving disabled state.
+            use tauri_plugin_dialog::{DialogExt, MessageDialogKind};
+
+            let paths = app.state::<StoragePaths>();
+            let initialize = || -> Result<_, Box<dyn std::error::Error>> {
+                let (pool, lock) = tauri::async_runtime::block_on(storage::initialize(&paths))
+                    .map_err(std::io::Error::other)?;
+                app.manage(pool);
+                app.manage(lock);
+                Ok(())
+            };
+            if let Err(error) = initialize() {
+                app.dialog().message(format!(
+                    "无法初始化安装目录中的数据：{}\n\n{error}\n\n请确认安装目录可写、磁盘空间充足，并退出使用同一数据目录的其他实例。",
+                    paths.root.display()
+                )).title("FrpcPilot 数据初始化失败").kind(MessageDialogKind::Error).blocking_show();
+                return Err(error);
+            }
+
+            // 插件会动态解析当前可执行文件的位置；重新安装或移动应用后刷新
+            // 已启用的自启动项，原本禁用的自启动项仍保持禁用。
             if is_autostart_supported() {
                 let autostart = app.autolaunch();
                 let result = autostart.is_enabled().and_then(|enabled| {
@@ -57,13 +94,6 @@ pub fn run() {
                 }
             }
 
-            let pool = tauri::async_runtime::block_on(async {
-                init_pool(app.handle())
-                    .await
-                    .expect("sqlite数据库连接池初始化失败!")
-            });
-            app.manage(pool);
-
             // 系统资源占用（CPU / 内存）后台采集
             let stats = SystemStats::default();
             stats.start();
@@ -72,12 +102,19 @@ pub fn run() {
             // Frpc 进程管理器（一键启动 / 停止与日志实时回显）
             app.manage(FrpcRunner::default());
 
+            for config in &app.config().app.windows {
+                let window = tauri::WebviewWindowBuilder::from_config(app.handle(), config)?;
+                #[cfg(not(target_os = "macos"))]
+                let window = window.data_directory(paths.webview());
+                window.build()?;
+            }
+
             Ok(())
         })
         .plugin(tauri_plugin_store::Builder::default().build())
         // .invoke_handler(tauri::generate_handler![greet])
         .invoke_handler(tauri_helper::tauri_collect_commands!())
-        .build(tauri::generate_context!())
+        .build(context)
         .expect("error while building tauri application");
 
     app.run(|app_handle, event| {

src-tauri/src/services/db.rs

@@ -1,14 +1,10 @@
 use sqlx::sqlite::{SqliteConnectOptions, SqlitePool, SqlitePoolOptions};
-use tauri::{AppHandle, Manager};
+use std::path::Path;
 
-pub async fn init_pool(app: &AppHandle) -> Result<SqlitePool, sqlx::Error> {
-    // 数据库文件路径
-    let app_dir = app.path().app_data_dir().expect("无法获取APP数据目录");
-    std::fs::create_dir_all(&app_dir).unwrap();
-    let db_path = app_dir.join("frpcpilot.db");
+pub async fn init_pool(db_path: &Path) -> Result<SqlitePool, sqlx::Error> {
     // 初始化数据库连接池
     let options = SqliteConnectOptions::new()
-        .filename(&db_path)
+        .filename(db_path)
         .create_if_missing(true);
     let pool = SqlitePoolOptions::new()
         .max_connections(5)

src-tauri/src/services/mod.rs

@@ -1,4 +1,5 @@
 pub mod config;
 pub mod db;
 pub mod runner;
+pub mod storage;
 pub mod system;

src-tauri/src/services/runner.rs

@@ -97,8 +97,8 @@ impl FrpcRunner {
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
 
-        // 工作目录设为 frpc 所在目录，保证其相对路径配置可正常解析
-        if let Some(dir) = exe.parent() {
+        // 相对路径的运行产物统一保存在生成配置所在的目录。
+        if let Some(dir) = Path::new(config_path).parent() {
             command.current_dir(dir);
         }
 

src-tauri/src/services/storage.rs

@@ -0,0 +1,153 @@
+//! 按安装位置分类存储应用数据。
+//! 此模块在创建任何 WebView 或打开应用数据库连接池之前执行。
+
+use std::fs::{self, File, OpenOptions};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+use serde::Serialize;
+use sqlx::SqlitePool;
+use tauri::utils::config::{AppDirectoriesOverride, AppDirectoryOverrides};
+
+use super::db::init_pool;
+
+#[derive(Clone, Debug)]
+pub struct StoragePaths {
+    pub root: PathBuf,
+}
+
+impl StoragePaths {
+    pub fn discover() -> Result<Self, String> {
+        let exe = std::env::current_exe().map_err(|e| e.to_string())?;
+        // APPIMAGE 指向实际的安装文件，避免使用只读的 /tmp/.mount_* 挂载目录。
+        let appimage = if cfg!(target_os = "linux") && !cfg!(debug_assertions) {
+            std::env::var_os("APPIMAGE").map(PathBuf::from)
+        } else {
+            None
+        };
+        let mut root = installation_root(&exe, appimage.as_deref(), cfg!(target_os = "macos"))?;
+        // 开发和测试使用独立的数据目录，避免影响正式版配置。
+        if cfg!(debug_assertions) {
+            root = root.join("FrpcPilot-dev");
+        }
+        Ok(Self { root })
+    }
+
+    pub fn data(&self) -> PathBuf {
+        self.root.join("data")
+    }
+    pub fn db(&self) -> PathBuf {
+        self.data().join("frpcpilot.db")
+    }
+    pub fn versions(&self) -> PathBuf {
+        self.root.join("frp").join("versions")
+    }
+    pub fn run(&self) -> PathBuf {
+        self.root.join("run")
+    }
+    pub fn webview(&self) -> PathBuf {
+        self.root.join("webview")
+    }
+    pub fn overrides(&self) -> AppDirectoriesOverride {
+        AppDirectoriesOverride::Directories(AppDirectoryOverrides {
+            config: Some(self.data()),
+            data: Some(self.data()),
+            local_data: Some(self.webview()),
+            cache: Some(self.root.join("cache")),
+            log: Some(self.root.join("logs")),
+        })
+    }
+}
+
+fn installation_root(exe: &Path, appimage: Option<&Path>, macos: bool) -> Result<PathBuf, String> {
+    if macos {
+        if let Some(bundle) = exe
+            .ancestors()
+            .find(|p| p.extension().is_some_and(|e| e == "app"))
+        {
+            // 数据保存在应用包同级目录，避免 macOS 更新器替换签名应用包时丢失数据。
+            return Ok(bundle.with_file_name("FrpcPilot-data"));
+        }
+    }
+    let location = appimage.unwrap_or(exe);
+    if !location.is_absolute() {
+        return Err(format!("安装位置必须为绝对路径：{}", location.display()));
+    }
+    location
+        .parent()
+        .map(Path::to_path_buf)
+        .ok_or_else(|| "无法确定安装目录".into())
+}
+
+/// 在应用整个生命周期内持有文件锁，进程崩溃后操作系统也会自动释放锁。
+pub struct StorageLock(File);
+
+impl StorageLock {
+    fn acquire(path: &Path) -> Result<Self, String> {
+        let file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(false)
+            .open(path)
+            .map_err(|e| {
+                format!(
+                    "无法写入 {}：{e}。请将软件安装到当前用户可写的目录。",
+                    path.display()
+                )
+            })?;
+        file.try_lock().map_err(|e| {
+            format!(
+                "数据目录正在被另一个 FrpcPilot 使用：{}（{e}）。请先退出其他实例。",
+                path.display()
+            )
+        })?;
+        Ok(Self(file))
+    }
+}
+
+impl Drop for StorageLock {
+    fn drop(&mut self) {
+        let _ = self.0.unlock();
+    }
+}
+
+pub async fn initialize(paths: &StoragePaths) -> Result<(SqlitePool, StorageLock), String> {
+    fs::create_dir_all(paths.data()).map_err(|e| {
+        format!(
+            "无法创建数据目录 {}：{e}。请使用可写的安装目录。",
+            paths.data().display()
+        )
+    })?;
+    let lock = StorageLock::acquire(&paths.data().join("storage.lock"))?;
+    for dir in [
+        paths.versions(),
+        paths.run(),
+        paths.webview(),
+        paths.root.join("cache"),
+        paths.root.join("logs"),
+        paths.root.join("tmp"),
+    ] {
+        fs::create_dir_all(&dir).map_err(|e| format!("无法创建 {}：{e}", dir.display()))?;
+    }
+    let pool = init_pool(&paths.db())
+        .await
+        .map_err(|e| format!("初始化数据库失败：{e}"))?;
+    Ok((pool, lock))
+}
+
+pub fn write_json(path: &Path, value: &impl Serialize) -> Result<(), String> {
+    let bytes = serde_json::to_vec_pretty(value).map_err(|e| e.to_string())?;
+    let temp = path.with_extension("json.tmp");
+    let mut file = File::create(&temp).map_err(|e| e.to_string())?;
+    file.write_all(&bytes)
+        .and_then(|_| file.sync_all())
+        .map_err(|e| e.to_string())?;
+    drop(file);
+    // std::fs::rename 在 Windows 和 Unix 上均以原子方式替换已有文件。
+    fs::rename(&temp, path).map_err(|e| e.to_string())
+}
+
+#[cfg(test)]
+#[path = "storage_tests.rs"]
+mod tests;

src-tauri/src/services/storage_tests.rs

@@ -0,0 +1,74 @@
+use super::*;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+struct Fixture(PathBuf);
+impl Fixture {
+    fn new() -> Self {
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("target")
+            .join("storage-tests")
+            .join(format!(
+                "{}-{}",
+                std::process::id(),
+                COUNTER.fetch_add(1, Ordering::SeqCst)
+            ));
+        fs::create_dir_all(&root).unwrap();
+        Self(root)
+    }
+    fn paths(&self, name: &str) -> StoragePaths {
+        StoragePaths {
+            root: self.0.join(name),
+        }
+    }
+}
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.0);
+    }
+}
+
+#[test]
+fn install_locations_cover_bundles_and_appimage() {
+    let f = Fixture::new();
+    assert_eq!(
+        installation_root(&f.0.join("pilot/frpcpilot"), None, false).unwrap(),
+        f.0.join("pilot")
+    );
+    assert_eq!(
+        installation_root(
+            &f.0.join(".mount_Pilot/usr/bin/frpcpilot"),
+            Some(&f.0.join("apps/FrpcPilot.AppImage")),
+            false
+        )
+        .unwrap(),
+        f.0.join("apps")
+    );
+    assert_eq!(
+        installation_root(
+            &f.0.join("Applications/FrpcPilot.app/Contents/MacOS/frpcpilot"),
+            None,
+            true
+        )
+        .unwrap(),
+        f.0.join("Applications/FrpcPilot-data")
+    );
+    assert!(installation_root(Path::new("relative/frpcpilot"), None, false).is_err());
+}
+
+#[test]
+fn fresh_install_and_exclusive_storage_lock() {
+    tauri::async_runtime::block_on(async {
+        let f = Fixture::new();
+        let paths = f.paths("new");
+        let (pool, lock) = initialize(&paths).await.unwrap();
+        assert!(paths.db().is_file());
+        assert!(paths.run().is_dir());
+        assert!(paths.versions().is_dir());
+        assert!(initialize(&paths).await.is_err());
+        pool.close().await;
+        drop(lock);
+        let (pool, _lock) = initialize(&paths).await.unwrap();
+        pool.close().await;
+    });
+}