Použití rozhraní příkazového řádku winapp s tauri

Tato příručka ukazuje, jak použít winapp rozhraní příkazového řádku v aplikaci Tauri k ladění pomocí identity balíčku a vytvoření instalačního balíčku aplikace jako MSIX.

Identita balíčku je základním konceptem modelu Windows app. Umožňuje vaší aplikaci přistupovat ke konkrétním rozhraním API Windows (jako jsou oznámení, zabezpečení, rozhraní API AI atd.), mají čisté prostředí pro instalaci a odinstalaci a další.

Kompletní funkční příklad najdete v ukázce Tauri v tomto repozitáři.

Předpoklady

Windows 11
Node.js - winget install OpenJS.NodeJS --source winget
Sada nástrojů Rust – Instalace Rustu pomocí rustupu nebo winget install Rustlang.Rustup --source winget
winapp CLI - winget install microsoft.winappcli --source winget

Tip

Pokud už máte tyto nástroje nainstalované, spusťte příkazy winget install, abyste zkontrolovali aktualizace.

1. Vytvoření nové aplikace Tauri

Začněte vytvořením nové aplikace Tauri pomocí oficiálního nástroje pro generování uživatelského rozhraní:

npm create tauri-app@latest

Postupujte podle pokynů:

Název projektu: tauri-app (nebo preferovaný název)
Jazyk front-endu: JavaScript
Správce balíčků: npm
Šablona uživatelského rozhraní: Vanilla
Příchuť uživatelského rozhraní: JavaScript

Přejděte do adresáře project a nainstalujte závislosti:

cd tauri-app
npm install

Spusťte aplikaci, abyste měli jistotu, že všechno funguje:

npm run tauri dev

2. Aktualizace kódu pro kontrolu identity

Aplikaci aktualizujeme a zkontrolujeme, jestli běží s identitou balíčku. Použijeme windows bednu v back-endu Rustu pro přístup k rozhraním API Windows a zpřístupníme ji front-endu.

Změny backendu (Rust)

Přidat závislost: Otevřete src-tauri/Cargo.toml a na konec souboru přidejte následující řádky. Tím se přidají vazby rozhraní API Windows, abychom mohli zkontrolovat identitu balíčku:
```
[target.'cfg(windows)'.dependencies]
windows = { version = "0.58", features = ["ApplicationModel"] }
```

Přidat příkaz: Otevřete src-tauri/src/lib.rs a přidejte get_package_family_name funkci. Umístěte pub fn run() před funkci:

#[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()
    }
}

Příkaz Register: Ve stejném souboru (src-tauri/src/lib.rs) aktualizujte run funkci tak, aby zaregistrovala nový příkaz:

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");
}

Změny front-endu (JavaScript)

Aktualizovat KÓD HTML: Otevřete src/index.html a přidejte odstavec, který zobrazí výsledek:
```

<p id="pfn-msg"></p>
```

Update Logic: Otevřete src/main.js, aby se vyvolal příkaz a zobrazil výsledek:

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();
});

Teď spusťte aplikaci obvyklým způsobem:
```
npm run tauri dev
```
V okně aplikace byste měli vidět text "Not running with package identity". Tím potvrdíte, že standardní vývojový build běží bez identity balíčku.

3. Inicializace Project pomocí rozhraní příkazového řádku winapp

Příkaz winapp init nastaví vše, co potřebujete na jednom místě: manifest aplikace a prostředky. Manifest definuje identitu vaší aplikace (název, vydavatel, verzi), která Windows používá k udělení přístupu k rozhraní API.

Spusťte následující příkaz a postupujte podle pokynů:

winapp init

Po zobrazení výzvy:

Název balíčku: Stisknutím klávesy Enter přijměte výchozí hodnotu (tauri-app).
Publisher název: Stisknutím klávesy Enter přijměte výchozí hodnotu nebo zadejte své jméno.
Verze: Stisknutím klávesy Enter přijměte verzi 1.0.0.0.
Vstupní bod: Stisknutím klávesy Enter přijměte výchozí (tauri-app.exe)
Instalační sady SDK: Vyberte "Nenastavovat sady SDK" (Tauri používá Rust cratewindows, ne hlavičky sady C++ SDK).

Tento příkaz:

Vytvoření Package.appxmanifest – manifest, který definuje identitu vaší aplikace
Vytvoření Assets složky – ikony vyžadované pro balení MSIX a odesílání do Storu

Poznámka:

Vzhledem k tomu, že se nespravují žádné balíčky SDK, nevytvoří se žádný winapp.yaml – Tauri používá Rust crate windows pomocí Cargo, takže není nic, co by winapp restore/update mohlo sledovat.

Můžete otevřít Package.appxmanifest a upravit vlastnosti, jako je zobrazovaný název, vydavatel a možnosti.

4. Ladění pomocí identity

Abychom mohli ladit pomocí identity, musíme sestavit Rust backend a spustit ho s winapp run. Vzhledem k tomu, že npm run tauri dev spravuje životní cyklus procesu, je těžší tam vložit identitu. Místo toho vytvoříme vlastní skript. Pro ladění není potřeba žádný certifikát ani podepisování.

Přidat skript: Otevřete package.json a přidejte nový 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"
}
```
Co tento skript dělá:
- cargo build ...: Rekompiluje Rust backend.
- copy ... dist\\: Vytvoří pouze exe do dist složky ( target\debug složka je velmi velká a obsahuje přechodné artefakty sestavení, které nejsou součástí vaší aplikace).
- winapp run .\\dist: Zaregistruje balíček volného rozložení (stejně jako skutečná instalace MSIX) a spustí aplikaci.
Spusťte skript:
```
npm run tauri:dev:withidentity
```

Tip

Za oknem aplikace se může zobrazit okno terminálu/konzoly — je to běžné u ladicích sestavení Tauri (je to konzola procesu Rust).

Teď byste měli vidět otevřenou aplikaci a zobrazit název rodiny balíčků a ověřit, že je spuštěná s identitou. Teď můžete začít používat a ladit rozhraní API, která vyžadují identitu balíčku, jako jsou oznámení nebo nová rozhraní API AI, jako je Phi Silica.

Tip

winapp run také zaregistruje balíček ve vašem systému. To je důvod, proč se MSIX může při pokusu o jeho instalaci později v kroku 5 zobrazit jako již nainstalovaný. Slouží winapp unregister k vyčištění vývojových balíčků po dokončení.

Tip

Pokročilé ladicí pracovní postupy (připojení ladicích programů, nastavení integrovaného vývojového prostředí, ladění po spuštění) najdete v průvodci laděním.

5. Balíček s MSIX

Jakmile budete připraveni distribuovat aplikaci, můžete ji zabalit jako MSIX, která vaší aplikaci poskytne identitu balíčku.

Nejprve přidejte pack:msix skript do svého 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"
}

Co tento skript dělá:

npm run tauri -- build: Sestaví Rust backend v produkčním režimu.
copy ... dist\\: Vytvoří pouze exe do dist složky ( target\release složka je velmi velká a obsahuje přechodné artefakty sestavení, které nejsou součástí vaší aplikace).
winapp pack .\\dist --cert .\\devcert.pfx: Balí a podepisuje aplikaci jako MSIX.

Vygenerování vývojového certifikátu

Balíčky MSIX musí být podepsané. Pro místní testování vygenerujte vývojový certifikát podepsaný svým držitelem:

winapp cert generate --if-exists skip

Tip

Publisher certifikátu musí odpovídat Publisher ve vašem Package.appxmanifest. Automaticky tento cert generate příkaz načte z manifestu.

Sestavení, fáze a balení

npm run pack:msix

Tip

Příkaz pack před zabalení automaticky použije Package.appxmanifest z aktuálního adresáře a zkopíruje ho do cílové složky. Vygenerovaný soubor .msix bude v aktuálním adresáři.

Instalace certifikátu

Než budete moct nainstalovat balíček MSIX, musíte na svém počítači důvěřovat vývojovému certifikátu. Spusťte tento příkaz jako správce (stačí to udělat jenom jednou pro každý certifikát):

winapp cert install .\devcert.pfx

Instalace a spuštění

Tip

Pokud jste tento balíček použili winapp run v kroku 4, možná už je v systému zaregistrovaný. Nejprve winapp unregister odeberte registraci vývojové verze a pak nainstalujte produkční balíček.

Nainstalujte balíček poklikáním na vygenerovaný .msix soubor nebo pomocí PowerShellu:

Add-AppxPackage .\tauri-app.msix

Tip

Název souboru MSIX zahrnuje verzi a architekturu (např tauri-app_1.0.0.0_x64.msix. ). Zkontrolujte přesný název souboru v adresáři. Pokud potřebujete po změně kódu znovu zabalit, navyšte Version v Package.appxmanifest – Windows k aktualizaci nainstalovaného balíčku vyžaduje vyšší číslo verze.

Po instalaci můžete aplikaci spustit z nabídky Start. Měla by se zobrazit aplikace spuštěná s identitou.

Tips

Jakmile budete připraveni k distribuci, můžete podepisovat MSIX certifikátem pro podepisování kódu od certifikační autority, aby uživatelé nemuseli instalovat certifikát podepsaný svým držitelem.
Microsoft Store za vás podepíše MSIX, před odesláním se nemusíte podepisovat.
Možná budete muset vytvořit několik balíčků MSIX, jeden pro každou architekturu, kterou podporujete (x64, Arm64).

Další kroky

Distribuujte pomocí winget: Odešlete svůj MSIX do repizitáře Windows Správce balíčků Community
Publish do Microsoft Store: Odešlete balíček pomocí winapp store
Nastavte CI/CD: Použijte akci setup-WinAppCli GitHub ke zautomatizování balení v pipeline
prozkoumat rozhraní Windows API: S identitou balíčku teď můžete používat oznámení, AI na zařízení a další rozhraní API závislé na identitě

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-05-12