Korzystanie z narzędzia winapp CLI z Tauri

W tym przewodniku pokazano, jak używać interfejsu winapp wiersza polecenia z aplikacją Tauri do debugowania przy użyciu tożsamości pakietu i spakowania aplikacji jako pliku MSIX.

Tożsamość pakietu jest podstawową koncepcją w modelu Windows app. Umożliwia Twojej aplikacji dostęp do specyficznych interfejsów API Windows (takich jak powiadomienia, zabezpieczenia, interfejsy API sztucznej inteligencji itp.), zapewnia czyste środowisko instalacji i dezinstalacji oraz oferuje wiele innych funkcji.

Aby zapoznać się z kompletnym przykładem roboczym, sprawdź przykład Tauri w tym repozytorium.

Wymagania wstępne

Windows 11
Node.js - winget install OpenJS.NodeJS --source winget
Rust Toolchain — zainstaluj rust przy użyciu rustup lub winget install Rustlang.Rustup --source winget
interfejs wiersza polecenia aplikacji winapp - winget install microsoft.winappcli --source winget

Wskazówka

Jeśli masz je już zainstalowane, uruchom mimo to winget install polecenia, aby sprawdzić dostępność aktualizacji.

1. Tworzenie nowej aplikacji Tauri

Zacznij od utworzenia nowej aplikacji Tauri przy użyciu oficjalnego narzędzia do generowania szablonu.

npm create tauri-app@latest

Postępuj zgodnie z monitami:

Nazwa projektu: tauri-app (lub preferowana nazwa)
Język frontonu: JavaScript
Menedżer pakietów: npm
Szablon interfejsu użytkownika: Vanilla
Smak interfejsu użytkownika: JavaScript

Przejdź do katalogu project i zainstaluj zależności:

cd tauri-app
npm install

Uruchom aplikację, aby upewnić się, że wszystko działa:

npm run tauri dev

2. Zaktualizuj kod, aby sprawdzić tożsamość

Zaktualizujemy aplikację, aby sprawdzić, czy jest ona uruchomiona przy użyciu tożsamości pakietu. Użyjemy windows crate w backendzie Rust, aby uzyskać dostęp do interfejsów API Windows i udostępnić go frontendowi.

Zmiany back-endu (Rust)

Dodaj zależność: Otwórz src-tauri/Cargo.toml i dodaj następujące wiersze na końcu pliku. Spowoduje to dodanie powiązań interfejsu API Windows, abyśmy mogli sprawdzić tożsamość pakietu:
```
[target.'cfg(windows)'.dependencies]
windows = { version = "0.58", features = ["ApplicationModel"] }
```

Dodaj polecenie: otwórz src-tauri/src/lib.rs i dodaj get_package_family_name funkcję. Umieść ją przed funkcją pub fn run() :

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

Zarejestruj polecenie: W tym samym pliku (src-tauri/src/lib.rs) zaktualizuj run funkcję, aby zarejestrować nowe polecenie:

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

Zmiany frontonu (JavaScript)

Zaktualizuj kod HTML: Otwórz src/index.html i dodaj akapit, aby wyświetlić wynik:
```

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

Aktualizacja logiki: otwórz polecenie src/main.js , aby wywołać polecenie i wyświetlić wynik:

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

Teraz uruchom aplikację w zwykły sposób:
```
npm run tauri dev
```
W oknie aplikacji powinna być widoczna wiadomość "Nie działa z tożsamością pakietu". Potwierdza to, że standardowa kompilacja programowa jest uruchomiona bez tożsamości pakietu.

3. Zainicjuj projekt za pomocą interfejsu wiersza poleceń winapp

Polecenie winapp init konfiguruje wszystko, czego potrzebujesz w jednym miejscu: manifest aplikacji i zasoby. Manifest definiuje tożsamość aplikacji (nazwę, wydawcę, wersję), która Windows używa do udzielania dostępu do interfejsu API.

Uruchom następujące polecenie i postępuj zgodnie z monitami:

winapp init

Po wyświetleniu monitu:

Nazwa pakietu: naciśnij klawisz Enter, aby zaakceptować wartość domyślną (tauri-app)
Nazwa wydawcy: Naciśnij klawisz Enter, aby zaakceptować wartość domyślną lub wprowadź swoją nazwę
Wersja: Naciśnij klawisz Enter, aby zaakceptować 1.0.0.0
Punkt wejścia: Naciśnij klawisz Enter, aby zaakceptować wartość domyślną (tauri-app.exe)
Skonfiguruj zestawy SDK: wybierz opcję "Nie konfiguruj zestawów SDK" (Tauri używa pakietu Rust windows, a nie nagłówków SDK języka C++)

To polecenie spowoduje:

Utwórz Package.appxmanifest — manifest, który definiuje tożsamość aplikacji
Utwórz folder Assets — ikony wymagane do tworzenia pakietów MSIX i wysyłania do Sklepu

Uwaga / Notatka

Ponieważ nie są zarządzane żadne pakiety SDK, nie jest tworzony winapp.yaml — Tauri używa biblioteki Rust windows za pośrednictwem Cargo, więc nie ma nic do śledzenia przez winapp restore/update.

Możesz otworzyć Package.appxmanifest aby jeszcze bardziej dostosować właściwości, takie jak nazwa wyświetlana, wydawca i funkcje.

4. Debugowanie przy użyciu tożsamości

Aby debugować z użyciem tożsamości, musimy skompilować backend w Rust i uruchomić go przy użyciu polecenia winapp run. Ponieważ npm run tauri dev zarządza cyklem życia procesu, trudniej jest tam wstrzyknąć tożsamość. Zamiast tego utworzymy skrypt niestandardowy. Do debugowania nie jest wymagany żaden certyfikat ani podpisywanie.

Dodaj skrypt: Otwórz package.json i dodaj nowy skrypt 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 robi ten skrypt:
- cargo build ...: Ponownie kompiluje zaplecze Rust.
- copy ... dist\\: Przechowuje tylko plik exe w folderze dist (folder target\debug ma dużą objętość i zawiera artefakty kompilacji pośredniej, które nie są częścią aplikacji).
- winapp run .\\dist: rejestruje luźny pakiet układu (podobnie jak prawdziwa instalacja MSIX) i uruchamia aplikację.
Uruchom skrypt:
```
npm run tauri:dev:withidentity
```

Wskazówka

Może zostać wyświetlone okno terminalu/konsoli za oknem aplikacji — jest to normalne w przypadku kompilacji debugowania Tauri (jest to konsola procesu Rust).

Aplikacja powinna teraz się otworzyć i wyświetlić "Nazwa rodziny pakietów", co potwierdza, że działa z określoną tożsamością! Teraz możesz zacząć korzystać i debugować interfejsy API, które wymagają tożsamości pakietu, takie jak Powiadomienia lub nowe interfejsy API sztucznej inteligencji, takie jak Phi Silica.

Wskazówka

winapp run rejestruje również pakiet w systemie. Dlatego plik MSIX może być wyświetlany jako "już zainstalowany" podczas próby zainstalowania go w dalszej części kroku 5. Użyj winapp unregister, aby wyczyścić pakiety programistyczne po zakończeniu pracy.

Wskazówka

Aby uzyskać zaawansowane scenariusze debugowania (dołączanie debugerów, konfigurowanie środowiska IDE, debugowanie uruchamiania), zobacz Przewodnik debugowania.

5. Pakiet z plikiem MSIX

Gdy wszystko będzie gotowe do dystrybucji aplikacji, możesz spakować ją jako plik MSIX, który zapewni tożsamość pakietu aplikacji.

Najpierw dodaj pack:msix skrypt do pliku 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 robi ten skrypt:

npm run tauri -- build: kompiluje backend Rust w trybie produkcyjnym.
copy ... dist\\: Umieszcza tylko plik exe w katalogu dist (katalog target\release jest bardzo duży i zawiera pośrednie pliki wynikowe kompilacji, które nie należą do aplikacji).
winapp pack .\\dist --cert .\\devcert.pfx: Pakuje i podpisuje aplikację jako MSIX.

Generowanie certyfikatu programistycznego

Pakiety MSIX muszą być podpisane. Na potrzeby testowania lokalnego wygeneruj certyfikat programowania z podpisem własnym:

winapp cert generate --if-exists skip

Wskazówka

Wydawca certyfikatu musi być zgodny z Publisher w Package.appxmanifest. Polecenie cert generate odczytuje to automatycznie z manifestu.

Budowa, środowisko testowe i pakowanie

npm run pack:msix

Wskazówka

Polecenie pack automatycznie używa pliku Package.appxmanifest z bieżącego katalogu i kopiuje go do folderu docelowego przed opakowaniem. Wygenerowany plik msix będzie znajdować się w bieżącym katalogu.

Instalowanie certyfikatu

Przed zainstalowaniem pakietu MSIX należy ufać certyfikatowi programistycznemu na maszynie. Uruchom to polecenie jako administrator (wystarczy to zrobić tylko raz na certyfikat):

winapp cert install .\devcert.pfx

Instalowanie i uruchamianie

Wskazówka

Jeśli użyto winapp run w kroku 4, pakiet może być już zarejestrowany w systemie. Najpierw usuń rejestrację deweloperską winapp unregister, a następnie zainstaluj pakiet produkcyjny.

Zainstaluj pakiet, klikając dwukrotnie wygenerowany .msix plik lub przy użyciu programu PowerShell:

Add-AppxPackage .\tauri-app.msix

Wskazówka

Nazwa pliku MSIX zawiera wersję i architekturę (np. tauri-app_1.0.0.0_x64.msix). Sprawdź katalog pod kątem dokładnej nazwy pliku. Jeśli musisz ponownie spakować po zmianie kodu, zwiększ Version w Package.appxmanifest — Windows wymaga wyższego numeru wersji w celu zaktualizowania zainstalowanego pakietu.

Po zainstalowaniu możesz uruchomić aplikację z menu Start. Powinieneś zobaczyć, że aplikacja działa z tożsamością.

Porady

Gdy wszystko będzie gotowe do dystrybucji, możesz podpisać plik MSIX przy użyciu certyfikatu podpisywania kodu z urzędu certyfikacji, aby użytkownicy nie musieli instalować certyfikatu z podpisem własnym.
Microsoft Store podpisze plik MSIX bez konieczności podpisywania przed przesłaniem.
Może być konieczne utworzenie wielu pakietów MSIX — po jednym dla każdej obsługiwanej architektury (x64, Arm64).

Dalsze kroki

Rozprowadź za pomocą narzędzia winget: Prześlij swój plik MSIX do Windows Menedżer pakietów Community Repository
Publikuj w Microsoft Store: Użyj winapp store aby przesłać pakiet
Konfigurowanie CI/CD: Użyj akcji setup-WinAppCli GitHub, aby zautomatyzować tworzenie pakietów w potoku
Zapoznaj się z interfejsami API Windows: z tożsamością pakietu możesz teraz użyć Powiadomień, AI na urządzeniu oraz innych interfejsów API zależnych od tożsamości

Opinia

Czy ta strona była pomocna?

Last updated on 2026-05-12

Korzystanie z narzędzia winapp CLI z Tauri

Wymagania wstępne

1. Tworzenie nowej aplikacji Tauri

2. Zaktualizuj kod, aby sprawdzić tożsamość

Zmiany back-endu (Rust)

Zmiany frontonu (JavaScript)

3. Zainicjuj projekt za pomocą interfejsu wiersza poleceń winapp

4. Debugowanie przy użyciu tożsamości

5. Pakiet z plikiem MSIX

Generowanie certyfikatu programistycznego

Budowa, środowisko testowe i pakowanie

Instalowanie certyfikatu

Instalowanie i uruchamianie

Porady

Dalsze kroki

Opinia

Dodatkowe zasoby