Atualização pelo próprio app (Tauri updater) com cartão de aviso

Ao abrir, o app consulta o latest.json da release no GitHub; havendo versão nova, um cartão
oferece Atualizar agora: baixa, confere a assinatura com a chave pública embutida, instala e
reabre (AppImage substituído no lugar; Windows e macOS pelo instalador). Instalação por .deb ou
.rpm só avisa. Configurações ganha a opção de desligar a consulta e o botão Verificar agora.

A release assina os pacotes com a chave guardada no ambiente 'release' do GitHub (só tags v*) e
o latest.json é montado de uma vez por scripts/make-latest-json.py, depois que todos os jobs
de empacotamento terminam.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

apps/gui/src-tauri/Cargo.toml

@@ -17,6 +17,8 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 tauri = { version = "2", features = [] }
 tauri-plugin-dialog = "2"
+tauri-plugin-updater = "2"
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 guara-core = { path = "../../../crates/guara-core" }
 

apps/gui/src-tauri/src/main.rs

@@ -15,6 +15,73 @@ async fn rpc(state: tauri::State<'_, State>, method: String, params: serde_json:
         .map_err(|e| e.to_string())?
 }
 
+/// Versão nova encontrada na release do GitHub.
+#[derive(serde::Serialize)]
+struct UpdateInfo {
+    current: String,
+    version: String,
+    notes: String,
+    /// O app consegue se atualizar sozinho (AppImage, Windows e macOS). Instalação por pacote
+    /// (.deb/.rpm) só avisa e leva à página da release.
+    auto: bool,
+    url: String,
+}
+
+fn self_update_possible() -> bool {
+    !cfg!(target_os = "linux") || std::env::var_os("APPIMAGE").is_some()
+}
+
+/// Procura uma versão mais nova. `None` = já está na última.
+#[tauri::command]
+async fn update_check(app: tauri::AppHandle) -> Result<Option<UpdateInfo>, String> {
+    use tauri_plugin_updater::UpdaterExt;
+    let found = app.updater().map_err(|e| e.to_string())?.check().await.map_err(|e| e.to_string())?;
+    Ok(found.map(|u| UpdateInfo {
+        current: u.current_version.clone(),
+        notes: u.body.clone().unwrap_or_default(),
+        url: format!("https://github.com/lucasrguerra/guara/releases/tag/v{}", u.version),
+        version: u.version,
+        auto: self_update_possible(),
+    }))
+}
+
+/// Baixa, confere a assinatura (chave pública embutida no app), instala e reabre o app.
+/// O progresso sai no evento `update-progress`.
+#[tauri::command]
+async fn update_install(app: tauri::AppHandle) -> Result<(), String> {
+    use tauri::Emitter;
+    use tauri_plugin_updater::UpdaterExt;
+    if !self_update_possible() {
+        return Err("Esta instalação não se atualiza sozinha (pacote do sistema). Baixe a versão nova na página da release.".into());
+    }
+    let update = app
+        .updater()
+        .map_err(|e| e.to_string())?
+        .check()
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or("Já está na versão mais recente.")?;
+    let (a, b) = (app.clone(), app.clone());
+    let mut got = 0u64;
+    update
+        .download_and_install(
+            move |chunk, total| {
+                got += chunk as u64;
+                let _ = a.emit("update-progress", serde_json::json!({ "downloaded": got, "total": total }));
+            },
+            move || {
+                let _ = b.emit("update-progress", serde_json::json!({ "installing": true }));
+            },
+        )
+        .await
+        .map_err(|e| format!("Não foi possível atualizar: {e}"))?;
+    // Rodando como administrador, o arquivo novo nasce do root: devolve ao usuário que abriu o app.
+    if let Some(p) = std::env::var_os("APPIMAGE") {
+        guara_core::owner::give_to_user(std::path::Path::new(&p));
+    }
+    app.restart()
+}
+
 /// Reabre o app com privilégios de administrador (Linux/macOS). No Windows o
 /// manifesto já exige elevação. O app novo encerra este quando abre; se a
 /// autorização falhar, a janela continua aqui e a interface mostra o motivo.
@@ -155,6 +222,7 @@ fn main() {
     let for_protocol = engine.clone();
     tauri::Builder::default()
         .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_updater::Builder::new().build())
         .manage(State(engine))
         .register_asynchronous_uri_scheme_protocol("guara", move |_ctx, request, responder| {
             let eng = for_protocol.clone();
@@ -176,7 +244,7 @@ fn main() {
             }
             Ok(())
         })
-        .invoke_handler(tauri::generate_handler![rpc, relaunch_elevated])
+        .invoke_handler(tauri::generate_handler![rpc, relaunch_elevated, update_check, update_install])
         .run(tauri::generate_context!())
         .expect("erro ao iniciar o Guará");
 }

apps/gui/src-tauri/tauri.conf.json

@@ -34,6 +34,18 @@
       "icons/128x128@2x.png",
       "icons/icon.icns",
       "icons/icon.ico"
-    ]
+    ],
+    "createUpdaterArtifacts": true
+  },
+  "plugins": {
+    "updater": {
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDhENzRCRUU5NEI3QTAxQzgKUldUSUFYcEw2YjUwamFzMnpXM3ZKTEZPN1JIeXdLL3Q5SEF1M1FxQ284WFM0UWNsdlAyNUloWTEK",
+      "endpoints": [
+        "https://github.com/lucasrguerra/guara/releases/latest/download/latest.json"
+      ],
+      "windows": {
+        "installMode": "passive"
+      }
+    }
   }
 }