个人工具型桌面应用：Tauri 和 Electron 怎么选

// src-tauri/src/lib.rs（Tauri 2 风格示意）
use serde::Serialize;
use std::fs;
use std::path::PathBuf;

#[derive(Serialize)]
struct SafeFile {
    name: String,
    size: u64,
}

#[tauri::command]
fn list_notes_dir(base: String) -> Result<Vec<SafeFile>, String> {
    let root = PathBuf::from(&base);
    // 只允许固定目录，拒绝 .. 逃逸
    let canon = root.canonicalize().map_err(|e| e.to_string())?;
    let allowed = PathBuf::from("/home/user/notes").canonicalize().unwrap();
    if !canon.starts_with(&allowed) {
        return Err("path not allowed".into());
    }

    let mut out = vec![];
    for ent in fs::read_dir(&canon).map_err(|e| e.to_string())? {
        let ent = ent.map_err(|e| e.to_string())?;
        let meta = ent.metadata().map_err(|e| e.to_string())?;
        if meta.is_file() {
            out.push(SafeFile {
                name: ent.file_name().to_string_lossy().into(),
                size: meta.len(),
            });
        }
    }
    Ok(out)
}

#[tauri::command]
fn read_secret_slot(slot: String) -> Result<String, String> {
    // 真实项目：走系统钥匙串 / 加密文件，不要明文写进 localStorage
    if slot != "openai" && slot != "anthropic" {
        return Err("unknown slot".into());
    }
    keyring_get(&slot) // 伪代码
}

{
  "permissions": [
    "core:default",
    {
      "identifier": "allow-list-notes",
      "commands": {
        "allow": ["list_notes_dir", "read_secret_slot"]
      }
    }
  ]
}

import { invoke } from "@tauri-apps/api/core";

type SafeFile = { name: string; size: number };

export async function loadNotes() {
  const files = await invoke<SafeFile[]>("list_notes_dir", {
    base: "/home/user/notes",
  });
  return files;
}

export async function getApiKey() {
  return invoke<string>("read_secret_slot", { slot: "openai" });
}

// preload.js
const { contextBridge, ipcRenderer } = require("electron");

contextBridge.exposeInMainWorld("api", {
  listNotes: (base) => ipcRenderer.invoke("list-notes", base),
  getSecret: (slot) => ipcRenderer.invoke("get-secret", slot),
});

// main.js
const { app, BrowserWindow, ipcMain } = require("electron");
const fs = require("fs");
const path = require("path");

function createWindow() {
  const win = new BrowserWindow({
    webPreferences: {
      preload: path.join(__dirname, "preload.js"),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true,
    },
  });
  win.loadFile("index.html");
}

ipcMain.handle("list-notes", async (_e, base) => {
  const allowed = path.resolve("/home/user/notes");
  const target = path.resolve(base);
  if (!target.starts_with(allowed)) throw new Error("path not allowed");
  return fs.readdirSync(target).map((name) => ({
    name,
    size: fs.statSync(path.join(target, name)).size,
  }));
});

#[tauri::command]
async fn chat_via_gateway(prompt: String) -> Result<String, String> {
    let key = keyring_get("gateway").map_err(|e| e.to_string())?;
    let client = reqwest::Client::new();
    let body = serde_json::json!({
        "model": "auto",
        "messages": [{"role":"user","content": prompt}]
    });
    let resp = client
        .post("http://127.0.0.1:4000/v1/chat/completions")
        .bearer_auth(key)
        .json(&body)
        .send()
        .await
        .map_err(|e| e.to_string())?;
    let v: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
    Ok(v["choices"][0]["message"]["content"].as_str().unwrap_or("").into())
}