Använda winapp CLI med Tauri

Den här guiden visar hur du använder winapp CLI med ett Tauri-program för att felsöka med paketidentitet och paketera ditt program som en MSIX.

Paketidentitet är ett grundläggande begrepp i Windows app modellen. Det gör att ditt program kan komma åt specifika Windows API:er (t.ex. meddelanden, säkerhet, AI-API:er osv.), har en ren installations-/avinstallationsupplevelse med mera.

Ett fullständigt arbetsexempel finns i Tauri-exemplet på den här lagringsplatsen.

Förutsättningar

1. Windows 11
2. Node.js - winget install OpenJS.NodeJS --source winget
3. Rust Toolchain – Installera Rust med rustup eller winget install Rustlang.Rustup --source winget
4. winapp CLI - winget install microsoft.winappcli --source winget

1. Skapa en ny Tauri-app

Börja med att skapa en ny Tauri-applikation med hjälp av det officiella genereringsverktyget.

npm create tauri-app@latest

Följ anvisningarna:

• Project namn: tauri-app (eller önskat namn)
• Klientdelsspråk: JavaScript
• Pakethanterare: npm
• Mall för användargränssnitt: Vanilla
• Gränssnittstema: JavaScript

Gå till din project-katalog och installera beroenden:

cd tauri-app
npm install

Kör appen för att kontrollera att allt fungerar:

npm run tauri dev

2. Uppdatera koden för att kontrollera identiteten

Vi uppdaterar appen för att kontrollera om den körs med paketidentitet. Vi använder windows-lådan i Rust-serverdelen för att komma åt Windows API:er och exponera den för klientdelen.

Backend-förändringar (Rust)

1. Lägg till beroende: Öppna src-tauri/Cargo.toml och lägg till följande rader i slutet av filen. Detta lägger till Windows API-bindningar så att vi kan söka efter paketidentitet:

   [target.'cfg(windows)'.dependencies]
   windows = { version = "0.58", features = ["ApplicationModel"] }
   

2. Lägg till kommando: Öppna src-tauri/src/lib.rs och lägg till get_package_family_name funktionen. Placera den före pub fn run() funktionen:

   #[tauri::command]
   fn get_package_family_name() -> String {
       #[cfg(target_os = "windows")]
       {
           use windows::ApplicationModel::Package;
           match Package::Current() {
               Ok(package) => {
                   match package.Id() {
                       Ok(id) => match id.FamilyName() {
                           Ok(name) => name.to_string(),
                           Err(_) => "Error retrieving Family Name".to_string(),
                       },
                       Err(_) => "Error retrieving Package ID".to_string(),
                   }
               }
               Err(_) => "No package identity".to_string(),
           }
       }
       #[cfg(not(target_os = "windows"))]
       {
           "Not running on Windows".to_string()
       }
   }
   

3. Registrera kommando: I samma fil (src-tauri/src/lib.rs) uppdaterar du run funktionen för att registrera det nya kommandot:

   pub fn run() {
       tauri::Builder::default()
           .plugin(tauri_plugin_opener::init())
           .invoke_handler(tauri::generate_handler![greet, get_package_family_name]) // Add get_package_family_name here
           .run(tauri::generate_context!())
           .expect("error while running tauri application");
   }
   

Klientdelsändringar (JavaScript)

1. Uppdatera HTML: Öppna src/index.html och lägg till ett stycke för att visa resultatet:

   <!-- ... inside <main> ... -->
   <p id="pfn-msg"></p>
   

2. Uppdateringslogik: Öppna src/main.js för att anropa kommandot och visa resultatet:

   const { invoke } = window.__TAURI__.core;
   
   // ... existing code ...
   
   async function checkPackageIdentity() {
     const pfn = await invoke("get_package_family_name");
     const pfnMsgEl = document.querySelector("#pfn-msg");
   
     if (pfn !== "No package identity" && !pfn.startsWith("Error")) {
       pfnMsgEl.textContent = `Package family name: ${pfn}`;
     } else {
       pfnMsgEl.textContent = `Not running with package identity`;
     }
   }
   
   window.addEventListener("DOMContentLoaded", () => {
     // ... existing code ...
     checkPackageIdentity();
   });
   

3. Kör appen som vanligt:

   npm run tauri dev
   

   Du bör se "Körs inte med paketidentitet" i appfönstret. Detta bekräftar att standardutvecklingsversionen körs utan paketidentitet.

3. Initiera Project med winapp CLI

Kommandot winapp init konfigurerar allt du behöver i ett svep: appmanifest och resurser. Manifestet definierar appens identitet (namn, utgivare, version) som Windows använder för att bevilja API-åtkomst.

Kör följande kommando och följ anvisningarna:

winapp init

När du uppmanas att göra det:

• Paketnamn: Tryck på Retur för att acceptera standardvärdet (tauri-app)
• Utgivarens namn: Tryck på Enter för att acceptera standardvärdet eller ange ditt namn
• Version: Tryck på Retur för att acceptera 1.0.0.0
• Startpunkt: Tryck på Retur för att acceptera standardvärdet (tauri-app.exe)
• Installations-SDK:er: Välj "Konfigurera inte SDK:er" (Tauri använder Rusts windows låda, inte C++ SDK-huvudena)

Det här kommandot kommer att:

• Skapa Package.appxmanifest – manifestet som definierar appens identitet
• Skapa Assets mapp – ikoner som krävs för MSIX-paketering och Lagringsöverföring

Du kan öppna Package.appxmanifest för att ytterligare anpassa egenskaper som visningsnamn, utgivare och funktioner.

4. Felsöka med identitet

För att felsöka med identitet måste vi bygga Rust-backend och köra den med winapp run. Eftersom npm run tauri dev hanterar processlivscykeln är det svårare att mata in identiteten där. I stället skapar vi ett anpassat skript. Inget certifikat eller signering krävs för felsökning.

1. Lägg till skript: Öppna package.json och lägg till ett nytt skript tauri:dev:withidentity:

   "scripts": {
     "tauri": "tauri",
     "tauri:dev:withidentity": "cargo build --manifest-path src-tauri/Cargo.toml && (if not exist dist mkdir dist) && copy /Y src-tauri\\target\\debug\\tauri-app.exe dist\\ >nul && winapp run .\\dist"
   }
   

   Det här skriptet gör:

   • cargo build ...: Omkompileras Rust-serverdelen.
   • copy ... dist\\: Förbereder bara exe till en dist-mapp (target\debug-mappen är mycket stor och innehåller artefakter från mellanliggande byggfaser som inte ingår i din app).
   • winapp run .\\dist: Registrerar ett löst layoutpaket (precis som en riktig MSIX-installation) och startar appen.

2. Kör skriptet:

   npm run tauri:dev:withidentity
   

Nu bör appen vara öppen och visa ett paketfamiljenamn som bekräftar att den körs med programidentitet! Nu kan du börja använda och felsöka API:er som kräver paketidentitet, till exempel Meddelanden eller nya AI-API:er som Phi Silica.

5. Paket med MSIX

När du är redo att distribuera din app kan du paketera den som en MSIX som tillhandahåller paketidentiteten till ditt program.

Lägg först till ett pack:msix skript i package.json:

"scripts": {
  "tauri": "tauri",
  "tauri:dev:withidentity": "...",
  "pack:msix": "npm run tauri -- build && (if not exist dist mkdir dist) && copy /Y src-tauri\\target\\release\\tauri-app.exe dist\\ >nul && winapp pack .\\dist --cert .\\devcert.pfx"
}

Det här skriptet gör:

• npm run tauri -- build: Bygger Rust-backenden i releaseläge.
• copy ... dist\\: Förbereder bara exe till en dist-mapp (target\release-mappen är mycket stor och innehåller artefakter från mellanliggande byggfaser som inte ingår i din app).
• winapp pack .\\dist --cert .\\devcert.pfx: Paketerar och signerar appen som MSIX.

Generera ett utvecklingscertifikat

MSIX-paket måste signeras. För lokal testning genererar du ett självsignerat utvecklingscertifikat:

winapp cert generate --if-exists skip

Bygg, Staging och Packning

npm run pack:msix

Installera certifikatet

Innan du kan installera MSIX-paketet måste du lita på utvecklingscertifikatet på datorn. Kör det här kommandot som administratör (du behöver bara göra det en gång per certifikat):

winapp cert install .\devcert.pfx

Installera och kör

Installera paketet genom att dubbelklicka på den genererade .msix filen eller använda PowerShell:

Add-AppxPackage .\tauri-app.msix

När du har installerat den kan du starta appen från Start-menyn. Du bör se att appen körs med identitet.

Tips

1. När du är redo för distribution kan du signera MSIX med ett kodsigneringscertifikat från en certifikatutfärdare så att användarna inte behöver installera ett självsignerat certifikat.
2. Microsoft Store signerar MSIX åt dig, du behöver inte signera innan det skickas in.
3. Du kan behöva skapa flera MSIX-paket, ett för varje arkitektur som du stöder (x64, Arm64).

Nästa steg

• Distribute via winget: Skicka din MSIX till Windows Správca balíkov Community Repository
• Publicera till Microsoft Store: Skicka paketet med winapp store
• Set up CI/CD: Använd setup-WinAppCli GitHub Action för att automatisera paketeringen i din pipeline
• Explore Windows API:er: Med paketidentitet kan du nu använda notiser, AI på enheten och andra identitetsberoende API:er